remarks
we can't run it cause of the images.
You might want to zip it (code + images) and upload somewhere

you didn't post all your code - it's ending in the middle of draw (no } )

you can determine the number of elements by size()

see reference.

This is the complete ArrayList Reference.
If I understand you correctly, you want to stop the ArrayList from surpassing a certain size...
Something like the following when you add a new item:

1. if(theList.size() + 1 < theMaxSize) theList.add(theItem);
   

Do you know you can make an array of array lists?
That would avoid copy/paste code which is a nightmare to read and to maintain...
I suppose you have 7 nearly identical classes as well. Find out what is common between them and what is different, and parametrize the latter with some class variable.
Thus, perhaps you can even make only one array list, with mixed bubbles in it.

General advice: avoid throwing in libraries that are not relevant to your problem. I moved the topic to Contributed Libraries only for that... If necessary, try and put the important code in a small separate sketch, simplifying your code and allowing others to run it without the unneeded libraries.

Hello,

thanks for the reply's. Yes, I only want a certain amount of bubbles in the window at one time. Yeah all of my classes are totally identical. The only thing is I want to be able to send a different OSC message every time one of the bubbles is 'burst', hence why I have 7 different classes.. Would I still be able to do that by making an array of arraylists?

also, I only put in the other libraries because I have already set up all of the OSC part already, so sorry about that.

I will try and make a smaller sketch to upload on here.

thanks.    

" I want to be able to send a different OSC message every time one of the bubbles is 'burst', hence why I have 7 different classes"
Thus, have only one class, and add a "message" parameter to the constructor, that you set in a class field.

new Bubble1( (int)random( 0, width - 40), -bubble1PNG.height, bubble1PNG.width, bubble1PNG.height)
can be:
new Bubble("your OSC message", "bubble1.png");

thus your constructor looks like:
Bubble(String oscMsg, String imgName) {
  oscMessage = oscMsg;
  image = loadImage(imgName);
  x = (int) random(0, width - 40);
  y = -image.height;
  width = image.width;
  height = image.height;
}
where the variables on the left are declared at the class level.
And you avoid making repetitive operations in the constructor's call, it is the constructor itself making the repetitive work.

Here is the code. I have had a look at trying to do what you said.... but I'm not too sure of how to approach it. Also here are the bubble images that you will need to run the code.

1. import hypermedia.video.*;          //  Imports the OpenCV library
   import oscP5.*;
   import netP5.*;
   
   OscP5 oscP5;
   NetAddress myBroadcastLocation;
   
   OpenCV opencv;                      //  Creates a new OpenCV object
   PImage movementImg;                 //  Creates a new PImage to hold the movement image
   int poppedBubbles;                  //  Creates a variable to hold the total number of popped bubbles
   ArrayList bubbles;                  //  Creates an ArrayList to hold the Bubble objects
   ArrayList bubbles1;
   
   PImage bubblePNG;                   //  Creates a PImage that will hold the image of the bubble
   PImage bubble1PNG;                   //  Creates a PImage that will hold the image of the bubble
   
   void setup()
   {
     size ( 640, 480 );                      //  Window size of 640 x 480
    
     oscP5 = new OscP5(this,12000);
    
     opencv = new OpenCV( this );            //  Initialises the OpenCV library
     opencv.capture( 640, 480 );             //  Sets the capture size to 640 x 480
     movementImg = new PImage( 640, 480 );   //  Initialises the PImage that holds the movement image
     poppedBubbles = 0;
      
     bubbles = new ArrayList();              //  Initialises the ArrayList
     bubbles1 = new ArrayList();
   
   
     bubblePNG = loadImage("bubble.png");    //  Load the bubble image into memory
     bubble1PNG = loadImage("bubble1.png");    //  Load the bubble image into memory
     myBroadcastLocation = new NetAddress("127.0.0.1",57120);
   }
   
   void draw()
   {
     bubbles.add(new Bubble( (int)random( 0, width - 40), -bubblePNG.height, bubblePNG.width, bubblePNG.height));   //  Adds a new bubble to the array with a random x position
     bubbles1.add(new Bubble1( (int)random( 0, width - 40), -bubble1PNG.height, bubble1PNG.width, bubble1PNG.height));
   
     opencv.read();                              //  Captures a frame from the camera   
     opencv.flip(OpenCV.FLIP_HORIZONTAL);        //  Flips the image horizontally
     image( opencv.image(), 0, 0 );              //  Draws the camera image to the screen
     opencv.absDiff();                           //  Creates a difference image
      
     opencv.convert(OpenCV.GRAY);                //  Converts to greyscale
     opencv.blur(OpenCV.BLUR, 3);                //  Blur to remove camera noise
     opencv.threshold(20);                       //  Thresholds to convert to black and white
     movementImg = opencv.image();               //  Puts the OpenCV buffer into an image object
    
    
     // BUBBLE
     for ( int i = 0; i < bubbles.size(); i++ ){    //  For every bubble in the bubbles array
       Bubble _bubble = (Bubble) bubbles.get(i);    //  Copies the current bubble into a temporary object
      
       if(_bubble.update() == 1){                  //  If the bubble's update function returns '1'
         bubbles.remove(i);                        //  then remove the bubble from the array
         _bubble = null;                           //  and make the temporary bubble object null
         i--;                                      //  since we've removed a bubble from the array, we need to subtract 1 from i, or we'll skip the next bubble
      
     }else{                                        //  If the bubble's update function doesn't return '1'
         bubbles.set(i, _bubble);                  //  Copys the updated temporary bubble object back into the array
         _bubble = null;                           //  Makes the temporary bubble object null.
       }
     }
    
      
      
       // BUBBLE 1
       for ( int i = 0; i < bubbles1.size(); i++ ){    //  For every bubble in the bubbles array
       Bubble1 _bubble1 = (Bubble1) bubbles1.get(i);    //  Copies the current bubble into a temporary object
      
       if(_bubble1.update() == 1){                  //  If the bubble's update function returns '1'
         bubbles1.remove(i);                        //  then remove the bubble from the array
         _bubble1 = null;                           //  and make the temporary bubble object null
         i--;                                      //  since we've removed a bubble from the array, we need to subtract 1 from i, or we'll skip the next bubble
      
     }else{                                        //  If the bubble's update function doesn't return '1'
         bubbles1.set(i, _bubble1);                  //  Copys the updated temporary bubble object back into the array
         _bubble1 = null;                           //  Makes the temporary bubble object null.
       }
     }
    
   opencv.remember(OpenCV.SOURCE, OpenCV.FLIP_HORIZONTAL);    //  Remembers the camera image so we can generate a difference image next frame. Since we've
                                                                //  flipped the image earlier, we need to flip it here too.
   }
   
   
   void oscEvent(OscMessage theOscMessage) {
     /* get and print the address pattern and the typetag of the received OscMessage */
     println("### received an osc message with addrpattern "+theOscMessage.addrPattern()+" and typetag "+theOscMessage.typetag());
     theOscMessage.print();
   }
   
   
   
   
   
   class Bubble
   {
    
     int bubbleX, bubbleY, bubbleWidth, bubbleHeight;    //  Some variables to hold information about the bubble
    
     Bubble ( int bX, int bY, int bW, int bH )           //  The class constructor- sets the values when a new bubble object is made
     {
       bubbleX = bX;
       bubbleY = bY;
       bubbleWidth = bW;
       bubbleHeight = bH;
     }
    
     int update()      //   The Bubble update function
     {
       int movementAmount;          //  Create and set a variable to hold the amount of white pixels detected in the area where the bubble is
       movementAmount = 0;
      
       for( int y = bubbleY; y < (bubbleY + (bubbleHeight-1)); y++ ){    //  For loop that cycles through all of the pixels in the area the bubble occupies
         for( int x = bubbleX; x < (bubbleX + (bubbleWidth-1)); x++ ){
          
           if ( x < width && x > 0 && y < height && y > 0 ){             //  If the current pixel is within the screen bondaries
             if (brightness(movementImg.pixels[x + (y * width)]) > 127)  //  and if the brightness is above 127 (in this case, if it is white)
             {
               movementAmount++;                                         //  Add 1 to the movementAmount variable.
             }
           }
         }
       }
      
   
       OscMessage myOscMessage; 
      
       if (movementAmount > 5)               //  If more than 5 pixels of movement are detected in the bubble area
         {
        
           myOscMessage = new OscMessage("/diam1");
         println( myOscMessage);
         oscP5.send(myOscMessage, myBroadcastLocation); 
        
         poppedBubbles++;                    //  Add 1 to the variable that holds the number of popped bubbles
         return 1;                           //  Return 1 so that the bubble object is destroyed
        
      }
      else{      //  If less than 5 pixels of movement are detected,
         bubbleY += 5;                      //  increase the y position of the bubble so that it falls down
        
         if (bubbleY > height)               //  If the bubble has dropped off of the bottom of the screen
         {  return 1; }                      //  Return '1' so that the bubble object is destroyed
        
         image(bubblePNG, bubbleX, bubbleY);    //  Draws the bubble to the screen
         return 0;                              //  Returns '0' so that the bubble isn't destroyed
      
     }
    
     }
    
   }
   
   
   
   class Bubble1
   {
    
     int bubble1X, bubble1Y, bubble1Width, bubble1Height;    //  Some variables to hold information about the bubble
    
     Bubble1 ( int bX, int bY, int bW, int bH )           //  The class constructor- sets the values when a new bubble object is made
     {
       bubble1X = bX;
       bubble1Y = bY;
       bubble1Width = bW;
       bubble1Height = bH;
     }
    
     int update()      //   The Bubble update function
     {
       int movementAmount;          //  Create and set a variable to hold the amount of white pixels detected in the area where the bubble is
       movementAmount = 0;
      
       for( int y = bubble1Y; y < (bubble1Y + (bubble1Height-1)); y++ ){    //  For loop that cycles through all of the pixels in the area the bubble occupies
         for( int x = bubble1X; x < (bubble1X + (bubble1Width-1)); x++ ){
          
           if ( x < width && x > 0 && y < height && y > 0 ){             //  If the current pixel is within the screen bondaries
             if (brightness(movementImg.pixels[x + (y * width)]) > 127)  //  and if the brightness is above 127 (in this case, if it is white)
             {
               movementAmount++;                                         //  Add 1 to the movementAmount variable.
             }
           }
         }
       }
      
       OscMessage myOscMessage;
      
       if (movementAmount > 5)               //  If more than 5 pixels of movement are detected in the bubble area
       {
        
         myOscMessage = new OscMessage("/diam2");
         println( myOscMessage);
         oscP5.send(myOscMessage, myBroadcastLocation);
      
         poppedBubbles++;                    //  Add 1 to the variable that holds the number of popped bubbles
         return 1;                           //  Return 1 so that the bubble object is destroyed
     
      }else{                                 //  If less than 5 pixels of movement are detected,
         bubble1Y += 5;                      //  increase the y position of the bubble so that it falls down
        
         if (bubble1Y > height)               //  If the bubble has dropped off of the bottom of the screen
         {  return 1; }                      //  Return '1' so that the bubble object is destroyed
        
         image(bubble1PNG, bubble1X, bubble1Y);    //  Draws the bubble to the screen
         return 0;                              //  Returns '0' so that the bubble isn't destroyed
       }
      
     }
    
   }
   
   
   
   

" I'm not too sure of how to approach it."
Well, the idea is to understand what I wrote and to replace your code with mine.
Example:

1. class Bubble
2. {
3.   int bubbleX, bubbleY, bubbleWidth, bubbleHeight;    //  Some variables to hold information about the bubble
4.  
5.   Bubble ( int bX, int bY, int bW, int bH )           //  The class constructor- sets the values when a new bubble object is made
6.   {
7.     bubbleX = bX;
8.     bubbleY = bY;
9.     bubbleWidth = bW;
10.     bubbleHeight = bH;
11.   }

can become:

1. class Bubble
2. {
3.   int x, y;
4.   int bWidth, bHeight;
5.   String oscMessage;
6.   PImage image;
7.  
8.   Bubble(String oscMsg, String imgName) {
9.     oscMessage = oscMsg;
10.     image = loadImage(imgName);
11.     x = (int) random(0, width - 40);
12.     y = -image.height;
13.     bWidth = image.width;
14.     bHeight = image.height;
15.   }

No need for the 'bubble' prefix as they are already in the Bubble class. Would look strange to access a member as bubble.bubbleX. I still used a 'b' prefix for width and height to avoid masking the Processing variables of same name: not a problem, actually, unless you really need them in the class.

Likewise, replace:

1. bubbles.add(new Bubble( (int)random( 0, width - 40), -bubblePNG.height, bubblePNG.width, bubblePNG.height));   //  Adds a new bubble to the array with a random x position
2.   bubbles1.add(new Bubble1( (int)random( 0, width - 40), -bubble1PNG.height, bubble1PNG.width, bubble1PNG.height));

with:

1. bubbles.add(new Bubble("/diam1", "bubble1.png"));
2. bubbles.add(new Bubble("/diam2", "bubble1.png"));

where bubbles is declared as:

1. ArrayList<Bubble> bubbles = new ArrayList<Bubble>();

and no need for copy/paste code.

1.   for (int i = 0; i < bubbles.size(); i++) {    //  For every bubble in the bubbles array
2.     Bubble bubble = bubbles.get(i);    //  Copies the current bubble into a temporary object
3.    
4.     if (bubble.update() == 1){                  //  If the bubble's update function returns '1'
5.       bubbles.remove(i);                        //  then remove the bubble from the array
6.       i--;                                      //  since we've removed a bubble from the array, we need to subtract 1 from i, or we'll skip the next bubble
7.    
8.     }
9.   }

No need to nullify the bubble variable and no need to "put back" the bubble in the array list because get() doesn't remove it.
This single loop will manage each bubble, whatever its kind: the OSC message and the image are coded in each bubble, so no need for a special treatment. That's the interest of objects: to unify the processing of the objects, by hiding differences in the objects.
You just have to change update() to use the new oscMessage and image variables, instead of using hard-coded global variables or literals.

ok thanks.

 have done this but I keep getting this error: NullPointerException. Also, yes I want to send a different OSC message every time a different coloured bubble is 'burst'. Each colour controls a different synth in SuperCollider.


import hypermedia.video.*;          //  Imports the OpenCV library
import oscP5.*;
import netP5.*;

OscP5 oscP5;
NetAddress myBroadcastLocation;

OpenCV opencv;                      //  Creates a new OpenCV object
PImage movementImg;                 //  Creates a new PImage to hold the movement image
int poppedBubbles;                  //  Creates a variable to hold the total number of popped bubbles
ArrayList<Bubble> bubbles = new ArrayList<Bubble>();


PImage bubblePNG;                   //  Creates a PImage that will hold the image of the bubble
PImage bubble1PNG;                   //  Creates a PImage that will hold the image of the bubble

void setup()
{
  size ( 640, 480 );                      //  Window size of 640 x 480
 
  oscP5 = new OscP5(this,12000);
 
  opencv = new OpenCV( this );            //  Initialises the OpenCV library
  opencv.capture( 640, 480 );             //  Sets the capture size to 640 x 480
  movementImg = new PImage( 640, 480 );   //  Initialises the PImage that holds the movement image
  poppedBubbles = 0;
   
  bubbles = new ArrayList();              //  Initialises the ArrayList



  bubblePNG = loadImage("bubble.png");    //  Load the bubble image into memory
  bubble1PNG = loadImage("bubble1.png");    //  Load the bubble image into memory
  myBroadcastLocation = new NetAddress("127.0.0.1",57120);
}

void draw()
{
bubbles.add(new Bubble("/diam1", "bubble1.png"));
bubbles.add(new Bubble("/diam2", "bubble2.png"));


  opencv.read();                              //  Captures a frame from the camera   
  opencv.flip(OpenCV.FLIP_HORIZONTAL);        //  Flips the image horizontally
  image( opencv.image(), 0, 0 );              //  Draws the camera image to the screen
  opencv.absDiff();                           //  Creates a difference image
   
  opencv.convert(OpenCV.GRAY);                //  Converts to greyscale
  opencv.blur(OpenCV.BLUR, 3);                //  Blur to remove camera noise
  opencv.threshold(20);                       //  Thresholds to convert to black and white
  movementImg = opencv.image();               //  Puts the OpenCV buffer into an image object
 
 
  // BUBBLE
  for (int i = 0; i < bubbles.size(); i++) {    //  For every bubble in the bubbles array
    Bubble bubble = bubbles.get(i);    //  Copies the current bubble into a temporary object
   
    if (bubble.update() == 1){                  //  If the bubble's update function returns '1'
      bubbles.remove(i);                        //  then remove the bubble from the array
    
 i--;                                      //  since we've removed a bubble from the array, we need to subtract 1 from i, or we'll skip the next bubble
   
    }
  }
 
opencv.remember(OpenCV.SOURCE, OpenCV.FLIP_HORIZONTAL);    //  Remembers the camera image so we can generate a difference image next frame. Since we've
                                                             //  flipped the image earlier, we need to flip it here too.
}

void oscEvent(OscMessage theOscMessage) {
  /* get and print the address pattern and the typetag of the received OscMessage */
  println("### received an osc message with addrpattern "+theOscMessage.addrPattern()+" and typetag "+theOscMessage.typetag());
  theOscMessage.print();
}




class Bubble
{
  int x, y;
  int bWidth, bHeight;
  String oscMessage;
  PImage image;
 
  Bubble(String oscMsg, String imgName) {
    oscMessage = oscMsg;
    image = loadImage(imgName);
    x = (int) random(0, width - 40);
    y = -image.height;
    bWidth = image.width;
    bHeight = image.height;
  }

  int update()      //   The Bubble update function
  {
    int movementAmount;          //  Create and set a variable to hold the amount of white pixels detected in the area where the bubble is
    movementAmount = 0;
   
    for( int y = bHeight; y < (bHeight + (bHeight-1)); y++ ){    //  For loop that cycles through all of the pixels in the area the bubble occupies
      for( int x = bWidth; x < (bWidth + (bWidth-1)); x++ ){
       
        if ( x < width && x > 0 && y < height && y > 0 ){             //  If the current pixel is within the screen bondaries
          if (brightness(movementImg.pixels[x + (y * width)]) > 127)  //  and if the brightness is above 127 (in this case, if it is white)
          {
            movementAmount++;                                         //  Add 1 to the movementAmount variable.
          }
        }
      }
    }
   

    OscMessage myOscMessage; 
   
    if (movementAmount > 5)               //  If more than 5 pixels of movement are detected in the bubble area
      {
     
        myOscMessage = new OscMessage("/diam1");
      println( myOscMessage);
      oscP5.send(myOscMessage, myBroadcastLocation); 
     
      poppedBubbles++;                    //  Add 1 to the variable that holds the number of popped bubbles
      return 1;                           //  Return 1 so that the bubble object is destroyed
     
   }
   else{      //  If less than 5 pixels of movement are detected,
      bHeight += 5;                      //  increase the y position of the bubble so that it falls down
     
      if (bHeight > height)               //  If the bubble has dropped off of the bottom of the screen
      {  return 1; }                      //  Return '1' so that the bubble object is destroyed
     
      image(bubblePNG, bWidth, bHeight);    //  Draws the bubble to the screen
      return 0;                              //  Returns '0' so that the bubble isn't destroyed
   
  }
 
  }
 
}

" have done this"
Not really, you only did half of what I described. I fear I am a poor explainer (if this word exists).
You no longer need the global PImages, since they are created and loaded in the class. You still hard-code the "/diam1" message in the OscMessage() constructor. The idea was to use the oscMessage variable instead, so it can vary with each bubble. Idem for the image() call, use the image variable instead of the global bubblePNG one.

" but I keep getting this error: NullPointerException"
Keep in mind I cannot run your code, as I don't have all libraries (and don't want to install them...). So if you don't tell at which line you have the exception, I have a hard time finding it out. Also read the Why do I get a NullPointerException? article, it might help you in finding the error by yourself.

Well I understood most of it, I just didn't understand when you said that I need to change update() to use the new image variables. I did change the variables in the Bubble class but I still got some error messages. I think you are good at explaining..... its just me.

ok well now you have explained that further I will try again..... If I have any errors I will try and find them myself and if it still doesn't work I will let you know which line the error is on.


Thanks once again.

 

Ok I have got it working with no errors, but the bubbles drop from one point just above the middle of the screen and they only drop in one line...... not randomly from the width of the top of the screen. I think its something to do with how my variables are defined in the for loop of the Bubble class. I have tried to work it out and changed the code around but then it just freezes.

1. import hypermedia.video.*;          //  Imports the OpenCV library
   import oscP5.*;
   import netP5.*;
   
   OscP5 oscP5;
   NetAddress myBroadcastLocation;
   
   OpenCV opencv;                      //  Creates a new OpenCV object
   PImage movementImg;                 //  Creates a new PImage to hold the movement image
   int poppedBubbles;                  //  Creates a variable to hold the total number of popped bubbles
   ArrayList<Bubble> bubbles = new ArrayList<Bubble>();
   
   void setup()
   {
     size ( 640, 480 );                      //  Window size of 640 x 480
    
     oscP5 = new OscP5(this,12000);
    
     opencv = new OpenCV( this );            //  Initialises the OpenCV library
     opencv.capture( 640, 480 );             //  Sets the capture size to 640 x 480
     movementImg = new PImage( 640, 480 );   //  Initialises the PImage that holds the movement image
     poppedBubbles = 0;
   
     bubbles = new ArrayList();              //  Initialises the ArrayList
   
     myBroadcastLocation = new NetAddress("127.0.0.1",57120);
   }
   
   void draw()
   {
   bubbles.add(new Bubble("/diam1", "bubble.png"));
   bubbles.add(new Bubble("/diam2", "bubble1.png"));
   
     opencv.read();                              //  Captures a frame from the camera   
     opencv.flip(OpenCV.FLIP_HORIZONTAL);        //  Flips the image horizontally
     image( opencv.image(), 0, 0 );              //  Draws the camera image to the screen
     opencv.absDiff();                           //  Creates a difference image
      
     opencv.convert(OpenCV.GRAY);                //  Converts to greyscale
     opencv.blur(OpenCV.BLUR, 3);                //  Blur to remove camera noise
     opencv.threshold(20);                       //  Thresholds to convert to black and white
     movementImg = opencv.image();               //  Puts the OpenCV buffer into an image object
    
    
     // BUBBLE
     for (int i = 0; i < bubbles.size(); i++) {    //  For every bubble in the bubbles array
       Bubble bubble = bubbles.get(i);    //  Copies the current bubble into a temporary object
      
       if (bubble.update() == 1){                  //  If the bubble's update function returns '1'
         bubbles.remove(i);                        //  then remove the bubble from the array
       
    i--;                                      //  since we've removed a bubble from the array, we need to subtract 1 from i, or we'll skip the next bubble
      
       }
     }
   
   
   opencv.remember(OpenCV.SOURCE, OpenCV.FLIP_HORIZONTAL);    //  Remembers the camera image so we can generate a difference image next frame. Since we've
                                                                //  flipped the image earlier, we need to flip it here too.
   }
   
   
   void oscEvent(OscMessage theOscMessage) {
     /* get and print the address pattern and the typetag of the received OscMessage */
     println("### received an osc message with addrpattern "+theOscMessage.addrPattern()+" and typetag "+theOscMessage.typetag());
     theOscMessage.print();
   }
   
   
   
   
   class Bubble
   {
     int x, y;
     int bWidth, bHeight;
     String oscMessage;
     PImage image;
    
     Bubble(String oscMsg, String imgName) {
       oscMessage = oscMsg;
       image = loadImage(imgName);
       x = (int) random(0, width - 40);
       y = -image.height;
       bWidth = image.width;
       bHeight = image.height;
     }
   
   
     int update()      //   The Bubble update function
     {
       int movementAmount;          //  Create and set a variable to hold the amount of white pixels detected in the area where the bubble is
       movementAmount = 0;
      
       for( int y = bHeight; y < (bHeight + (bHeight-1)); y++ ){    //  For loop that cycles through all of the pixels in the area the bubble occupies
         for( int x = bWidth; x < (bWidth + (bWidth-1)); x++ ){
          
           if ( x < width && x > 0 && y < height && y > 0 ){             //  If the current pixel is within the screen bondaries
             if (brightness(movementImg.pixels[x + (y * width)]) > 127)  //  and if the brightness is above 127 (in this case, if it is white)
             {
               movementAmount++;                                         //  Add 1 to the movementAmount variable.
             }
           }
         }
       }
      
   
       OscMessage myOscMessage; 
      
       if (movementAmount > 5)               //  If more than 5 pixels of movement are detected in the bubble area
         {
        
           myOscMessage = new OscMessage("/diam1");
         println( myOscMessage);
         oscP5.send(myOscMessage, myBroadcastLocation); 
        
         poppedBubbles++;                    //  Add 1 to the variable that holds the number of popped bubbles
         return 1;                           //  Return 1 so that the bubble object is destroyed
        
      }
      else{      //  If less than 5 pixels of movement are detected,
         bHeight += 5;                      //  increase the y position of the bubble so that it falls down
        
         if (bHeight > height)               //  If the bubble has dropped off of the bottom of the screen
         {  return 1; }                      //  Return '1' so that the bubble object is destroyed
        
         image(image, bWidth, bHeight);    //  Draws the bubble to the screen
         return 0;                              //  Returns '0' so that the bubble isn't destroyed
      
     }
    
     }
    
   }
   
   
   
   
   
   

Notes:
The line
bubbles = new ArrayList();              //  Initialises the ArrayList
is just redundant with the declaration / initialization.
The line
        myOscMessage = new OscMessage("/diam1");
should be:
        myOscMessage = new OscMessage(oscMessage);

You add two bubbles per frame, I hope that's what you want...

In the line
      image(image, bWidth, bHeight);    //  Draws the bubble to the screen
you use bWidth and bHeight as x and y coordinates, and you don't use x and y fields. So indeed, the position isn't random.
Looks like you mix up dimensions (width and height) and coordinates.

I do want to have more bubbles after I have got it working with two.

"Looks like you mix up dimensions (width and height) and coordinates." - I'm not too sure what you mean? Do I do this so the bubbles will fall from a random width?

The last two parameters of image() are the position where to draw the image. The parameters you use are named bWidth and bHeight, implying they are dimensions / sizes, not coordinates. I think you should use x and y instead, there. Beside, that's x receiving the random position of the bubble, not bWidth.
And you should update and test y against the height, before this call, not bHeight.

Ok I'm sorry I should have realised that. However, I have tried that and nothing appears on the screen at all.