Hi. This is my the first question on this forum! I'm undergoing project making fish-eye effect on screen changing depends on input from webcam blob detection.
Working on processing 1.5.1 to use glgraphics library_output_fish-eye ( http://glgraphics.sourceforge.net/examples/Output/FishEye/FishEye.pde), it is hard to use the both fish-eye library and webcam video capture(webcam capture needs canvas to get input and fish-eye rendering also). I'm using blob detection  from v3ga ( http://www.v3ga.net/processing/BlobDetection/).

Two codes separately works well, but I don't know how to combine them for my purpose. Anyone can help this? and if it exists, I wanna know more about fish-eye effect on processing. Are there any libraries?

1) Fish-eye 

it' on this link :  http://glgraphics.sourceforge.net/examples/Output/FishEye/FishEye.pde


2) Video capture with blob detection

2. // - Super Fast Blur v1.1 by Mario Klingemann <http://incubator.quasimondo.com>
3. // - BlobDetection library
4. 
   
5. import processing.video.*;
6. import blobDetection.*;
7. 
   
8. Capture cam;
9. BlobDetection theBlobDetection;
10. PImage img;
11. boolean newFrame=false;
12. 
    
13. // ==================================================
14. // setup()
15. // ==================================================
16. void setup()
17. {
18. // Size of applet
19. size(640, 480);
20. // Capture
21. cam = new Capture(this, 40*4, 30*4, 15);
22.         // Comment the following line if you use Processing 1.5
23. 
    
24.         
25. // BlobDetection
26. // img which will be sent to detection (a smaller copy of the cam frame);
27. img = new PImage(80,60); 
28. theBlobDetection = new BlobDetection(img.width, img.height);
29. theBlobDetection.setPosDiscrimination(true);
30. theBlobDetection.setThreshold(0.2f); // will detect bright areas whose luminosity > 0.2f;
31. }
32. 
    
33. // ==================================================
34. // captureEvent()
35. // ==================================================
36. void captureEvent(Capture cam)
37. {
38. cam.read();
39. newFrame = true;
40. }
41. 
    
42. // ==================================================
43. // draw()
44. // ==================================================
45. void draw()
46. {
47. if (newFrame)
48. {
49. newFrame=false;
50. image(cam,0,0,width,height);
51. img.copy(cam, 0, 0, cam.width, cam.height, 
52. 0, 0, img.width, img.height);
53. fastblur(img, 2);
54. theBlobDetection.computeBlobs(img.pixels);
55. drawBlobsAndEdges(true,true);
56. }
57. }
58. 
    
59. 
    
60. // ==================================================
61. // drawBlobsAndEdges()
62. // ==================================================
63. void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges)
64. {
65. noFill();
66. Blob b;
67. EdgeVertex eA,eB;
68. for (int n=0 ; n<theBlobDetection.getBlobNb() ; n++)
69. {
70. b=theBlobDetection.getBlob(n);
71. if (b!=null)
72. {
73. // Edges
74. if (drawEdges)
75. {
76. strokeWeight(3);
77. stroke(0,255,0);
78. for (int m=0;m<b.getEdgeNb();m++)
79. {
80. eA = b.getEdgeVertexA(m);
81. eB = b.getEdgeVertexB(m);
82. if (eA !=null && eB !=null)
83. line(
84. eA.x*width, eA.y*height, 
85. eB.x*width, eB.y*height
86. );
87. }
88. }
89. 
    
90. // Blobs
91. if (drawBlobs)
92. {
93. strokeWeight(1);
94. stroke(255,0,0);
95. rect(
96. b.xMin*width,b.yMin*height,
97. b.w*width,b.h*height
98. );
99.                                  ellipse(b.xMin*width/2+(b.w*width+b.xMin*width)/2, b.yMin*height/2+(b.h*height+b.yMin*height)/2,10,10);     
100.                
101.                                   println("NEW blob");
102.                                   println("x of blob =" + b.xMin*width/2+(b.w*width+b.xMin*width)/2);
103.                                   println("y of blob =" + b.yMin*height/2+(b.h*height+b.yMin*height)/2);
104. 
     
105. }
106. 
     
107. }
108. 
     
109.       }
110. }
111. 
     
112. // ==================================================
113. // Super Fast Blur v1.1
114. // by Mario Klingemann 
115. // <http://incubator.quasimondo.com>
116. // ==================================================
117. void fastblur(PImage img,int radius)
118. {
119.  if (radius<1){
120.     return;
121.   }
122.   int w=img.width;
123.   int h=img.height;
124.   int wm=w-1;
125.   int hm=h-1;
126.   int wh=w*h;
127.   int div=radius+radius+1;
128.   int r[]=new int[wh];
129.   int g[]=new int[wh];
130.   int b[]=new int[wh];
131.   int rsum,gsum,bsum,x,y,i,p,p1,p2,yp,yi,yw;
132.   int vmin[] = new int[max(w,h)];
133.   int vmax[] = new int[max(w,h)];
134.   int[] pix=img.pixels;
135.   int dv[]=new int[256*div];
136.   for (i=0;i<256*div;i++){
137.     dv[i]=(i/div);
138.   }
139. 
     
140.   yw=yi=0;
141. 
     
142.   for (y=0;y<h;y++){
143.     rsum=gsum=bsum=0;
144.     for(i=-radius;i<=radius;i++){
145.       p=pix[yi+min(wm,max(i,0))];
146.       rsum+=(p & 0xff0000)>>16;
147.       gsum+=(p & 0x00ff00)>>8;
148.       bsum+= p & 0x0000ff;
149.     }
150.     for (x=0;x<w;x++){
151. 
     
152.       r[yi]=dv[rsum];
153.       g[yi]=dv[gsum];
154.       b[yi]=dv[bsum];
155. 
     
156.       if(y==0){
157.         vmin[x]=min(x+radius+1,wm);
158.         vmax[x]=max(x-radius,0);
159.       }
160.       p1=pix[yw+vmin[x]];
161.       p2=pix[yw+vmax[x]];
162. 
     
163.       rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
164.       gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
165.       bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
166.       yi++;
167.     }
168.     yw+=w;
169.   }
170. 
     
171.   for (x=0;x<w;x++){
172.     rsum=gsum=bsum=0;
173.     yp=-radius*w;
174.     for(i=-radius;i<=radius;i++){
175.       yi=max(0,yp)+x;
176.       rsum+=r[yi];
177.       gsum+=g[yi];
178.       bsum+=b[yi];
179.       yp+=w;
180.     }
181.     yi=x;
182.     for (y=0;y<h;y++){
183.       pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
184.       if(x==0){
185.         vmin[y]=min(y+radius+1,hm)*w;
186.         vmax[y]=max(y-radius,0)*w;
187.       }
188.       p1=x+vmin[y];
189.       p2=x+vmax[y];
190. 
     
191.       rsum+=r[p1]-r[p2];
192.       gsum+=g[p1]-g[p2];
193.       bsum+=b[p1]-b[p2];
194. 
     
195.       yi+=w;
196.     }
197.   }
198. 
     
199. }
200. 
     
201.