Doing blob detection on half an image

lki92

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

PhiLho

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

lki92

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

lki92

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;
            }
          }

        }

PhiLho

"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().