...
Wird eine Kinect Kamera v1 verwendet, muss die Referenz und Initialisierung entsprechend angepasst werden:
Code Block |
---|
Kinect kinect; // ohne "2"
void setup() {
kinect = new Kinect2Kinect(this);
kinect.initDevice();
} |
...
Code Block |
---|
void videoEvent(Kinect k) {
// There has been a video event!
} |
Infrarot Bild
Zuerst muss der Infrarot-Stream der Kamera in der setup()
Funktion aktiviert werden:
Code Block |
---|
kinect.initIR();
kinect.initDevice(); |
Dann kann das aktuelle Bild gelesen werden:
Code Block |
---|
PImage irImage = kinect.getIrImage(); |
Code Block |
---|
title | Beispiel |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
void setup() {
size(640, 360);
kinect = new |
Code Block |
---|
title | Beispiel |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
void setup() {
size(1920, 1080);
kinect = new Kinect2(this);
kinect.initIRinitVideo();
kinect.initDevice();
}
void draw() {
image(kinect.getIrImagegetVideoImage(), 0, 0);
} |
...
Infrarot Bild
Zuerst muss der TiefenbildInfrarot-Stream der Kamera in der setup()
Funktion aktiviert werden:
Code Block |
---|
kinect.initDepthinitIR();
kinect.initDevice(); |
Um das Tiefenbild als Graustufen zurückzubekommen wird folgendes gemachtDann kann das aktuelle Bild gelesen werden:
Code Block |
---|
PImage depthImageirImage = kinect.getDepthImagegetIrImage(); |
Code Block |
---|
title | Beispiel |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
void setup() {
size(512, 424);
kinect = new Kinect2(this);
kinect.initDepthinitIR();
kinect.initDevice();
}
void draw() {
image(kinect.getDepthImagegetIrImage(), 0, 0);
} |
Tiefenarray
Der Nachteil des Graustufen-Tiefenbildes ist es, dass alle Entfernungsinformationen auf Werte zwischen 0 bis 255 (Helligkeit) verteilt werden. Tatsächlich kann die Kinect Kamera aber eine viel genauere Auflösung der Tiefeninformationen liefern. Dazu ist es jedoch nötig, das Tiefenarray aufzurufen und auszulesen. Dies geschieht über:
...
Tiefenbild
Zuerst muss der Tiefenbild-Stream der Kamera in der setup()
Funktion aktiviert werden:
Code Block |
---|
kinect.initDepth();
kinect.initDevice(); |
Um das Tiefenbild als Graustufen zurückzubekommen wird folgendes gemacht:
Code Block |
---|
PImage depthImage = kinect.getRawDepthgetDepthImage(); |
Code Block |
---|
title | Beispiel |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
import peasy.*;
Kinect2 kinect;
PeasyCam
cam;
void setup() {
size(512, 424, P3D);
cam = new PeasyCam(this, 1000);
cam.setMaximumDistance(5000);
);
kinect = new Kinect2(this);
kinect.initDepth();
kinect.initDevice();
}
void draw() {
background(0);
int[] depthMap = kinect.getRawDepth();
int stepSize = 2;
for(int x=0; x<kinect.depthWidth; x+=stepSize) {
for(int y=0; y<kinect.depthHeight; y+=stepSize) {
int loc = x+y*kinect.depthWidth;
PVector point = depthToPointCloudPos(x, y, depthMap[loc]);
stroke(255);
point(point.x, point.y, point.zimage(kinect.getDepthImage(), 0, 0);
} |
Tiefenarray
Der Nachteil des Graustufen-Tiefenbildes ist es, dass alle Entfernungsinformationen auf Werte zwischen 0 bis 255 (Helligkeit) verteilt werden. Tatsächlich kann die Kinect Kamera aber eine viel genauere Auflösung der Tiefeninformationen liefern. Dazu ist es jedoch nötig, das Tiefenarray aufzurufen und auszulesen. Dies geschieht über:
Code Block |
---|
int[] depth = kinect.getRawDepth(); |
Code Block |
---|
title | Beispiel |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
import peasy.*;
Kinect2 kinect;
PeasyCam cam;
void setup() {
size(1920, 1080, P3D);
cam = new PeasyCam(this, 1000);
cam.setMaximumDistance(5000);
} kinect = }
}new Kinect2(this);
PVector depthToPointCloudPos(int x, int y, float depthValue) {
PVector point = new PVector();
point.z = (depthValue);
point.x = (x - CameraParams.cx) * point.z / CameraParams.fx;
point.y = (y - CameraParams.cy) * point.z / CameraParams.fy;
return point;
}
static class CameraParams {
static float cx = 254.878f;
static float cy = 205.395f;
static float fx = 365.456f;
static float fy = 365.456f;
static float k1 = 0.0905474;
static float k2 = -0.26819;
static float k3 = 0.0950862;
static float p1 = 0.0;
static float p2 = 0.0;
} |
Angleichung
Weil bei der Kinect Kamera der Sensor für das RGB Bild und das Titelbild nicht übereinanderliegen stimmen die Positionen in XY Richtung der einen Kamera, nicht mit denen der anderen überein. Um dies zu korrigieren kann ein RGB Bild angefordert werden, welches durch die Library angepasst wird. Dieses Bild bekommt man über:
Code Block |
---|
PImage img = kinect2.getRegisteredImage(); |
Code Block |
---|
title | Beispiel |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
void setup() {
size(512, 424);
kinect = new Kinect2(this);
kinect.initRegistered();
kinect.initDevice();
}
void draw() {
image(kinect.getRegisteredImage(), 0, 0);
} |
Übersicht der Funktionen
Hier eine Übersicht der Funktionen, welche die Library zur Verfügung stellt:
initVideo()
— Video Bild initialisieren initIR()
—Infrarot Bild initialisiereninitDepth()
— Tiefenbild initialisieren
initDevice()
— Gerät initialisierenPImage getVideoImage()
— RGB BildPImage getIrImage()
— IR BildPImage getDepthImage()
— TiefenbildPImage getRegisteredImage()
— Angeglichenes RGB Bildint[] getRawDepth()
— Tiefenarray
Für weitere Informationen: the javadoc reference.
Weitere Beispiele
Code Block |
---|
title | Kinect Test |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
void setup() {
size(1024, 848);
kinect = new Kinect2(this);
kinect.initVideo();
kinect.initDepth();
kinect.initIR();
kinect.initRegistered();
kinect.initDevice();
}
void draw() {
background(0);
image(kinect.getVideoImage(), 0, 0, kinect.depthWidth, kinect.depthHeight);
image(kinect.getDepthImage(), kinect.depthWidth, 0);
image(kinect.getIrImage(), 0, kinect.depthHeight);
image(kinect.getRegisteredImage(), kinect.depthWidth, kinect.depthHeight);
fill(255);
text("Framerate: " + (int)(frameRate), 10, 515);
} |
Code Block |
---|
title | Depth Threshold |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
int lowerThreshold = 0;
int upperThreshold = 750;
void setup() {
size(512, 424);
kinect = new Kinect2(this);
kinect.initDepth();
kinect.initDevice();
}
void draw() {
PImage img = kinect.getDepthImage();
int[] depthMap = kinect.getRawDepth();
loadPixels();
for (int x = 0; x < kinect.depthWidth; x++) {
for (int y = 0; y < kinect.depthHeight; y++) {
int loc = x+ y * kinect.depthWidth;
int rawDepth = depthMap[loc];
if (rawDepth > lowerThreshold && rawDepth < upperThreshold) {
pixels[loc] = color(150, 50, 50);
} else {
pixels[loc] = img.pixels[loc];
}
}
}
updatePixels();
}kinect.initDepth();
kinect.initDevice();
}
void draw() {
background(0);
int[] depthMap = kinect.getRawDepth();
int stepSize = 2;
for(int x=0; x<kinect.depthWidth; x+=stepSize) {
for(int y=0; y<kinect.depthHeight; y+=stepSize) {
int loc = x+y*kinect.depthWidth;
PVector point = depthToPointCloudPos(x, y, depthMap[loc]);
stroke(255);
point(point.x, point.y, point.z);
}
}
}
PVector depthToPointCloudPos(int x, int y, float depthValue) {
PVector point = new PVector();
point.z = (depthValue);
point.x = (x - CameraParams.cx) * point.z / CameraParams.fx;
point.y = (y - CameraParams.cy) * point.z / CameraParams.fy;
return point;
}
static class CameraParams {
static float cx = 254.878f;
static float cy = 205.395f;
static float fx = 365.456f;
static float fy = 365.456f;
static float k1 = 0.0905474;
static float k2 = -0.26819;
static float k3 = 0.0950862;
static float p1 = 0.0;
static float p2 = 0.0;
} |
Angleichung
Weil bei der Kinect Kamera der Sensor für das RGB Bild und das Titelbild nicht übereinanderliegen stimmen die Positionen in XY Richtung der einen Kamera, nicht mit denen der anderen überein. Um dies zu korrigieren kann ein RGB Bild angefordert werden, welches durch die Library angepasst wird. Dieses Bild bekommt man über:
Code Block |
---|
PImage img = kinect2.getRegisteredImage(); |
Code Block |
---|
title | Beispiel |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
void setup() {
size(512, 424);
kinect = new Kinect2(this);
kinect.initRegistered();
kinect.initDevice();
}
void draw() {
image(kinect.getRegisteredImage(), 0, 0);
} |
Übersicht der Funktionen
Hier eine Übersicht der Funktionen, welche die Library zur Verfügung stellt:
initVideo()
— Video Bild initialisieren initIR()
—Infrarot Bild initialisiereninitDepth()
— Tiefenbild initialisieren
initDevice()
— Gerät initialisierenPImage getVideoImage()
— RGB BildPImage getIrImage()
— IR BildPImage getDepthImage()
— TiefenbildPImage getRegisteredImage()
— Angeglichenes RGB Bildint[] getRawDepth()
— Tiefenarray
Für weitere Informationen: the javadoc reference.
Weitere Beispiele
Code Block |
---|
title | Kinect Test |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
void setup() {
size(1024, 848);
kinect = new Kinect2(this);
kinect.initVideo();
kinect.initDepth();
kinect.initIR();
kinect.initRegistered();
kinect.initDevice();
}
void draw() {
background(0);
image(kinect.getVideoImage(), 0, 0, kinect.depthWidth, kinect.depthHeight);
image(kinect.getDepthImage(), kinect.depthWidth, 0);
image(kinect.getIrImage(), 0, kinect.depthHeight);
image(kinect.getRegisteredImage(), kinect.depthWidth, kinect.depthHeight);
fill(255);
text("Framerate: " + (int)(frameRate), 10, 515);
} |
Code Block |
---|
title | Depth Threshold |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
int lowerThreshold = 0;
int upperThreshold = 750;
void setup() {
size(512, 424);
kinect = new Kinect2(this);
kinect.initDepth();
kinect.initDevice();
}
void draw() {
PImage img = kinect.getDepthImage();
int[] depthMap = kinect.getRawDepth();
loadPixels();
for (int x = 0; x < kinect.depthWidth; x++) {
for (int y = 0; y < kinect.depthHeight; y++) {
int loc = x+ y * kinect.depthWidth;
int rawDepth = depthMap[loc];
if (rawDepth > lowerThreshold && rawDepth < upperThreshold) {
pixels[loc] = color(150, 50, 50);
} else {
pixels[loc] = img.pixels[loc];
}
}
}
updatePixels();
} |
Code Block |
---|
title | Background Removal and mass centre |
---|
collapse | true |
---|
|
import org.openkinect.processing.*;
Kinect2 kinect;
int[] depthMapRef;
int[] depthMap;
int Threshold = 30;
int depthlength;
// Raw location
PVector loc = new PVector(0, 0);
// Interpolated location
PVector lerpedLoc = new PVector(0, 0);
// Depth data
int[] depth;
void setup() {
size(640, 520);
depthlength = 640*480;
kinect = new Kinect2(this);
kinect.initDepth();
kinect.initDevice();
depthMapRef = new int[depthlength];
}
void draw() {
float sumX = 0;
float sumZ = 0;
float sumY = 0;
float count = 0;
fill(255, 255, 255, 1);
rect(0, 0, width, height);
PImage img = kinect.getDepthImage();
depthMap = kinect.getRawDepth();
if (depthMapRef == null) {
arrayCopy(depthMap, depthMapRef);
}
img.loadPixels();
for (int x = 0; x < kinect.depthWidth; x++) {
for (int y = 0; y < kinect.depthHeight; y++) {
int loc = x+ y * kinect.depthWidth;
int difference = abs(depthMap[loc]-depthMapRef[loc]);
if ( difference > Threshold) {
sumX += x;
sumY += y;
sumZ += depthMap[loc];
count++;
img.pixels[loc] = color(150, 50, 50);
} else {
img.pixels[loc] = img.pixels[loc];
}
}
}
img.updatePixels();
image(img, 0, 0);
// find the average location of the "body mass"
if (count != 0) {
loc = new PVector(sumX/count, sumY/count, sumZ/count);
}
// Interpolating the location with lerp for a smoother animation
lerpedLoc.x = PApplet.lerp(lerpedLoc.x, loc.x, 0.3f);
lerpedLoc.y = PApplet.lerp(lerpedLoc.y, loc.y, 0.3f);
lerpedLoc.z = PApplet.lerp(lerpedLoc.z, loc.z, 0.3f);
fill(255);
text("depth:" +lerpedLoc.z+"", lerpedLoc.x+5, lerpedLoc.y);
ellipse(lerpedLoc.x, lerpedLoc.y, 5, 5);
}
void mousePressed() {
background(255);
arrayCopy(depthMap, depthMapRef);
}
|