https://dropbox.com/s/o4uqt074bx8mjo9/saved.png?dl=0

ArrayList<Cube> myCubes = new ArrayList<Cube>();

void setup() {
  size(800, 800, P3D);
  frameRate(60);
  for (int i = 0; i < 30; i++){
    myCubes.add(new Cube());
  }

}

void draw() {
  background(0);
  for (Cube myCube : myCubes) {
    myCube.display();
  }
}

class Cube {
  PImage tex, tex1, tex2, tex3, tex4, tex5;
  float x;
  float y;
  float scale;

  public Cube() {
    this.x = random(width);
    this.y = random(height);
    this. scale = 30;

    tex = loadImage("image0.jpg");
    tex1 = loadImage("image1.jpg");
    tex2 = loadImage("image2.jpg");
    tex3 = loadImage("image3.jpg");
    tex4 = loadImage("image4.jpg");
    tex5 = loadImage("image5.jpg");
  }

  void display() {
    noStroke();
    pushMatrix();
    translate(x, y, 0);
    rotateY(map(mouseX, 0, width, 0, PI));
    rotateX(map(mouseY, 0, height, 0, PI));
    scale(scale);


    textureMode(NORMAL);

    beginShape(QUADS);
    texture(tex);

    // +Z "front" face
    vertex(-1, -1, 1, 0, 0);
    vertex( 1, -1, 1, 1, 0);
    vertex( 1, 1, 1, 1, 1);
    vertex(-1, 1, 1, 0, 1);
    endShape();
    beginShape(QUADS);
    // -Z "back" face
    texture(tex1);
    vertex( 1, -1, -1, 0, 0);
    vertex(-1, -1, -1, 1, 0);
    vertex(-1, 1, -1, 1, 1);
    vertex( 1, 1, -1, 0, 1);

    endShape();
    beginShape(QUADS);
    // +Y "bottom" face
    texture(tex2);
    vertex(-1, 1, 1, 0, 0);
    vertex( 1, 1, 1, 1, 0);
    vertex( 1, 1, -1, 1, 1);
    vertex(-1, 1, -1, 0, 1);

    endShape();
    beginShape(QUADS);
    // -Y "top" face
    texture(tex3);
    vertex(-1, -1, -1, 0, 0);
    vertex( 1, -1, -1, 1, 0);
    vertex( 1, -1, 1, 1, 1);
    vertex(-1, -1, 1, 0, 1);

    endShape();
    beginShape(QUADS);
    // +X "right" face
    texture(tex4);
    vertex( 1, -1, 1, 0, 0);
    vertex( 1, -1, -1, 1, 0);
    vertex( 1, 1, -1, 1, 1);
    vertex( 1, 1, 1, 0, 1);

    endShape();
    beginShape(QUADS);
    // -X "left" face
    texture(tex5);
    vertex(-1, -1, -1, 0, 0);
    vertex(-1, -1, 1, 1, 0);
    vertex(-1, 1, 1, 1, 1);
    vertex(-1, 1, -1, 0, 1);
    endShape();
    popMatrix();
  }
}

In theory, if I manipulate the matrix stack (with translations, rotations, and scaling), draw something, say an ellipse, record the current matrix, pop out of the stack (or otherwise reset the current matrix), and then apply my recorded matrix and draw an identical ellipse, they should draw on top of one another. This isn't what happens on my machine. Why?

Here is an example sketch that, using the above algorithm, should draw two ellipses on top of one another.

void setup(){
  size(100,100,P3D);  
}

void draw(){
  background(0);
  //draw first ellipse
  noFill();  stroke(255);
  pushMatrix();
    translate(width/2,height/2);
    rotateX(millis()/2000.f);
    PMatrix3D pMat = new PMatrix3D();
    getMatrix(pMat); //record current matrix
    ellipse(0,0,50,50);
  popMatrix();

  //draw second ellipse
  fill(255,0,0);  noStroke();
  pushMatrix();
    applyMatrix(pMat);
    ellipse(0,0,50,50);
  popMatrix();
}

This simple test fails on windows in the 64bit Processing 2.1.1, why?

There shouldn't be gray there? I have no idea what the issue is and I can't find anyone else who's already posted this problem on the internet, but apologies if the answer is out there and I've been searching by the wrong terms or something. Here is my code, relevant bit is at the bottom:

    PImage img; 
    PImage destination;
    FloatList sBlob;

    void setup() {
      img = loadImage("prince-street-bike-lane.jpg");
      destination = createImage(150,150, HSB);
      size(1000, 1000);
      colorMode(HSB, 360, 100, 100);
      sBlob = new FloatList();

      img.loadPixels();
      float highestAverage = 0;
      int highestLocStart = 0;
      float blobAverage = 0;
      float satch = 0;
      int loc = 0;
      int sloc = 0;

      for (int x = 0; x < img.width - destination.width; x++) {
        for (int y = 0; y < img.height - destination.height; y++ ) {
          blobAverage = 0;
          loc = x + y*img.width;
          sBlob.clear();

          for (int sx = 0; sx < destination.width; sx++) {
            for (int sy = 0; sy < destination.height; sy++ ) {
              sloc = loc + sx + sy*img.width;
              satch = saturation(img.pixels[sloc]);
              sBlob.append(satch);
            }
          }
          for (int i = 0; i < sBlob.size(); i++) {
            blobAverage += sBlob.get(i);
          }
          blobAverage = blobAverage/sBlob.size();
          if (blobAverage > highestAverage){
            highestAverage = blobAverage;
            highestLocStart = loc;
          }
          print(x + " ");
        }
      }

      for (int x = 0; x < destination.width; x++) {
        for (int y = 0; y < destination.height; y++ ) {
          int dloc = x + y*destination.width;
          int iloc = (x + y*img.width) + highestLocStart;
          float h = hue(img.pixels[iloc]);
          float s = saturation(img.pixels[iloc]);
          float b = brightness(img.pixels[iloc]);
          destination.pixels[dloc]  = color(h,s,b);
        }
      }

      destination.updatePixels();

      int sx = -1;
      int sy = -1;
      for (int x = 0; x < width; x += destination.width) {
        sx *= -1;
        for (int y = 0; y < height; y += destination.height) {
          sy *= -1;
          pushMatrix();
          scale(sx, sy);
          image(destination,x,y);
          popMatrix();
        }
      }
    }

I'm not super experienced so if you think I'm going about this code in completely the wrong way, feel free to make suggestions. I'm on a mac with current OS and using processing 2.2.1.

that Understanding pushMatrix() and popMatrix() requires understanding the concept of a matrix stack.

Where can I learn more about matrix stacks?