Why not send the greyscale depth image directly to the blob detection?

It seems a long way round to turn it into vectors and then back into pixels.

It is, I know... but I only want to get the vector positions that are between two defined depth ranges... 

I found your other post interesting, because at some point I've been dabbling a bit with those (javacvpro, kinect) as well, but I didn't respond there, cause I don't have advanced experience in these areas to be able to give useful advice.

In addition, it's been awhile since I dusted off my Kinect but as far as I remember those vector depth values correspond to greyscale colors. Far away is black and close is white etc. Currently you turn all into vectors and then filter out the range of your interest into points. This makes total sense because you're only displaying the points within your range of interest.

But if you were to recreate the image pixels from those vectors, what would be the color of xy-values with no vector aka those that fell out of the range earlier? As I understand it you have a min and max threshold with regard to z-depth that you use to filter vectors, which corresponds to a min and max threshold with regard to color in the greyscale depth image. But if you operate on the pixel array of the greyscale image directly, the question is also what color do you want to make the greyscale depth colors outside the range.

Given that you have as input a greyscale depth image and/or a selection of vectors, it comes down to the question what kind of image do you want to send to the blob detection. Perhaps if you know what kind of image you want to send it's easier to see what you need to do to get from your input (image and/or vectors) to your output (image to blob detection). If you could post an example of this output image here, it would also help focus this thread.

Hey Amnon, 

All right, that's clear. Besides I found my Kinect and gave it a shot myself. Below is what I came up with. Essentially all the arrays the Kinect can give you are 640x480. In retrospect, the PVector array is indeed preferred because it already has the correct depth and the PVector format is convenient. I've placed the relevant code in a seperate getBlobImage() function that just returns the image. For the image you want to go over every pixel and not use steps (as is often done for the depth point cloud). To see the result, move within the specified range.

Code Example

1. import SimpleOpenNI.*; // tested with SimpleOpenNI 0.26
2. SimpleOpenNI context;
3.  
4. float minThreshold = 1000; // minimum distance from the sensor
5. float maxThreshold = 1500; // maximum distance from the sensor
6. color blobNo = color(0); // color if it's outside the range
7. color blobYes = color(0, 255, 0); // color if it's within the range
8.  
9. void setup() {
10.   size(640, 480); // this sketch doesn't actually use 3D! ;-)
11.   context = new SimpleOpenNI(this);
12.   if (!context.enableDepth()) { exit(); return; }
13.   context.setMirror(true);
14. }
15.  
16. void draw() {
17.   context.update();
18.   PImage blobImage = getBlobImage();
19.   image(blobImage, 0, 0);
20. }
21. 
    
22. PImage getBlobImage() {
23.   PVector[] realWorldMap = context.depthMapRealWorld();
24.   PImage blobImage = createImage(context.depthWidth(), context.depthHeight(), RGB);
25.   for (int i=0; i<realWorldMap.length; i++) {
26.     PVector realWorldPoint = realWorldMap[i];
27.     color blobColor = blobNo;
28.     if (realWorldPoint.z > minThreshold && realWorldPoint.z < maxThreshold) {
29.       blobColor = blobYes;
30.     }
31.     blobImage.pixels[i] = blobColor;
32.   }
33.   return blobImage;
34. }

Quick question... 

Something like the following, with Lines 8,9,10 added ? 

Try this (untested). The non-covered area in the image below will be black. Try setting the blobNo color to red temporarily to see if it works. This is just a quick rewrite, not able to test it right now. It works like a rect with the starting xy and the widht+height for the covered area (but the returned image will always be 640x480!).

Code Example

1. PImage getBlobImage(int sx, int sy, int w, int h) {
2.   PVector[] realWorldMap = context.depthMapRealWorld();
3.   PImage blobImage = createImage(context.depthWidth(), context.depthHeight(), RGB);
4.   int maxY = min(context.depthHeight()-sy, sy+h);
5.   int maxX = min(context.depthWidth()-sx, sx+w);
6.   for (int y=sy; y<maxY; y++) {
7.     for (int x=sx; x<maxX; x++) {
8.       int index = x + y * context.depthWidth();
9.       PVector realWorldPoint = realWorldMap[index];
10.       color blobColor = blobNo;
11.       if (realWorldPoint.z > minThreshold && realWorldPoint.z < maxThreshold) {
12.         blobColor = blobYes;
13.       }
14.       blobImage.pixels[index] = blobColor;
15.     }
16.   }
17.   return blobImage;
18. }

Cheers. That makes a lot of sense... i'll give it a shot.

Expanded Question...