ALMOST solved…… blob detect quits under android

Android Processing

pauline303

ALMOST solved…… blob detect quits under android

in Android Processing • 7 months ago

hello all.
I use blob detection from the v3ga library under prcessing.
and it quits when the blob seems to be at the center of the screen…really weird stuff…
I put max blob detect= 1, and it doesn't seem to be a problem of size.
its not a problem of drawing, when I drawBlobsAndEdges(falsefalse), same problem…

could you reproduce this issue ?
merci

// - Super Fast Blur v1.1 by Mario Klingemann <http://incubator.quasimondo.com>
// - BlobDetection library

import ketai.camera.*;
import blobDetection.*;
float seuil;
KetaiCamera cam;
BlobDetection theBlobDetection;
PImage img;
boolean newFrame=false;

// ==================================================
// setup()
// ==================================================
void setup()
{
orientation(LANDSCAPE);

// Size of applet
size(640, 480);
// Capture
cam = new KetaiCamera(this, 640, 480, 15);
// Comment the following line if you use Processing 1.5

    // 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(seuil); // will detect bright areas whose luminosity > 0.2f;
theBlobDetection.setBlobMaxNumber(1);
}

void draw()
{
background(0);
image(cam, 0, 0, width, height);

theBlobDetection.setThreshold(0.2);
// if (newFrame)
// {
//    newFrame=false;

img.copy(cam, 0, 0, cam.width, cam.height,
0, 0, img.width, img.height);
fastblur(img, 2);
theBlobDetection.computeBlobs(img.pixels);
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);
    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 wh=w*h;
int div=radius+radius+1;
int r[]=new int[wh];
int g[]=new int[wh];
int b[]=new int[wh];
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;
    }
}
}

void onPause()
{
super.onPause();
//Make sure to releae the camera when we go
// to sleep otherwise it stays locked
if (cam != null && cam.isStarted())
    cam.stop();
}

void onCameraPreviewEvent()
{
cam.read();
// cam.autoSettings();
newFrame = true;
}

// start/stop camera preview by tapping the screen
void mousePressed()
{

if (cam.isStarted())
{
    cam.stop();
}
else
    cam.start();
}
void keyPressed() {
if (key == CODED) {
    if (keyCode == MENU) {
      if (cam.isFlashEnabled())
        cam.disableFlash();
      else
        cam.enableFlash();
    }
}
}

Replies(6)

phildar

Re: blob detect quits under android

6 months ago

I can reproduce it.
Wouldn't it have to link with threads stuff ?
Would it be possible to put the detection into the same thread than the Ketai camera ?

It would have been very nice to have a good and efficient library for blob detection into processing/android,
It would make augemented reality applications under processing/android possible !!!

Anyone would have tips about that ?

pauline303

Re: blob detect quits under android

6 months ago

Hi.
I avoid the application quitting because of StackOverflow.
I put the blob detection into a thread (which increases the stack size). Overflow still occurs (see the console) and Blob detection is not computed while overflowing, but it doesn't quit. So I would like to know how to avoid this Overflow (which doesn't occur on my mac…).
Would some of had tips about that ?

here's the sketch that demonstrates the problem with a simple image blob detection.
thanks in advance:

import blobDetection.*;//http://www.v3ga.net/processing/BlobDetection/index-page-download.html

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

// Size of applet
size(640, 480, P3D);
}

// ==================================================
// draw()
// ==================================================
void draw()
{
image(img, 0, 0, width, height);
thread("bloub");
}

// ==================================================
// drawBlobsAndEdges()
// ==================================================
void bloub()
{
theBlobDetection.computeBlobs(img.pixels);
drawBlobsAndEdges(true, true);
}
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
          );
      }
    }
}
}

pauline303

Re: SOLVED blob detect quits under android

6 months ago

I've finally got it !!! stupid thing I guess, I should update pixels from the camera. Then I use this weird trick !! I have to call twice loadpixels to make it work in P3D ! (need this render because of shaders I use for processing images…) some of you would knew why ?
So now I have a real good detection for android at 60 fps !!! Really good news for me, augmented reality apps should come soon ; )

void draw()
{
println(frameRate);
image(cam, 0, 0, width, height);
cam.loadPixels();
cam.loadPixels();
drawBlobsAndEdges(true, true);
theBlobDetection.computeBlobs(cam.pixels);
cam.updatePixels();
}

berengerr

Re: SOLVED blob detect quits under android

6 months ago

Hi Pauline303,

great that you solved your issue, I was interested in the same subject and followed your advancements remotely as I wasn't able to help.

Could you share a working sample code as a whole ? with cam and blobDetection please :)

I've tried agregating the code from your first post and your last update but i only get a white screen.

60 fps is a great score ! what resolution do you use and what is you device ?

Congrats on breaking this down !

pauline303

Re: ALMOST solved…… blob detect quits under android

6 months ago

ARRGggg !!
almost
I had the same problem with images and camera. Now I can make blob detection without any bug in images.
But Still not in camera !! I don't understand why… because formers codes shows that I copy cam into a PImage which is analysed by blobDetect… If you have some idea, a little time to experiment with the camera, it could be pretty helpful.
I have the feeling that the clue of the issue is how android deals with pixels from the camera.
Any thoughts about that ?

//detection de blob dans une image-THIS CODE WORKS
import blobDetection.*;//http://www.v3ga.net/processing/BlobDetection/index-page-download.html

BlobDetection theBlobDetection;
PImage img;

// ==================================================
// setup()
// ==================================================
void setup()
{
img = loadImage("camera.jpg");

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

// Size of applet
size(640, 480, P3D);
}

// ==================================================
// draw()
// ==================================================
void draw()
{
println(frameRate);
image(img, 0, 0, width, height);
img.loadPixels();
img.loadPixels();
drawBlobsAndEdges(true, true);
theBlobDetection.computeBlobs(img.pixels);
img.updatePixels();
}

// ==================================================
// drawBlobsAndEdges()
// ==================================================
void bloub()
{
}
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
          );
        fill(0, 0, 255);
        float _x = b.xMin*width +b.w*width/2;
        float _y = b.yMin*height +b.h*height/2;
        ellipse(_x, _y, 20, 20);
      }
    }
}
}

berengerr

Re: ALMOST solved…… blob detect quits under android

6 months ago

Hi Pauline,

I wish I had more time to look into this, but from what I ould gather on the internet and few discussions I had with a developper it seems that the data coming from the camera is in YUV format, whereas the data you want to process should be in RGB format. So throwing in a YUV<--> RGB converter should do the trick.

In this post AK Eric talks about this, and it seems that a YUV<> RGB converter already exists in ketai lib.

maybe it's worth investigating.

I should have followed a worshop with Julien (author of the Blob Detection lib) today but it has been reported to an unknown date yet :/ I'll ask him when the workshop is re-schedulded if we haven't found a solution by now.