Hi our group name is 'LMI(Lego Media Interaction)'.

We used 'blobDetection' processing code and planned to make education tool.

I am a processing beginner.

(To make 'blobDetection' code we install 'WinVDIG_101.exe.' first. because we have to use webcam.)

now our code appears 'vertical' and 'horizental' model image with lego piece  'vertical' or 'horizental'

 and now we want to add more function, like right cross, left cross code and pile up (we use only twe lego pieces now,

     we want to make new intreface. help us please. :)

1. // - Super Fast Blur v1.1 by Mario Klingemann <http://incubator.quasimondo.com>
   // - BlobDetection library
2. import processing.video.*;
   import blobDetection.*;
3. Capture cam;
   BlobDetection theBlobDetection;
   PImage img;
   boolean newFrame=false;
4. PImage img1;
   PImage img2;
5. // ==================================================
   // setup()
   // ==================================================
   void setup()
   {
    // Size of applet
    size(1366, 768);
    // 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);
6. 
           img1 = loadImage("img01.jpg");
           img2 = loadImage("img02.jpg");
7. 
    theBlobDetection = new BlobDetection(img.width, img.height);
    theBlobDetection.setPosDiscrimination(true);
    theBlobDetection.setThreshold(0.2f); // will detect bright areas whose luminosity > 0.2f;
   }
8. // ==================================================
   // captureEvent()
   // ==================================================
   void captureEvent(Capture cam)
   {
    cam.read();
    newFrame = true;
   }
9. // ==================================================
   // draw()
   // ==================================================
   void draw()
   {
    if (newFrame)
    {
     newFrame=false;
     image(cam,0,0,width,height);
     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);
    }
10. 
    }
11. // ==================================================
    // 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(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
    //       );
    //    }
       }
12.    // Blobs
       if (drawBlobs)
       {
        strokeWeight(1);
        stroke(255,0,0);
        rect(
         b.xMin*width,b.yMin*height,
         b.w*width,b.h*height
         );
13.                                 if((b.w*width - b.h*height) > 20)
                                    {
                                    // println("Horizontal: "+theBlobDetection.getBlobNb());
                                     if(theBlobDetection.getBlobNb() ==1)
                                      image(img1,0,0,1366,768);
                                    }
                                    else if((b.h*height - b.w*width) > 20)
                                    {
                                      //println("Vertical: "+theBlobDetection.getBlobNb());
                                     if(theBlobDetection.getBlobNb() ==1)
                                       image(img2,0,0,1366,768);
                                    }                     
       }
14.   }
15.       }
    }
16. // ==================================================
    // 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);
      }
17.   yw=yi=0;
18.   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++){
19.       r[yi]=dv[rsum];
          g[yi]=dv[gsum];
          b[yi]=dv[bsum];
20.       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]];
21.       rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
          gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
          bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
          yi++;
        }
        yw+=w;
      }
22.   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];
23.       rsum+=r[p1]-r[p2];
          gsum+=g[p1]-g[p2];
          bsum+=b[p1]-b[p2];
24.       yi+=w;
        }
      }
25. }
    
* 1) we want to add lego cross and pile up.* 2) we want to take a picture with wecam first and after that, image changes.