Doing blob detection on half an image

edited February 2014 in Library Questions

Hi, A question from one of the Processing examples for blob detection. Here is the code:

import blobDetection.*;

BlobDetection theBlobDetection;
PGraphics img;

// ==================================================
// setup()
// ==================================================
void setup()
{
  // Works with Processing 1.5
  // img = createGraphics(640, 480,P2D);

  // Works with Processing 2.0b3
  img = createGraphics(640, 480);

  img.beginDraw();
  img.background(255);
  img.noStroke();
  img.fill(0);
  for (int i=0;i<20;i++) {
    float r = random(50);
    img.ellipse(random(img.width), random(img.height), r, r);
  }
  img.endDraw();

  theBlobDetection = new BlobDetection(img.width, img.height);
  theBlobDetection.setPosDiscrimination(false);
  theBlobDetection.setThreshold(0.38f);
  theBlobDetection.computeBlobs(img.pixels);

  // Size of applet
  size(img.width, img.height);
}

// ==================================================
// draw()
// ==================================================
void draw()
{
  image(img, 0, 0, width, height);
  drawBlobsAndEdges(true, true);
}

// ==================================================
// drawBlobsAndEdges()
// ==================================================
void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges)
{
  noFill();
  Blob b;
  EdgeVertex eA, eB;
  for (int n=0 ; n<theBlobDetection.getBlobNb() ; n++)
  {
    b=theBlobDetection.getBlob(n);
    if (b!=null)
    {
      // Edges
      if (drawEdges)
      {
        strokeWeight(2);
        stroke(0, 255, 0);
        for (int m=0;m<b.getEdgeNb();m++)
        {
          eA = b.getEdgeVertexA(m);
          eB = b.getEdgeVertexB(m);
          if (eA !=null && eB !=null)
            line(
            eA.x*width, eA.y*height, 
            eB.x*width, eB.y*height
              );
        }
      }

      // Blobs
      if (drawBlobs)
      {
        strokeWeight(1);
        stroke(255, 0, 0);
        rect(
        b.xMin*width, b.yMin*height, 
        b.w*width, b.h*height
          );
      }
    }
  }
}

How can I do blob detection for just half an image?? Thanks

Tagged:

Answers

  • Perhaps you can get() this half, and use the resulting PImage in the blob init?

  • Okay thanks. But any ideas on how to read half a webcam capture and pass it to blob detection?

  • This is what I have done so far, but the results aren't what I expected. Changes were made in the draw() section.

            import processing.video.*;
            import blobDetection.*;
    
            Capture cam;
            BlobDetection theBlobDetection;
            PImage img;
            boolean newFrame=false;
    
            // ==================================================
            // setup()
            // ==================================================
            void setup()
            {
              // Size of applet
              size(640, 480);
              // Capture
              cam = new Capture(this, 40*4, 30*4, 15);
                    // Comment the following line if you use Processing 1.5
                    cam.start();
    
              // BlobDetection
              // img which will be sent to detection (a smaller copy of the cam frame);
              img = new PImage(80,60); 
              theBlobDetection = new BlobDetection(img.width, img.height);
              theBlobDetection.setPosDiscrimination(true);
              theBlobDetection.setThreshold(0.2f); // will detect bright areas whose luminosity > 0.2f;
            }
    
            // ==================================================
            // captureEvent()
            // ==================================================
            void captureEvent(Capture cam)
            {
              cam.read();
              newFrame = true;
            }
    
            // ==================================================
            // draw()
            // ==================================================
            void draw()
            {
              if (newFrame)
              {
                newFrame=false;
                image(cam,0,0,width,height);
                img.copy(cam, 0, 60, cam.width, cam.height/2, 
                    0, 30, img.width, img.height/2);
                fastblur(img, 2);
    
                theBlobDetection.computeBlobs(img.pixels);
    
    
                drawBlobsAndEdges(true,true);
              }
            }
    
            // ==================================================
            // drawBlobsAndEdges()
            // ==================================================
            void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges)
            {
              noFill();
              Blob b;
              EdgeVertex eA,eB;
    
                loadPixels();
    
    
    
              for (int n=0 ; n<theBlobDetection.getBlobNb() ; n++)
              {
                b=theBlobDetection.getBlob(n);
                if (b!=null)
                {
                  // Edges
                  if (drawEdges)
                  {
                    strokeWeight(3);
                    stroke(0,255,0);
                    for (int m=0;m<b.getEdgeNb();m++)
                    {
                      eA = b.getEdgeVertexA(m);
                      eB = b.getEdgeVertexB(m);
                      if (eA !=null && eB !=null)
                        line(
                          eA.x*width, eA.y*height, 
                          eB.x*width, eB.y*height
                          );
                    }
                  }
    
                  // Blobs
                  if (drawBlobs)
                  {
                    strokeWeight(1);
                    stroke(255,0,0);
                    rect(
                      b.xMin*width,b.yMin*height,
                      b.w*width,b.h*height
                      );
                  }
    
                }
    
                  }
            }
    
            // ==================================================
            // Super Fast Blur v1.1
            // by Mario Klingemann 
            // <http://incubator.quasimondo.com>;
            // ==================================================
            void fastblur(PImage img,int radius)
            {
             if (radius<1)
                return;
    
              int w = img.width;
              int h = img.height;
              int wm = w-1;
              int hm = h-1;
              int area = w*h;
              int div = radius+radius+1;
              int r[] = new int[area];
              int g[] = new int[area];
              int b[] = new int[area];
              int rsum,gsum,bsum,x,y,i,p,p1,p2,yp,yi,yw;
              int vmin[] = new int[max(w,h)];
              int vmax[] = new int[max(w,h)];
              int[] pix = img.pixels;
              int dv[] = new int[256*div];
              for (i=0; i<256*div; i++)
                dv[i]=(i/div);
    
              yw = yi =0;
    
              for (y=0; y<h; y++)
              {
                rsum = gsum = bsum = 0;
                for(i=-radius; i<=radius; i++)
                {
                  p = pix[yi+min(wm,max(i,0))];
                  rsum += (p & 0xff0000)>>16;
                  gsum += (p & 0x00ff00)>>8;
                  bsum += p & 0x0000ff;
                }
                for (x=0; x<w; x++)
                {
    
                  r[yi]=dv[rsum];
                  g[yi]=dv[gsum];
                  b[yi]=dv[bsum];
    
                  if(y==0)
                  {
                    vmin[x] = min(x+radius+1,wm);
                    vmax[x] = max(x-radius,0);
                  }
                  p1 = pix[yw+vmin[x]];
                  p2 = pix[yw+vmax[x]];
    
                  rsum += ((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
                  gsum += ((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
                  bsum += (p1 & 0x0000ff)-(p2 & 0x0000ff);
                  yi++;
                }
                yw+=w;
              }
    
              for (x=0; x<w; x++)
              {
                rsum = gsum = bsum = 0;
                yp =- radius*w;
                for(i = -radius; i<=radius; i++){
                  yi = max(0,yp)+x;
                  rsum += r[yi];
                  gsum += g[yi];
                  bsum += b[yi];
                  yp += w;
                }
                yi = x;
                for (y=0; y<h; y++)
                {
                  pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
                  if(x==0)
                  {
                    vmin[y] = min(y+radius+1,hm)*w;
                    vmax[y] = max(y-radius,0)*w;
                  }
                  p1 = x+vmin[y];
                  p2 = x+vmax[y];
    
                  rsum += r[p1]-r[p2];
                  gsum += g[p1]-g[p2];
                  bsum += b[p1]-b[p2];
    
                  yi += w;
                }
              }
    
            }
    
  • "any ideas on how to read half a webcam capture and pass it to blob detection?"
    That's what I meant with my reference (obscure, perhaps), to get().

Sign In or Register to comment.