Processing: Manejando imágenes

Processing es un entorno de desarrollo que permite a artistas, diseñadores y entusiastas en general crear aplicaciones para manipular imágenes, sonidos e interacción en general de manera sencilla.
La idea es presentar alguna de las posibilidades de processing usando una cámara.
En este articulo me voy a concentrar en un programa que captura y muestra constantemente imágenes de la cámara, en el momento que se hace clic en el mouse una nueva imagen estática es volcada al área de visualización como si fuese una foto.
La forma de implementar este programa no es única, elegí una forma que sea sencilla de leer y muestre varios elementos de processing.
Los comentarios están incluidos en el código de forma tal que se pueda copiar y pegar directamente en processing.

// Indico que paquetes importar.
import processing.video.*;

// Declaro los objetos que voy a usar.
// La forma de declarar un objeto es:
// TipoDeObjeto nombreDelObejto;
// myCapture representara a la cámara.
Capture myCapture;
// capturedPhoto: almacenara la imagen capturada al
// momento de hacer clic en el mouse

PImage capturedPhoto;
// graphicBuffer es un objeto intermedio que permite
// manipular las gráficos
PGraphics graphicBuffer;

// Declaro dos números enteros y les asigno el valor:

// w representa el ancho de una imagen.
// h representa la altura de una imagen.
int w = 320;
int h = 240;

// Declaro e inicializo una variable que me servirá
// como indicador para saber si debo volcar una
// nueva imagen en la visualización.
boolean newPhoto = false;

// Función de inicialización:
void setup() {
 // Preparo la zona de visualización, serán dos
 // imágenes distribuidas horizontalmente,
 // por eso w*2 indica un ancho del doble de una imagen

 size( w * 2, h, P2D );

 // Negro para el fondo del área de visualización
 background( 0 );
 // Creo gráfico intermedia para guardar la imagen 
 // capturada

 graphicBuffer = createGraphics( w, h, P2D );

 // Creo el objeto que maneja la cámara:
 // En este caso usara la ultima cámara utilizada por 
 // quicktime. Parámetros:
 // this: Esta aplicacion
 // w, h: son el ancho y el largo de la imagen capturada
 // 5: es la cantidad de cuadros por segundo a capturar

 myCapture = new Capture( this, w, h, 5 );

}
// Esta función es llamada por procesing cada vez que 
// el usuario hace clic con el mouse
void mouseClicked() {
 // Guardo la imagen actual, este área de gráficos que
 // me permitirá en un futuro dibujar o trabajar sobre la

 // imagen capturada
 graphicBuffer.set(0, 0, myCapture);

 // Convierto el área de gráficos en una imagen común
 // para poder mostrarla fácilmente.
 capturedPhoto = graphicBuffer.get();
 // Inidico que se ha capturado una nueva imagen.

 newPhoto = true;
}

// Esta función es llamada por processing por cada imagen
// disponible de la cámara
void captureEvent(Capture myCapture) {

 // ¿Existe una nueva imagen desde la cámara?
 if(myCapture.available()) {
   // Leo de la cámara la nueva imagen
   myCapture.read();

 }
}

void draw() {
 // Actualizo la visualización con la imagen obtenida
 // captureEvent()

 image(myCapture, 0, 0);
 // Pregunto si existe una imagen capturada con el clic 
 // del mouse

 if (newPhoto != false) {
   // Si hay imagen, la vuelco en el área de visualización,
   // al lado de la imagen antes dibujada, por eso la

   // posición de esta nueva imagen, será w,0 que indica 
   // un desplazamiento horizontal igual al ancho de una 
   // imagen (w)
   image(capturedPhoto, w , 0);

   // Vuelvo el aviso de imagen capturada a falso
   newPhoto = false;
 }
}