Translate

COLORMONO

Static, Interactive & Motion Designer

A la manera de Mondrian

Arte generativo

Trabajo práctico parcial “A la manera de Piet Mondrian”, Informática Aplicada I, Profesor Raúl Lacabanne, IUNA.

“Solo cuando estemos en lo real absoluto, el arte no será ya más necesario.”

P. Mondrian

El trabajo es un sketch en Processing que cada 10 segundos genera una imagen que “imita” los estilos de composición de Piet Mondrian. Estas imágenes se generan continuamente y nunca una es igual a otra, son piezas que nacen y mueren en el transcurso de 10 segundos.

Descargar código fuente

A la manera de Mondrian

A la manera de Mondrian

/*
 * TP Parcial: A la manera de Piet Mondrian
 * Obra: Retícula Cósmica
 * Concepto: "Solo cuando estemos en lo real absoluto, el arte no será ya más necesario." P. Mondrian
 *
 * Informática Aplicada I - IUNA
 * Mariano Rivas (30.591.163)
 * http://colormono.com
 *
 ****************************************************************/
 
// Definiciones
boolean pintando = false;                                        // Comienza pintando o pensando que pintar?
boolean grid = false;                                            // Muestra la grilla de construccion?
int ciclos = 0;                                                  // Primer ciclo (Duracion = ciclosTotales - ciclos)
int ciclosTotales = 300;                                         // Cantidad de ciclos antes del reinicio
int Principales = 1;                                             // Cantidad de Bloques Principales
int Secundarios = 2;                                             // Cantidad de Bloques Secundarios
int Terciarios = 3;                                              // Cantidad de Bloques Terciarios
int Complementarios = 3;                                         // Cantidad de Bloques Complementarios
Rectangulo[] principal = new Rectangulo[Principales];            // Declaración y creación del array
Rectangulo[] secundarios = new Rectangulo[Secundarios];          // Declaración y creación del array
Rectangulo[] terciarios = new Rectangulo[Terciarios];            // Declaración y creación del array
Rectangulo[] complementarios = new Rectangulo[Complementarios];  // Declaración y creación del array
Transition bgCanvas = new Transition();                          // Declaración y Construccion del Objeto para las transiciones
Transition bgMascara = new Transition();                         // Declaración y Construccion del Objeto para las transiciones
 
// Variables internas de construccion
float bloque, Xpos, Ypos, BordeAncho, MargenError, margenSup, margenDer, margenInf, margenIzq;
int Ancho, Alto, BordeSuperior, BordeInferior, BordeIzquierdo, BordeDerecho;
color Color, ColorPrincipal, ColorSecundario, ColorTerciario, ColorComplementario, BordeColor, blanco, negro, rojo, amarillo, azul;
 
void setup(){
  size(512,512);                                                 // Tamaño del lienzo
  colorMode(HSB, 360, 100, 100, 100);                            // Modo de color
  randomSeed(0);                                                 // Fuerza los mismos valores aleatorios
  smooth();                                                      // Filtro antiAlias
  //noCursor();                                                    // Apago el cursor
  //println(frameCount);                                           // Medir FrameRate
}
 
void draw(){
 
  // Si no esta pintando, piensa que tiene que pintar
  if (pintando == false){
 
    // Parametros Globales
    bloque = width / 32;                                        // Grilla: 32 x 32 bloques
    blanco = color(39, 13, 95, 100);                            // Color Blanco
    negro = color(348, 83, 7, 100);                             // Color Negro
    rojo = color(8, 88, 88, 100);                               // Color Rojo
    amarillo = color(53, 99, 93, 100);                          // Color Amarillo
    azul = color(222, 65, 61, 100);                             // Color Azul
    BordeAncho = round(random(5,8));                            // Grosor del borde
    BordeSuperior = 2 * round(random(4, 24) % 16);              // Continuacion del borde superior
    BordeInferior = 2 * round(random(4, 24) % 16);              // Continuacion del borde inferior
    BordeIzquierdo = 2 * round(random(4, 24) % 16);             // Continuacion del borde izquierdo
    BordeDerecho = 2 * round(random(4, 24) % 16);               // Continuacion del borde derecho
    MargenError = round(random(0, 5));                          // Aberraciones en las terminaciones
    strokeCap(SQUARE);                                          // Tipo de borde
    int defineColor = round(random(0,3));                       // Paleta a utilizar
    switch(defineColor){
    case 0:
      ColorPrincipal = rojo;
      ColorSecundario = azul;
      ColorTerciario = amarillo;
      ColorComplementario = negro;
      BordeColor = negro;
      break;
    case 1:
      ColorPrincipal = azul;
      ColorSecundario = rojo;
      ColorTerciario = amarillo;
      ColorComplementario = negro;
      BordeColor = negro;
      break;
    case 2:
      ColorPrincipal = amarillo;
      ColorSecundario = rojo;
      ColorTerciario = azul;
      ColorComplementario = negro;
      BordeColor = negro;
      break;
    default:
      ColorPrincipal = blanco;
      ColorSecundario = blanco;
      ColorTerciario = azul;
      ColorComplementario = rojo;
      BordeColor = amarillo;
      break;
    }
 
    // Bloques Principales
    for (int i = 0; i < principal.length; i++) {
      Xpos = 2 * round(random(0, 16) % 8);
      Ypos = 2 * round(random(0, 16) % 8);
      Ancho = 2 * round(random(4, 8));
      Alto = 2 * round(random(4, 8));
      principal[i] = new Rectangulo(ColorPrincipal, Xpos, Ypos, Ancho, Alto, BordeColor, BordeAncho, BordeSuperior, BordeDerecho, BordeInferior, BordeIzquierdo, MargenError);
      println(Xpos + ", " + Ypos + ", " + Ancho + ", " + Alto);
    }
 
    // Bloques Secundarios
    for (int i = 0; i < secundarios.length; i++) {
      Xpos = 2 * round(random(0, 16) % 16);
      Ypos = 2 * round(random(0, 16) % 16);
      Ancho = 2 * round(random(3, 5));
      Alto = 2 * round(random(3, 5));
      secundarios[i] = new Rectangulo(ColorSecundario, Xpos, Ypos, Ancho, Alto, BordeColor, BordeAncho, BordeSuperior, BordeDerecho, BordeInferior, BordeIzquierdo, MargenError);
    }
 
    // Bloques Terciarios
    for (int i = 0; i < terciarios.length; i++) {
      Xpos = 2 * round(random(0, 16) % 32);
      Ypos = 2 * round(random(0, 16) % 32);
      Ancho = 2 * round(random(1, 3));
      Alto = 2 * round(random(1, 3));
      terciarios[i] = new Rectangulo(ColorTerciario, Xpos, Ypos, Ancho, Alto, BordeColor, BordeAncho, BordeSuperior, BordeDerecho, BordeInferior, BordeIzquierdo, MargenError);
    }
 
    // Bloques Complementarios
    for (int i = 0; i < complementarios.length; i++) {
      Xpos = 2 * round(random(0, 16) % 8);
      Ypos = 2 * round(random(0, 16) % 8);
      Ancho = 2 * round(random(0, 2));
      Alto = 2 * round(random(0, 2));
      BordeAncho = 0;
      complementarios[i] = new Rectangulo(ColorComplementario, Xpos, Ypos, Ancho, Alto, BordeColor, BordeAncho, BordeSuperior, BordeDerecho, BordeInferior, BordeIzquierdo, MargenError);
    }
 
    pintando = true;
 
    // Sino, se pone manos a la obra
  }
  else {
 
    // Si le queda tiempo sigue pintando
    if (ciclos <= ciclosTotales){
 
      // Color del lienzo
      background(blanco);
 
      // Grilla de construccion
      if (grid == true){
        for (float x = 0; x < height; x += bloque ) {
          for (float y = 0; y < width; y += bloque ) {
            stroke(negro, 1);
            strokeWeight(1);
            line(x, 0, x, height);
            line(0, y, width, y);
          }
        }
      }
 
      // Dibuja Bloques
      for (int i = 0; i < complementarios.length; i++) {
        complementarios[i].mostrar();
      }
      for (int i = 0; i < terciarios.length; i++) {
        terciarios[i].mostrar();
      }
      for (int i = 0; i < secundarios.length; i++) {
        secundarios[i].mostrar();
      }
      for (int i = 0; i < principal.length; i++) {
        principal[i].mostrar();
      }
 
      // Mascara de Entrada
      bgMascara.slideTo(0.05, 39, 13, 95); // Pasando: Velocidad (0 a 1), Tono (1 a 360), Saturacion (0 a 100), Brillo (0 a 100)
 
      ciclos ++;
 
      // Sino reinicia
    }
    else {
      bgCanvas.fadeTo(0.08, 39, 13, 95); // Pasando: Velocidad (0 a 1), Tono (1 a 360), Saturacion (0 a 100), Brillo (0 a 100)
    }
 
  } // FIN
 
}
 
// Rectangulo
class Rectangulo {
  color Color, BordeColor;
  float Xpos, Ypos, BordeAncho, MargenError, margenSup, margenDer, margenInf, margenIzq;
  int Ancho, Alto, BordeSuperior, BordeInferior, BordeIzquierdo, BordeDerecho;
 
  Rectangulo(color tempColor, float tempXpos, float tempYpos, int tempAncho, int tempAlto, color tempBordeColor,
  float tempBordeAncho, int tempBordeSuperior, int tempBordeDerecho, int tempBordeInferior,
  int tempBordeIzquierdo, float tempMargenError) {
    Color = tempColor;
    Xpos = tempXpos;
    Ypos = tempYpos;
    Ancho = tempAncho;
    Alto = tempAlto;
    BordeColor = tempBordeColor;
    BordeAncho = tempBordeAncho;
    BordeSuperior = tempBordeSuperior;
    BordeInferior = tempBordeInferior;
    BordeIzquierdo = tempBordeIzquierdo;
    BordeDerecho = tempBordeDerecho;
    MargenError = random(0,tempMargenError);
  }
 
  void mostrar() {
    noStroke();
    fill(Color);
    rectMode(CORNER);
    rect(bloque * Xpos, bloque * Ypos, bloque * Ancho, bloque * Alto);
    if(BordeAncho != 0){
      stroke(BordeColor);
      strokeWeight(BordeAncho);
      margenSup = (bloque * BordeSuperior) - MargenError;
      margenDer = (bloque * BordeDerecho) - MargenError;
      margenInf = (bloque * BordeInferior) - MargenError;
      margenIzq = (bloque * BordeIzquierdo) - MargenError;
      line(bloque * Xpos - margenIzq, bloque * Ypos, bloque * (Xpos + Ancho) + margenDer , bloque * Ypos); // Border Superior
      line(bloque * Xpos - margenIzq, bloque * (Ypos + Alto), bloque * (Xpos + Ancho) + margenDer , bloque * (Ypos + Alto)); // Border Inferior
      line(bloque * (Xpos + Ancho), bloque * Ypos - margenSup, bloque * (Xpos + Ancho),  bloque * (Ypos + Alto) + margenInf); // Border Derecho
      line(bloque * Xpos, bloque * Ypos - margenSup, bloque * Xpos,  bloque * (Ypos + Alto) + margenInf); // Border Izquierdo
    }
  }
 
}
 
// Transition
 
// Clases
class Transition{
 
  // Campos
  float Alpha = 0;
  float mascara = 0;
 
  // Metodos:
 
  // Slide
  void slideTo(float Speed, float Hue, float Saturation, float Bright){
    noStroke();
    fill(Hue, Saturation, Bright, 100);
    rect(0, height, width, mascara - height);
    mascara += ciclos * Speed;
    // Reinicia
    if (ciclos == ciclosTotales){
      mascara = 0;
    }
  }
 
  // Fade
  void fadeTo(float Speed, float Hue, float Saturation, float Bright){
    noStroke();
    rectMode(CORNER);
    fill(Hue, Saturation, Bright, Alpha);
    rect(0, 0, width, height);
    Alpha += (Alpha + 1) * Speed;
    // Reinicia
    if (Alpha > 100){
      Alpha = 0;
      ciclos = 0;
      pintando = false;
    }
  }
 
}

Anterior / Siguiente proyecto