Parte 1: Introducción a Processing, gráficos, eventos y transformaciones
Bloque A. Programación Gráfica Multimedia | CDPC.1.A.4 y CDPC.1.A.5
Currículo LOMLOE - Andalucía | Saberes básicos:
- CDPC.1.A.4. Funciones. Introducción al uso de funciones gráficas: punto, línea, triángulo, cuadrado, rectángulo, círculo, elipse, sectores y arcos.
- CDPC.1.A.5. Procesamiento de imágenes. Gráficos vectoriales. Diseño digital generativo basado en algoritmos. Eventos: ratón y teclado. Uso de la línea y el punto para dibujar líneas a mano alzada. Operaciones en el espacio: translaciones, escalados, rotaciones, etc. Diseño de patrones.
PARTE I. Introducción a Processing
1. ¿Qué es Processing?
Processing (processing.org) es un entorno de programación y un lenguaje creado en el MIT (Ben Fry y Casey Reas, 2001) para aprender a programar generando imágenes, animaciones e instalaciones interactivas. Su sintaxis se basa en Java pero sin el aparato de clases y métodos main: con un mínimo código se obtiene un resultado visual. Es código abierto, gratuito y multiplataforma, base de p5.js y Processing.py, y su ejecución en tiempo real refresca el dibujo decenas de veces por segundo.
Instalación: descarga desde processing.org/download, instala y abre el programa. En el editor, el botón ▶ Ejecutar (Ctrl/Cmd + R) lanza el sketch y ■ Detener lo detiene.
1.1. Estructura de un sketch
Cada programa se llama sketch y tiene dos funciones obligatorias:
void setup() {
// Se ejecuta UNA SOLA vez al arrancar
size(600, 400); // tamaño de la ventana
background(220); // color de fondo
}
void draw() {
// Se ejecuta EN BUCLE (unas 60 veces por segundo)
// Aquí va el dibujo y la animación
}setup() se ejecuta una sola vez (tamaño, fondo, valores iniciales) y draw() lo hace en bucle continuo (dibujo, animación, eventos). Además existen funciones de eventos (mousePressed(), keyPressed()) que Processing invoca automáticamente y que estudiaremos en este mismo tema.
1.2. Funciones de color
void setup() {
size(640, 300);
background(30, 30, 60); // fondo azul oscuro RGB
fill(255, 80, 80); // interior rojo desde aquí
ellipse(140, 150, 160, 160);
fill(80, 200, 120); // interior verde
ellipse(320, 150, 160, 160);
noFill(); // sin interior: solo contorno
ellipse(500, 150, 160, 160);
stroke(255); // contorno blanco
strokeWeight(4); // grosor de 4 píxeles
line(20, 20, 620, 20);
noStroke(); // sin contorno desde aquí
fill(120, 160, 255);
rect(240, 220, 160, 60);
}| Función | Efecto |
|---|---|
background(r, g, b) | Borra y pinta toda la ventana |
fill(r, g, b) | Color del interior de las figuras |
stroke(r, g, b) | Color del contorno |
noFill() / noStroke() | Suprime el interior o el contorno |
strokeWeight(n) | Grosor del contorno en píxeles |
fill(255) es blanco, fill(0) es negro, fill(128) gris medio; con tres valores se usa el modelo RGB (0–255) y también vale el hexadecimal fill(#1E90FF).
2. Funciones gráficas básicas
Coordenadas: el origen (0, 0) es la esquina superior izquierda; el eje X crece hacia la derecha y el eje Y hacia abajo. width y height son variables con el tamaño de la ventana.
2.1. Punto: point(x, y)
void setup() {
size(400, 200);
background(255);
stroke(0);
strokeWeight(4);
for (int x = 20; x < 380; x += 10) {
point(x, 100); // fila de puntos cada 10 píxeles
}
}2.2. Línea: line(x1, y1, x2, y2)
void setup() {
size(400, 300);
background(255);
stroke(0, 100, 200);
strokeWeight(3);
line(50, 50, 350, 50); // horizontal
line(50, 50, 50, 250); // vertical
line(50, 250, 350, 50); // diagonal
}2.3. Triángulo: triangle(x1, y1, x2, y2, x3, y3)
Recibe las coordenadas de sus tres vértices, en cualquier orden:
void setup() {
size(400, 300);
background(255);
fill(255, 180, 60);
stroke(120, 70, 0);
strokeWeight(2);
triangle(200, 40, 60, 260, 340, 260);
}2.4. Rectángulo: rect() y cuadrado: square()
rect(x, y, w, h) toma la esquina superior izquierda (x, y), el ancho w y el alto h; square(x, y, s) es lo mismo con ancho = alto.
void setup() {
size(500, 300);
background(255);
fill(120, 200, 255);
rect(40, 40, 200, 120); // rectángulo 200x120
fill(255, 150, 180);
square(280, 40, 120); // cuadrado de lado 120
fill(180, 240, 160);
rect(40, 200, 420, 70, 20); // radio de esquina 20
}2.5. Círculo: circle() y elipse: ellipse()
Ambas toman el centro: circle(x, y, d) usa el diámetro d; ellipse(x, y, w, h) usa ancho y alto (si w == h, es un círculo).
void setup() {
size(500, 300);
background(255);
fill(255, 220, 100);
stroke(200, 150, 0);
circle(120, 150, 160); // círculo de diámetro 160
fill(200, 160, 255);
ellipse(340, 150, 240, 120); // elipse ancha
noFill();
stroke(0);
ellipse(340, 150, 120, 240); // elipse alta
}2.6. Arco y sector: arc()
arc(x, y, w, h, inicio, fin, [modo]) dibuja la porción de elipse entre dos ángulos.
void setup() {
size(600, 240);
background(255);
noStroke();
fill(255, 120, 120);
arc(100, 120, 160, 160, 0, PI/2, PIE); // sector relleno
fill(120, 200, 255);
arc(300, 120, 160, 160, 0, PI/2, CHORD); // arco cerrado con cuerda
fill(150, 240, 150);
arc(500, 120, 160, 160, 0, PI/2, OPEN); // solo el trazo
}Ángulos en radianes
Processing mide los ángulos en radianes: 360º = 2π, 180º = π, 90º = π/2. Piensa en sectores circulares: el ángulo 0 apunta a la derecha y crece en sentido horario (porque el eje Y apunta hacia abajo). Por eso arc(x, y, w, h, 0, HALF_PI) ocupa el cuarto situado abajo a la derecha del centro.
| Grados | Radianes | Constante |
|---|---|---|
| 0º | 0 | 0 |
| 90º | 1.5708... | HALF_PI |
| 180º | 3.14159... | PI |
| 270º | 4.712... | PI + HALF_PI |
| 360º | 6.283... | TWO_PI |
Modos de arc(): sectores y arcos
| Modo | Resultado |
|---|---|
PIE | Sector relleno: une los extremos con el centro |
CHORD | Arco cerrado: une los extremos con una cuerda recta |
OPEN | Arco abierto: solo dibuja la curva (necesita stroke) |
Con arc(x, y, w, h, 0, TWO_PI, PIE) se dibuja exactamente un círculo relleno.
3. Sketch completo de ejemplo
// composicion.pde
void setup() {
size(700, 400);
background(30, 40, 60); // fondo azul noche
stroke(255);
strokeWeight(3);
for (int i = 0; i < 10; i++) {
point(40 + i * 30, 40); // diez puntos alineados
}
stroke(255, 200, 0); // línea horizontal
strokeWeight(2);
line(40, 70, 660, 70);
noStroke(); // figuras con relleno
fill(255, 120, 120);
triangle(90, 130, 40, 230, 140, 230); // triángulo
fill(120, 220, 160);
rect(180, 130, 120, 100); // rectángulo
fill(120, 170, 255);
square(330, 130, 100); // cuadrado
fill(255, 210, 90);
circle(500, 180, 100); // círculo
fill(220, 150, 255);
ellipse(620, 180, 110, 70); // elipse
fill(255, 150, 150); // arcos y sectores
arc(90, 330, 120, 120, 0, HALF_PI, PIE); // sector de 90º
fill(150, 220, 255);
arc(250, 330, 120, 120, 0, PI, CHORD); // media elipse con cuerda
noFill();
stroke(200, 255, 200);
strokeWeight(4);
arc(430, 330, 120, 120, PI, TWO_PI, OPEN); // arco superior abierto
fill(255, 235, 120);
noStroke();
arc(610, 330, 120, 120, 0, TWO_PI, PIE); // círculo relleno
}Consejo de trabajo
Escribe los sketches por partes y ejecuta tras cada figura que añadas: si esperas a escribir el código entero, localizar el error será mucho más costoso.
PARTE II. Gráficos vectoriales, eventos y transformaciones
4. Gráficos vectoriales y diseño generativo
4.1. Gráficos vectoriales frente a mapa de bits
En procesamiento de imágenes conviven dos grandes familias de representación:
| Característica | Gráfico vectorial | Imagen de mapa de bits |
|---|---|---|
| Elemento básico | Primitivas geométricas (punto, línea, curva) | Píxeles en una rejilla |
| Escalado | Sin pérdida de calidad | Se pixela y se degrada |
| Edición | Se modifican los objetos por separado | Se modifican píxeles sueltos |
| Tamaño de archivo | Suele ser menor en dibujos técnicos | Crece con la resolución |
| Uso típico | Logotipos, ilustración, tipografía, croquis | Fotografías, capturas, texturas |
En Processing trabajamos sobre todo con gráficos vectoriales: cada forma se describe mediante coordenadas y parámetros (line(x1, y1, x2, y2)), de modo que podemos redibujarla a otra escala sin que se deteriore. La imagen de mapa de bits se estudia en el Tema 2, Parte 2.
4.2. Diseño digital generativo basado en algoritmos
Un diseño generativo es aquel cuya apariencia final la define un algoritmo: el artista no dibuja cada trazo a mano, sino que fija reglas, parámetros y grados de azar, y el programa produce la obra. Sus rasgos fundamentales son:
- Regla explícita: el diseño se describe como una secuencia finita de instrucciones (CDPC.1.A.2).
- Iteración: se repiten módulos, simetrías o variaciones mediante bucles (CDPC.1.A.3).
- Parámetros variables: colores, longitudes, densidades o semillas aleatorias que producen familias enteras de composiciones.
- Emergencia: de reglas simples aparecen estructuras visuales complejas y difíciles de prever a simple vista.
Ejemplos habituales: tramas de líneas con variación de grosor, mosaicos irregulares, estelas de partículas, composiciones tipográficas repetidas, mapas abstractos generados a partir de datos o de números aleatorios.
// Composición generativa: rejilla de cuadrados con tamaño y tono aleatorios.
// Cada ejecución produce una variante distinta de la misma regla.
size(600, 600);
noStroke();
int celda = 40; // tamaño de celda de la rejilla
for (int x = 0; x < width; x += celda) {
for (int y = 0; y < height; y += celda) {
float t = random(0.2, 1.0); // parámetro aleatorio por celda
fill(40 + 180 * t, 90, 160 + 70 * t);
float lado = celda * t; // el lado depende del parámetro
rect(x + (celda - lado) / 2, y + (celda - lado) / 2, lado, lado);
}
}5. Eventos: ratón y teclado
5.1. ¿Qué es un evento?
Un evento es cualquier acción del usuario (pulsar el ratón, moverlo, teclear) que interrumpe el flujo normal del programa. Processing ofrece una solución sencilla: basta con definir una función con un nombre concreto y el entorno la ejecutará automáticamente cada vez que ocurra ese suceso. No hay que registrar ningún oyente ni escribir un bucle de espera.
Las funciones de evento se escriben fuera de setup() y de draw(), normalmente al final del archivo:
void mousePressed() { ... } // al pulsar un botón del ratón
void mouseDragged() { ... } // al arrastrar con un botón pulsado
void mouseReleased() { ... } // al soltar el botón
void keyPressed() { ... } // al pulsar una tecla
void keyReleased() { ... } // al soltar la tecla5.2. Variables disponibles del ratón y del teclado
| Variable | Tipo | Significado |
|---|---|---|
mouseX, mouseY | int | Posición actual del puntero en el lienzo |
pmouseX, pmouseY | int | Posición del puntero en el frame anterior |
mousePressed | boolean | true mientras hay un botón pulsado |
mouseButton | int | Botón activo: LEFT, RIGHT o CENTER |
key | char | Última tecla pulsada (carácter) |
keyCode | int | Código numérico de la tecla (flechas, MAYÚS...) |
Consejo:
pmouseX/pmouseYes la clave para dibujar trazos continuos: conectando la posición actual con la anterior obtenemos un segmento por cada fotograma.
5.3. Ejemplo: pintar al arrastrar y borrar con la barra espaciadora
// Pizarra con eventos de ratón y teclado.
// - Arrastrar el ratón dibuja un trazo.
// - Pulsa 'c' o la barra espaciadora para limpiar el lienzo.
size(640, 400);
background(30);
stroke(255);
strokeWeight(3);
void draw() {
// Dibujo continuo: se actualiza solo cuando el botón está pulsado
if (mousePressed) {
line(pmouseX, pmouseY, mouseX, mouseY);
}
}
void mousePressed() {
// Un punto inicial evita el "salto" de la primera línea
point(mouseX, mouseY);
}
void keyPressed() {
if (key == 'c' || key == 'C' || key == ' ') {
background(30); // borrar el lienzo
}
}5.4. Ejemplo: dibujo a mano alzada combinando point() y line()
El dibujo a mano alzada es el ejemplo clásico de uso conjunto de punto y línea: se coloca un punto en la posición actual y se traza un segmento hacia ella desde la anterior.
// Dibujo a mano alzada con cambio de color y grosor por teclado.
// Teclas: '+' engrosa el trazo, '-' lo adelgaza, 'l' limpia.
size(700, 450);
background(255);
stroke(20, 60, 140);
strokeWeight(4);
noFill();
void draw() {
if (mousePressed) {
// punto en la posición actual del ratón
point(mouseX, mouseY);
// y segmento desde la posición del fotograma anterior
line(pmouseX, pmouseY, mouseX, mouseY);
}
}
void mouseDragged() {
// coloreamos el trazo según la posición horizontal
stroke(mouseX * 255 / width, 80, 180);
}
void keyPressed() {
if (key == '+') strokeWeight(strokeWeight + 1);
if (key == '-') strokeWeight(max(1, strokeWeight - 1));
if (key == 'l' || key == 'L') {
background(255);
strokeWeight(4);
}
}Atención
Si en mousePressed() no dibujas nada, al hacer clic y arrastrar de golpe puede aparecer un hueco en el trazo: pmouseX/pmouseY aún no se ha actualizado. Por eso se marca primero un point() en la posición actual.
6. Transformaciones espaciales
6.1. El sistema de coordenadas y la matriz de transformación
De forma predeterminada, el origen (0, 0) está en la esquina superior izquierda y el eje X crece hacia la derecha y el eje Y hacia abajo. Las transformaciones no modifican los datos de las figuras: modifican el sistema de referencia en el que se dibuja, mediante una matriz interna que Processing multiplica por cada coordenada.
Las tres transformaciones fundamentales son:
translate(dx, dy): desplaza el origen del sistema (traslación).rotate(ángulo): gira el sistema alrededor del origen, en radianes (giro positivo = sentido horario porque Y apunta hacia abajo).scale(sx, sy): escala el sistema (ampliación o reducción).
// Las tres transformaciones básicas aplicadas a un rectángulo.
size(640, 360);
background(20);
stroke(255);
noFill();
// Traslación: el rectángulo se dibuja desplazado
translate(120, 180);
rect(0, 0, 80, 50);
// Rotación: giramos el sistema 45 grados y volvemos a dibujar
rotate(radians(45));
rect(140, 0, 80, 50);
// Escalado: ampliamos el sistema 2 veces
scale(2);
rect(0, -140, 30, 20);Unidad de ángulo: Processing trabaja en radianes.
radians(90)convierte 90 grados aPI/2radianes; a la inversa,degrees(PI)devuelve 180.
6.2. El orden importa
Las transformaciones se aplican en el orden en que se escriben, de arriba abajo. Si cambiamos el orden, el resultado es distinto:
// Comparación del orden de las transformaciones.
size(640, 240);
background(20);
stroke(255);
noFill();
// Caso A: primero trasladar y después girar -> gira alrededor del nuevo origen
translate(160, 120);
rotate(radians(45));
rect(-30, -30, 60, 60);
// Caso B: primero girar y después trasladar -> rota en torno al origen original
translate(480, 120);
rect(-30, -30, 60, 60);
rotate(radians(45));
rect(-30, -30, 60, 60);6.3. pushMatrix() y popMatrix()
Cada transformación es acumulativa: si trasladas 100 px y vuelves a trasladar 100 px, acabas en 200 px. Para que una figura quede aislada del efecto de las transformaciones anteriores se guarda el estado con pushMatrix() y se restaura con popMatrix():
// Estado de transformación: cada estrella se dibuja en su propio sistema.
size(640, 360);
background(15, 25, 45);
stroke(255, 210, 90);
strokeWeight(2);
fill(255, 120, 60, 90);
for (int i = 0; i < 6; i++) {
pushMatrix(); // guardo el sistema actual
translate(90 + i * 95, 180); // me muevo a la posición de la figura
rotate(radians(i * 15)); // giro local, no afecta a las demás
scale(0.6 + i * 0.15); // escala local
rect(-35, -35, 70, 70);
ellipse(0, 0, 30, 30);
popMatrix(); // restauro el sistema anterior
}La regla práctica es: todo lo que se dibuje entre pushMatrix() y popMatrix() vive en su propio sistema de coordenadas.
7. Diseño de patrones
7.1. Patrones con bucles y transformaciones
Un patrón es una estructura visual que se repite según una regla. Combinando bucles (repeticiones) con transformaciones (desplazamientos, giros, escalados) obtenemos tres familias clásicas:
- Rejillas: dos bucles anidados que desplazan el origen.
- Espirales: un solo bucle que acumula rotación y traslación.
- Rosetas: giros sucesivos alrededor de un mismo centro (simetría rotacional).
7.2. Rejilla de motivos
// Rejilla 8x5 con rotación alternada: patrón textil sencillo.
size(640, 400);
background(250, 245, 235);
stroke(30);
strokeWeight(1.5);
fill(90, 160, 200);
int filas = 5, columnas = 8;
float ancho = width / columnas;
float alto = height / filas;
for (int f = 0; f < filas; f++) {
for (int c = 0; c < columnas; c++) {
pushMatrix();
translate(c * ancho + ancho / 2, f * alto + alto / 2);
// alternamos la orientación para crear ritmo visual
if ((f + c) % 2 == 0) rotate(radians(45));
rect(-18, -18, 36, 36);
popMatrix();
}
}7.3. Espiral de cuadrados
// Espiral construida acumulando rotación y traslación en cada paso.
size(640, 640);
background(10);
noFill();
strokeWeight(2);
translate(width / 2, height / 2); // centro de la espiral
float angulo = 0;
float distancia = 0;
for (int i = 0; i < 220; i++) {
angulo += radians(13); // giro acumulado (ángulo áureo aproximado)
distancia += 2.4; // radio creciente
stroke(80 + i, 200 - i / 2, 255);
pushMatrix();
rotate(angulo);
translate(distancia, 0);
rect(-6, -6, 12, 12);
popMatrix();
}7.4. Roseta con simetría rotacional
// Roseta de 12 pétalos: se dibuja una vez y se replica rotando.
size(600, 600);
background(20, 12, 30);
stroke(255, 190, 80);
strokeWeight(1.5);
fill(255, 90, 140, 70);
translate(width / 2, height / 2); // centro del lienzo
int n = 12; // número de pétalos
for (int i = 0; i < n; i++) {
pushMatrix();
rotate(TWO_PI * i / n); // giro equiespaciado (360° / n)
ellipse(70, 0, 140, 40); // pétalo desplazado sobre el eje X
popMatrix();
}
// centro decorativo
fill(255, 220, 120);
ellipse(0, 0, 60, 60);8. Síntesis
| Aprendizaje | Herramienta en Processing |
|---|---|
| Gráficos vectoriales | Figuras definidas por coordenadas, escalables sin pérdida |
| Diseño generativo | Algoritmo + parámetros + azar controlado |
| Eventos de ratón | mousePressed(), mouseDragged(), mouseReleased(), mouseX/Y, pmouseX/Y |
| Eventos de teclado | keyPressed(), keyReleased(), key, keyCode |
| Dibujo a mano alzada | point() + line(pmouseX, pmouseY, mouseX, mouseY) |
| Transformaciones | translate(), rotate(), scale() |
| Aislamiento de estado | pushMatrix() / popMatrix() |
| Patrones | Bucles + transformaciones (rejilla, espiral, roseta) |
Ejercicios
- Sketch con figuras. Crea un sketch de 600 × 400 que dibuje: fondo a tu elección, tres círculos de distinto tamaño y color, dos rectángulos, un cuadrado, un triángulo, cuatro líneas en cruz y un punto de grosor 10 en el centro. Usa
fill(),stroke(),strokeWeight(),noFill()ynoStroke(). - Tarta de sectores. Crea un sketch que dibuje una "tarta" de 4 sectores (
PIE) con aperturas 0–HALF_PI,HALF_PI–PI,PI–PI + HALF_PIyPI + HALF_PI–TWO_PI, cada uno de un color. Repite la misma figura conCHORDy conOPENy explica por escrito las diferencias visuales entre los tres modos. - Mural interactivo. Crea un sketch donde, al mantener pulsado el ratón y arrastrarlo, se dibujen cuadrados de 20 px de lado en la posición del puntero, con un color que dependa de
mouseY. Al pulsar la teclag, el lienzo debe limpiarse. Incluye un comentario que explique por qué se usapmouseX/pmouseY. - Retrato a mano alzada. Diseña una herramienta de dibujo con tres modos seleccionados por teclas:
1trazo fino y azul,2trazo grueso y rojo,3borrador (color del fondo). Añade una funciónmouseReleased()que dibuje un círculo pequeño en el punto de soltado para marcar el final del trazo. - Patrón de damero rotado. Genera una rejilla de 10 × 10 celdas en la que solo se dibuje un cuadrado cuando la suma de los índices de fila y columna sea par. Aplica
rotate(radians(45))dentro depushMatrix()/popMatrix()de modo que cada cuadrado gire sobre su propio centro. Explica con una frase qué ocurriría si eliminaras las llamadas apushMatrix()ypopMatrix(). - Roseta de pétalos elípticos. Dibuja una roseta con 20 pétalos usando
ellipse()y rotaciones deTWO_PI * i / 20. Para cada pétalo, varía el color conmap(i, 0, 19, 0, 255)y la longitud del eje mayor entre 60 y 160 px. El resultado debe quedar centrado en el lienzo. - Espiral de Fibonacci visual. Partiendo del bucle de la espiral de la sección 7.3, sustituye el incremento lineal de la distancia por el incremento que proporciona la secuencia de Fibonacci (1, 1, 2, 3, 5, 8, 13, 21...). Genera la secuencia con un bucle y dibuja un cuadrado por cada término. (Se conecta con el Tema 2, Parte 2.)
- Analiza el siguiente código y describe, sin ejecutarlo, qué se verá en pantalla y por qué. Después modifícalo para que la figura resultante sea el doble de grande y esté desplazada 50 px a la derecha:
size(500, 300);
background(255);
translate(250, 150);
rotate(radians(30));
rect(-40, -40, 80, 80);