Question

我正在尝试提取用户剪影并将其放在我的图像上方。我能够制作一个面具并从rgb图像切割用户。但轮廓很乱。

问题是如何使面具更精确（适合真实用户）。我已经尝试过ERODE-DILATE过滤器，但它们没有做太多。也许我需要像Photoshop一样的羽毛过滤器。或者我不知道。

这是我的代码。

import SimpleOpenNI.*;
SimpleOpenNI  context;
PImage mask;
void setup()
{
  size(640*2, 480);
  context = new SimpleOpenNI(this);
  if (context.isInit() == false)
  {        
    exit();
    return;
  }
  context.enableDepth(); 
  context.enableRGB();
  context.enableUser();
  context.alternativeViewPointDepthToImage();     
}

void draw()
{
  frame.setTitle(int(frameRate) + " fps");     
  context.update();
  int[] userMap = context.userMap();  
  background(0, 0, 0);
  mask = loadImage("black640.jpg");  //just a black image  
  int xSize = context.depthWidth();
  int ySize = context.depthHeight();  
  mask.loadPixels();
  for (int y = 0; y < ySize; y++) {      
    for (int x = 0; x < xSize; x++) {        
      int index = x + y*xSize;     
      if (userMap[index]>0) {  
        mask.pixels[index]=color(255, 255, 255);
      }
    }
  }
  mask.updatePixels();
  image(mask, 0, 0);
  mask.filter(DILATE);  
  mask.filter(DILATE);         
  PImage rgb = context.rgbImage();
  rgb.mask(mask);  
  image(rgb, context.depthWidth() + 10, 0);
}

Answer 1

你很好地对齐RGB和深度流。在效率方面几乎无法改进：

无需在每一帧（在draw（）循环中）重新加载黑色图像，因为您无论如何都在修改所有像素：

mask = loadImage("black640.jpg");  //just a black image

此外，由于循环访问用户数据时不需要x，y坐标，因此可以使用单个for循环，这应该更快一些：

  for(int i = 0 ; i < numPixels ; i++){
    mask.pixels[i] = userMap[i] > 0 ? color(255) : color(0);
  }

而不是：

for (int y = 0; y < ySize; y++) {      
    for (int x = 0; x < xSize; x++) {        
      int index = x + y*xSize;     
      if (userMap[index]>0) {  
        mask.pixels[index]=color(255, 255, 255);
      }
    }
  }

你可以做的另一个hacky事是从SimpleOpenNI而不是userImage()检索userData()并对其应用THRESHOLD过滤器，理论上应该给你相同的结果上方。

例如：

int[] userMap = context.userMap();  
  background(0, 0, 0);
  mask = loadImage("black640.jpg");  //just a black image  
  int xSize = context.depthWidth();
  int ySize = context.depthHeight();  
  mask.loadPixels();
  for (int y = 0; y < ySize; y++) {      
    for (int x = 0; x < xSize; x++) {        
      int index = x + y*xSize;     
      if (userMap[index]>0) {  
        mask.pixels[index]=color(255, 255, 255);
      }
    }
  }

可能是：

mask = context.userImage();
mask.filter(THRESHOLD);

在过滤方面，如果你想缩小轮廓，你应该ERODE和bluring应该给你一些像羽毛一样的Photoshop。

请注意，某些filter()次调用会使用参数（例如BLUR），但其他调用不喜欢ERODE / DILATE形态过滤器，但您仍然可以使用自己的循环来处理。

我还建议在玩过滤器时使用某种易于调整的界面（它可以是花哨的滑块或简单的键盘快捷键）。

以下是对重构草图的粗略尝试以及上述评论：

import SimpleOpenNI.*;
SimpleOpenNI  context;
PImage mask;
int numPixels = 640*480;

int dilateAmt = 1;
int erodeAmt = 1;
int blurAmt = 0;
void setup()
{
  size(640*2, 480);
  context = new SimpleOpenNI(this);

  if (context.isInit() == false)
  {        
    exit();
    return;
  }
  context.enableDepth(); 
  context.enableRGB();
  context.enableUser();
  context.alternativeViewPointDepthToImage();  
  mask = createImage(640,480,RGB);  
}

void draw()
{
  frame.setTitle(int(frameRate) + " fps");     
  context.update();
  int[] userMap = context.userMap();  
  background(0, 0, 0);

  //you don't need to keep reloading the image every single frame since you're updating all the pixels bellow anyway
//  mask = loadImage("black640.jpg");  //just a black image  

//  mask.loadPixels();

//  int xSize = context.depthWidth();
//  int ySize = context.depthHeight();  
//  for (int y = 0; y < ySize; y++) {      
//    for (int x = 0; x < xSize; x++) {        
//      int index = x + y*xSize;     
//      if (userMap[index]>0) {  
//        mask.pixels[index]=color(255, 255, 255);
//      }
//    }
//  }

  //a single loop is usually faster than a nested loop and you don't need the x,y coordinates anyway
  for(int i = 0 ; i < numPixels ; i++){
    mask.pixels[i] = userMap[i] > 0 ? color(255) : color(0);
  }
  //erode
  for(int i = 0 ; i < erodeAmt ; i++) mask.filter(ERODE);
  //dilate 
  for(int i = 0 ; i < dilateAmt; i++) mask.filter(DILATE);
  //blur  
  mask.filter(BLUR,blurAmt);

  mask.updatePixels();
  //preview the mask after you process it  
  image(mask, 0, 0);

  PImage rgb = context.rgbImage();
  rgb.mask(mask);  
  image(rgb, context.depthWidth() + 10, 0);

  //print filter values for debugging purposes
  fill(255);
  text("erodeAmt: " + erodeAmt + "\tdilateAmt: " + dilateAmt + "\tblurAmt: " + blurAmt,15,15);
}
void keyPressed(){
  if(key == 'e') erodeAmt--;
  if(key == 'E') erodeAmt++;
  if(key == 'd') dilateAmt--;
  if(key == 'D') dilateAmt++;
  if(key == 'b') blurAmt--;
  if(key == 'B') blurAmt++;
  //constrain values
  if(erodeAmt < 0) erodeAmt = 0;
  if(dilateAmt < 0) dilateAmt = 0;
  if(blurAmt < 0) blurAmt = 0;
}

不幸的是我现在无法使用实际的传感器测试，所以请使用所解释的概念，但请记住完整的草图代码未经过测试。

上面的草图（如果它运行）应该允许你使用键来控制滤波器参数（e / E减少/增加侵蚀，d / D用于扩张，b / B用于模糊）。希望你会得到满意的结果。

一般情况下，在使用SimpleOpenNI时，我建议为最常见的用例录制.oni文件（请查看 RecorderPlay 示例）。从长远来看，这将为您节省一些时间进行测试，并允许您远程操作分离的传感器。记住一件事，深度分辨率在录制时减少到一半（但使用usingRecording布尔标志应该保证安全）

最后也可能是最重要的一点是关于最终结果的质量。如果源图像开始时不易使用，那么您生成的图像可能会好得多。来自原始Kinect传感器的深度数据不是很好。华硕传感器感觉更稳定，但在大多数情况下仍然可以忽略不计。如果您要坚持使用其中一个传感器，请确保您拥有清晰的背景和适当的照明（没有太多直接的暖光（阳光，白炽灯泡等），因为它们可能会干扰传感器）

如果您想要更准确的用户剪切并且上述过滤无法获得您所追求的结果，请考虑切换到更好的传感器，如KinectV2。深度质量更好，传感器不易受直接暖光的影响。这可能意味着您需要使用Windows（我看到有KinectPV2包装器可用）或OpenFrameworks（类似于Processing的c ++库集合）ofxKinectV2

Answer 2

我在处理中尝试了内置的erode-dilate-blur。但它们效率很低。每次我在img.filter（BLUR，blurAmount）中增加blurAmount时，我的FPS会减少5帧。所以我决定尝试opencv。相比之下要好得多。结果令人满意。

import SimpleOpenNI.*;
import processing.video.*;
import gab.opencv.*;
SimpleOpenNI  context;
OpenCV opencv;
PImage mask;
int numPixels = 640*480;
int dilateAmt = 1;
int erodeAmt = 1;
int blurAmt = 1;
Movie mov;
void setup(){
  opencv = new OpenCV(this, 640, 480);
  size(640*2, 480);
  context = new SimpleOpenNI(this);
  if (context.isInit() == false) {        
    exit();
    return;
  }
  context.enableDepth(); 
  context.enableRGB();
  context.enableUser();
  context.alternativeViewPointDepthToImage();  
  mask = createImage(640, 480, RGB);
  mov = new Movie(this, "wild.mp4");
  mov.play();
  mov.speed(5);
  mov.volume(0);
}
void movieEvent(Movie m) {
  m.read();
}
void draw() {
  frame.setTitle(int(frameRate) + " fps");     
  context.update();
  int[] userMap = context.userMap();  
  background(0, 0, 0); 
  mask.loadPixels();  
  for (int i = 0; i < numPixels; i++) {
    mask.pixels[i] = userMap[i] > 0 ? color(255) : color(0);
  }
  mask.updatePixels();
  opencv.loadImage(mask);
  opencv.gray(); 
  for (int i = 0; i < erodeAmt; i++) {
    opencv.erode();
  }
  for (int i = 0; i < dilateAmt; i++) {
    opencv.dilate();
  }  
  if (blurAmt>0) {//blur with 0 amount causes error
    opencv.blur(blurAmt);
  }  
  mask = opencv.getSnapshot();  
  image(mask, 0, 0);
  PImage rgb = context.rgbImage();  
  rgb.mask(mask);  
  image(mov, context.depthWidth() + 10, 0);
  image(rgb, context.depthWidth() + 10, 0);
  fill(255);
  text("erodeAmt: " + erodeAmt + "\tdilateAmt: " + dilateAmt + "\tblurAmt: " + blurAmt, 15, 15);
}
void keyPressed() {
  if (key == 'e') erodeAmt--;
  if (key == 'E') erodeAmt++;
  if (key == 'd') dilateAmt--;
  if (key == 'D') dilateAmt++;
  if (key == 'b') blurAmt--;
  if (key == 'B') blurAmt++;
  //constrain values
  if (erodeAmt < 0) erodeAmt = 0;
  if (dilateAmt < 0) dilateAmt = 0;
  if (blurAmt < 0) blurAmt = 0;
}

如何在simple-openni中获得清晰的用户掩码？

2 个答案: