Hello !
I try to understand the way opengl works under processing to adapt code to android opengl2ES.

Could some of you could explain differences between PGL, pgl ?
 PGraphics3D pg = (PGraphics3D) g and  pg = (Opengl) g ?

or what is the difference between pgl.bindTexture( PGL.TEXTURE_2D, textureID); and pgl.bindTexture( pgl.TEXTURE_2D, textureID);

How can I get the opengl context in processing ?
Before it was something like = GL gl;

My puropse is to generate a texture in my sketch ( bind, enable…), to avoid texture(PImage). Any ideas about this ?
But now, it doesn't seem to work under opengles.…

Any links, advices are welcomed !
thanks.
pauline.

Hi. sorry for posting again about what could maybe refer to the same issue (I can't be sure about this yet.)

My goal is to load images as texture in OPENGL android Application.
The issue is the thread of loading images blocks the UI main thread.
(in A2D regular render, no problem : images are loaded without affecting the main thread).
In Opengl, it doesn't.
I found this: http://developer.android.com/guide/components/processes-and-threads.html . (see worker threads). They explain how to make operation like downloading images without affecting the main thread:
simple example:

1. public void onClick(View v) {
       new Thread(new Runnable() {
           public void run() {
               final Bitmap bitmap = loadImageFromNetwork("http://example.com/image.png");
               mImageView.post(new Runnable() {
                   public void run() {
                       mImageView.setImageBitmap(bitmap);
                   }
               });
           }
       }).start();
   }

If I understand correctly, the key would be this:

 mImageView.post(new Runnable() It means that the thread is handle by user interface, 
and not UI Main interface. 
How could I tell processing about this user interface / view to free MAIN thread
from those loading operations ? 
I'm pretty in hurry, any help or advices would be really appreciated !! thanks.
pauline.

hello.
I'm try to visualise a simple texture in android using PGL.
i'm stuck at the line 17, the texture binding operation. it can't find the symbol- I don't understand what I'm doing wrong.
any help would be really appreciated, I'm really new to this kind of thing but pretty impressed by all discoveries I make about processing !

1. import android.graphics.Bitmap;
2. import android.graphics.BitmapFactory;
3. import android.opengl.GLUtils;
4. Bitmap bitmap;
5. PGL pgl;
6. int texture[] = new int[1];
7. void setup() {
8.   size(1280, 800, P3D);
9.   orientation(LANDSCAPE);
10. }
11. void draw() {
12.   background(0);
13.   pgl = beginPGL();
14.   if (bitmap != null) {
15.     pgl.glBindTexture(pgl.TEXTURE_2D, 0);
16.     GLUtils.texImage2D(pgl.TEXTURE_2D, 0, bitmap, 0);
17.   }
18.   //  pg.glTexParameterf(pgl.TEXTURE_2D, pgl.TEXTURE_MIN_FILTER, pgl.LINEAR);
19.   //  pg.glTexParameterf(pgl.TEXTURE_2D, pgl.TEXTURE_MAG_FILTER, pgl.LINEAR);
20.   endPGL();
21. }
22. void mousePressed()
23. {
24.   BitmapFactory.Options options = new BitmapFactory.Options();
25.   options.inScaled = false;
26.   try {
27.     Bitmap bitmap = BitmapFactory.decodeStream(getApplicationContext().getAssets().open("0.jpg"));
28.   }
29.   catch (IOException e) {
30.     System.err.println(" File '0.jpg' not found /Put them in regular data processing folder/");
31.   }
32. }

Hi.
I have a sketch which loads images into PImage.
I would like to use P3D mode to use blending shaders.
My problem is:
in P3D, the screen freezes while the loading thread is running.
It works fine without P3D…

How could I avoid this problem ? Is that something to do with the OPENGL thread ?

here's the code to demonstrate the problem:

1. PImage images[] = new PImage[9];
2. final int loadedI = 3;//number of images to load
3. final int IMAGE_WIDTH= 1280; //width of loaded images
4. final int IMAGE_HEIGHT= 800; //height of loaded images
5. int h;
6. void setup()
7. {
8.   size(1280, 800, P3D); //SWITCH P3D ON AND OFF TO SEE THE OPENGL BLOCKS THE LOADING THREAD
9.   background(0);
10.   for (int i = 0; i < images.length; i++)
11.   {
12.     images[i] = new PImage(IMAGE_WIDTH, IMAGE_HEIGHT, RGB);
13.   }
14. }
15. void draw()
16. {
17.   background(0);
18.   println(frameRate);
19.   for (int t = 0; t <loadedI; t++)
20.   {
21.     image(images[t], t*width/loadedI, height/2, width/loadedI, width/loadedI);
22.   }
23.   ellipse();//TO VISUALISE THE "INTERRUPTION OF THE SCREEN"
24. }
25. void ellipse()
26. {
27.   h++;
28.   if (h>height) h=0;
29.   fill(255);
30.   ellipse(width/2, h, 50, 50);
31. }
32. void mousePressed()
33. {
34.   for (int i= 0; i<loadedI; i++) {
35.     (new ImageLoaderThread(this, i, i )).start();
36.   }
37. }

and here's the thread:

1. class ImageLoaderThread extends Thread
   {
   
     private PApplet pa;
     private String fileName;
     private int gridIndex;
     public ImageLoaderThread(PApplet pa, int imageIndex, int gridIndex)
     {
       this.pa = pa;
       fileName = imageIndex+".jpg";
       this.gridIndex = gridIndex;
     }
   
     public void run()
     {
       images[gridIndex] = loadImage(fileName);
       images[gridIndex].updatePixels();
   
       images[gridIndex].pixels = null;
     }
   }
   
   

Hi.
I have an array of 3 numbers.
I would like to output only elements that have changed between fame -1 and frame.
I made another array to track changes from my source array.
but weird nothing occurs…
here's what I got:
any help would be cool !
thanks

1. //mousePressed modify the source array, and it should println the changed element…but walou…
   
   int[] source= {
     3, 4, 5
   };
   int track_source[] = new int[3];
   void setup()
   {
     size(300, 300);
     track_source= source;
   }
   
   void draw()
   {
   
     background(200);
     for (int i  =0; i<3; i++)
     { 
       if (track_source[i]  !=source[i] )
       {
         println(source[i]);
         track_source[i] =source[i] ;
       }
     }
   }
   void mousePressed()
   { 
     source[1] = 19;
   }
   
   

Hello all. Here's a problem which is not just link  to android mode I guess.
I would like to implement a runnable thread to increase the stack size in my android application. (stack size is smaller in android by default which causes stack overflow of blobs detection).
several try and weird things. The main problem is null pointer exception occurs (caused by the blobdetection instruction.)

In java mode I can make the thread work but first weird thing=

1.  void run()
     {
       finished = false;
       println("hello thread");
       img1 = loadImage("1.jpg");// WHEN I REMOVE THIS I GOT NULL POINTER EXCEPTION //EVEN IN JAVA MODE !
       img.loadPixels();
       theBlobDetection.computeBlobs(img.pixels);
       img.updatePixels();
       finished = true;
       println("thread finished");
     }

I can't explain that…in android mode, theBlobDetection.computeBlobs(img.pixels); returns Null pointer exception.

here's the whole code:
main tab:

1. // blob detection library= http://www.v3ga.net/processing/BlobDetection/index-page-download.html
   Thread t ;
   import blobDetection.*;
   PGraphics img;
   PImage img1;
   BlobDetection theBlobDetection;
   boolean finished;
   void setup()
   { 
     size(640, 480);
     background(255, 0, 0);
     graphics();
     Thread t =new Thread(new trid());
     ThreadGroup group = new ThreadGroup("group");
     t.start();
     theBlobDetection = new BlobDetection(img.width, img.height);
     theBlobDetection.setPosDiscrimination(false);
     theBlobDetection.setThreshold(0.38f);
   }
   
   void draw()
   {
     if (finished)
     {
       image(img, 0, 0, width, height);
       drawBlobsAndEdges(true, true);
     }
   }
   

Hello I would like to make fades between a grid of images according to the position of the Mouse (as it shown in the code).
The idea would be to use 9 players image. How can I bind PImage to my player dynamically to make effects with tint for instance ? (the final purpose is to do it with shaders but I have to understand the way to refresh players in real time).
Thanks in advance.
the code shows one image per cell, although I would have wanted a fade effect with pictures around the cell.

1. PImage img[] = new PImage[25];
   int video_nbr;
   void setup()
   {
   
     size(800, 800);
     textSize(20);
     for (int k = 0; k<25; k++)
     {
       img[k] = loadImage(k+".jpg");
     }
   }
   
   void draw()
   
   {
     background(150);
     GUI();
     displayIMAGE();
     fill(255);
     int coordX =constrain(int(5*mouseX/400), 0, 4);
     int  coordY= constrain(int(5*mouseY/400), 0, 4);
     video_nbr = coordX +5*coordY;
     text("X :  "+ coordX +"\n"+ "Y :  " + coordY +"\n"+ "Vidéos numéro= " +video_nbr, 20+width/2, 60);
   }
   void GUI()
   {
     for (int i= 0; i< 6; i++)
     {
       line(i*400/5, 0, i*400/5, 400);
       line(0, i*400/5, 400, i*400/5);
     }
     fill(255, 90);
     ellipse(constrain(mouseX, 0, 400), constrain(mouseY, 0, 400), 20, 20);
   }
   void displayIMAGE()
   {
     image(img[video_nbr], width/2, height/2, 200, 200);
   }
   

pretty cool !!!
http://vimeo.com/channels/natureofcode/

Hi,
I would like make some blobs detection which uses PImage.copy.
Unfortunately there's kind of bug using this into P3D mode. (the image freezes in very strange way…).
Anyway, how could I replaced PImage.copy in this code :

1. void draw()
   {
     if (newFrame)
     {
     
       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);
2.         newFrame=false;
     }
   }

thanks in advance

Hello, sorry I'm still stuck into loading images in a very efficient way.
I use the really nice class from quarks. I need to display pictures according to their name which the class do very well with hashmap.
I need to put this into a thread to display pictures which are already into the ram, while loading and removing the others one from the ram without delay.
that is my problem, I can't make it works here's the code of modified class:

1. import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Map;
   import processing.core.PApplet;
   import processing.core.PImage;
   String filename;
   class Textures_loader extends Thread
   {
     Textures_loader(PApplet app, String _filename)
     {
       _filename = filename;
     }
   
     public PImage loadImage(PApplet app, String filename) { 
       HashMap<String, PImage> textures = new HashMap<String, PImage>();
       if (textures.containsKey(filename)) {
         return textures.get(filename);
       }
       PImage image = app.loadImage(filename);
       if (image != null) {
         textures.put(filename, image);
         Iterator i = textures.entrySet().iterator();  // Get an iterator
         while (i.hasNext ()) {
           Map.Entry me = (Map.Entry)i.next();
           //        PApplet.print(me.getKey() + " is "); //this is a way to know the image object loaded.
           //        PApplet.println(me.getValue());
         }
       }
       else
         PApplet.println("Unable to load image from file '" + filename+"'");
       return image;
     }
     public void run()
     {
       try {
   
         Textures_loader.loadImage(PApplet app, String filename);
       }
   
       catch (Exception e) {
         println("No Video Image: "+ e);
       }
     }
   }
   

Hello, I would like to know if some of you would have samples of code which use Asynchronous image loading class.
I just can't make it work when I paste the code into my processing sketch.
It would have been so much helpful for me, because the sample demo 's link is broken.
Thanks in advance.
pauline

Hi all.
I would like to create a 30 images buffer with 5 image(image[],0,0); player to display a 900 pictures folder.

I use the wonderful class from quarks found here: https://forum.processing.org/topic/large-amounts-of-textures-a-good-way-to-store-them

Pictures are stored randomly in the buffer but I need to know their location to recall them.

For instance I need to know the the picture 845 is stored in the image[25] = Textures.loadImage(this, "845.jpg");
and thanks to that I can display this picture with image(image[25], 0, 0).

I think I should make kind of string array to know the position of 845.jpg into my buffer, and display it with image. Which tool let me know the position of the file 845.jpg into my buffer ?

Should I use PVector instead of Arraylist ?
Could you give me some start points ?
thank you

hello,
I just try to do a simple mix-shader: multiply the texture by an amount to make some fades.
but nothing occurs.

here's my glsl code:

1.             #ifdef GL_ES
   precision mediump float;
   precision mediump int;
   #endif
   
   #define PROCESSING_TEXTURE_SHADER
   
   uniform sampler2D texture;
   uniform float amount;
   varying vec4 vertTexCoord;
   
   
   void main(void) {
   vec4 a = texture2D(texture, vertTexCoord.st);
   
   gl_FragColor = a  * vec4(amount);}

hello,
I would like to output a value only if it's changed. (for instance mouseX, if it doesn't moove I don't need the value)
thx

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

1. // - 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();
       }
     }
   }