Rotate your monitor 180 degrees?
Rotate your head 180 degrees?

Just kidding. I don't know any other solutions.

Rotate your monitor 180 degrees?
Rotate your head 180 degrees?

The original would be upside down then so even that, er, 'suggestion' doesn't help.

Of the two options option 2 will be much more efficient.

Another alternative is to avoid scaling and just use translate and rotate. The code below was used to produce this image.

I am not absolutely certain but I believe this will be more efficient than scaling. My understanding is that scaling will result in another image being created and then displaying that new image. Perhaps someone else might confirm that or provide another explanation.

Anyway this is the code I used . BTW to see both the sketch size should be as wide as the image and twice its height.

1. public void setup(){
2.   size(400, 400);
3.   PImage img = loadImage("snoopy1.jpg");
4.   int imgH = img.height;
5.   int imgW = img.width;
6.  
7.   image (img, 0, imgH, imgW, imgH);
8.   translate(imgW/2, imgH);
9.   rotate(PI);
10.   translate(-imgW/2, -imgH);
11.   image (img, 0, imgH, imgW, imgH);
12.   saveFrame("snoopy2.jpg");
    
13. }

Transformations don't get you a rotated copy of the image, they could only display the image rotated. So I would say the pixel array, since you need to copy and reverse.

Code Example

1. PImage img = loadImage("http://www.atlastours.net/holyland/sea_of_galilee.jpg");
2. PImage flippedOne = createImage(img.width, img.height, RGB);
3. PImage flippedTwo = createImage(img.width, img.height, RGB);
4.  
5. void setup() {
6.   size(img.width*3, img.height);
7.   // copy and reverse using a for loop
8.   for (int i=0; i<img.pixels.length; i++) {
9.     flippedOne.pixels[img.pixels.length-1-i] = img.pixels[i];
10.   }
11.   // copy and reverse in a single line
12.   flippedTwo.pixels = reverse(img.pixels);
13. }
14.  
15. void draw() {
16.   image(img, 0, 0);
17.   image(flippedOne, img.width, 0);
18.   image(flippedTwo, img.width*2, 0);
19. }

Bit if I displayed the image in rotated form and then grabbed it...?

From my past experience in other languages I'd always avoid scaling bitmaps in real time  unless there was no alternative.

Thanks for the help both.

Well, I think get() is one of the slowest methods in Processing, it will cripple your frameRate at higher resolutions. With the upcoming Processing 2.0 all those kind of filter/pixel operations are supposed to go into GLSL shaders. If you want really good realtime performance a shader is the way to go.

Great, thanks for that info - I know nothing of shaders... more to learn!

Actually in this case I don't need good real time performance, it's just for generating tiles in advance but it's worth knowing what methods are available :D

Also I didn't know about reverse() - that is very handy!

I see now that you want a mirrored image. This can be done without rotation or scaling if we use OpenGL in the form of the P2D renderer. (actually the example I gave earlier can also be done using the same technique).

The picture on the right was created using textured quads and modifying the texture coordinates. Here is the code:

1. public void setup() {
2.   size(400, 400, P2D);
3.   PImage img = loadImage("snoopy1.jpg");
4.   int imgH = img.height;
5.   int imgW = img.width;
6.   translate(0, imgH);
7.   beginShape(QUADS);
8.   texture(img);
9.   vertex(0, 0, 0, 0);
10.   vertex(0, imgH, 0, 1);
11.   vertex(imgW, imgH, 1, 1);
12.   vertex(imgW, 0, 1, 0);
13.   endShape();
14.   translate(0, -imgH);
15.   beginShape(QUADS);
16.   texture(img);
17.   vertex(0, 0, 0, 1);
18.   vertex(0, imgH, 0, 0);
19.   vertex(imgW, imgH, 1, 0);
20.   vertex(imgW, 0, 1, 1);
21.   endShape();
22.   saveFrame("snoopy2.jpg");
23. }

Thank you quarks - I need to read up a little more to understand how that works!