Marcianitos

Como este sitio trata de la doble página traigo esta aplicación: Issuu.

Mis amigos más fundamentalistas dirán que es pura nostalgia por la página, otros dirán que se trata de otra aplicación que declara la supremacía absoluta de Internet sobre los otros medios de comunicación; porque es capaz de contenerlos a todos.

En fin, si esta discusión no te interesa, sólo baja el código para hacer tus propios marcianitos.

Notas
  1. float)height - (2 * margen []
  2. float)width - (2 * margen []

Crono-anamorfosis

secuencia Nuestra comprensión del tiempo es discreta, es decir concebimos la suceción de “instantes” como el único modo de reconstruir el flujo del tiempo. Cada vez que grabamos un video, recolectamos una gran catidad de fotogramas que luego son reproducidos —normalmente— a la misma velocidad con la que fueron captados. Tenemos entonces un solido o volumen de fotogramas cuyo espesor corresponde al tiempo. Siempre que reproducimos el video, elegimos verlo en sucesivos cortes transversales perpendiculares al tiempo, tratando de volver a esos instantes fotográficos. Pero ¿podemos verlo de otro modo? ¿qué ocurriría si elegimos ver este sólido de tiempo haciendo un corte con una inclinación ligeramente distinta? secuencia inclinada con anamorfosis temporal Por ejemplo, imaginemos que el programa que captura video va almacenando un buffer de fotogramas que tiene un espesor igual al alto en pixeles del fotograma (aquí en el esquema: y = z). Es decir, si tengo un fotograma de 320 pixeles de ancho por 240 pixeles de alto, tengo un buffer de 240 fotogramas de espesor. Entonces el fotograma actual puede construirse a partir de la diagonal de este volumen: la primera línea es la actual, la segunda es de 1 fotograma atrás, la tercera de 2 fotogramas atras, y así hasta completar el alto de la imágen. TimeTwist de Herbert Spencer en Vimeo.

Código

El código presentado a continuación fue generado para captura en tiempo real en el entorno processing. Se debe tener en consideración que el programa requiere mucha memoria RAM para ejecutarse por lo que se hace necesario modificar las preferencias de processing (ojalá más de 1GB). Esto dependerá del tamaño de captura. Normalmente las cámaras para videoconferencias integradas admiten un máximo de 640 x 480. Este código no está optimizado, ojo. Si hacen algo con el código pongan el link para ver los experimentos en los comentarios de más abajo ¡Suerte! Bajar: timetwist.pde

Referencias

buscando un nombre

duwa

En muy poco tiempo más seré nuevamente padre, esta vez de una niña. El problema es que no se nos ocurre qué nombre ponerle. Hemos buscado miles, pero mi decepción fue mayor al ver que todos mis esfuerzos creativos no eran más que el lugar común que todos transitan. Entonces se me ocurrió que podría tener un nombre inventado, nuevo. Para eso hice un programa llamado nameGenerator que genera nombres a partir de distintos patrones de consonates y vocales:

Instrucciones

Este programa se maneja con el teclado (No tuve el tiempo ni la dedicación para esmerarme en una interfaz más amistosa, pero el teclado funciona bien). Para generar un nombre nuevo, hay que apretar cualquier número, 0 inclusive. Cada uno de los números representa un patrón de consonantes y vocales distinto. Arriba, al medio dice que patrón se está utilizando. Por ejemplo: “C V V C V” (‘C’ para consonante y ‘V’ para vocal) podría arrojar “paula”. Dentro de la carpeta del programa viene un archivo de texto llamado “nombres.txt” que está vacío (!) Este archivo es necesario para grabar los nombres buenos que puedan ir saliendo. Para grabar un nombre sólo hay que apretar la barra de ESPACIO. Además, dentro de los chiches inútiles, está el catastro de todas las letras representado por unos pequeños gráficos de barra de 1 pixel para ir contando cuantas veces cada letra es utilizada. Como ya dije, no tiene mayor utilidad; sólo lo hice para ver si la función random() que elige las letras es realmente aleatoria. La letra ‘ñ’ fue eliminada a propósito. Bueno… como no le tengo mucha fe a este programa (que es enfermo de nerd) Acepto feliz cualquier tipo de sugerencia para el nombre de la beba. Gracias y que disfruten de este útil programa. Se me olvidaba: es muy importante salir del programa presionando la letra Q, de otro modo, el archivo de texto quedará mal cerrado… detalles… ; )

Modulador de Números Primos

Los números primos son los diamantes de los números naturales. Todos los demás números pueden construirse desde factorizaciones únicas de números primos; ellos son las piezas clave, los otros números son sólo relleno. No existe modo de anticipar la distribución de estos números como secuencia regular y han existido muchos intentos para predecir su aparición. Nadie ha podido estabalecer un patrón claro para describirlos. En 1963, Stanislaw Ulam, un matemático polaco, decidió disponerlos en una espiral cuadrada como la que muestro en la imagen. Este arreglo consiste en comenzar desde el número 1 al centro del espiral y avanzar girando hacia afuera manteniendo la unidad de distancia entre números constante; los puntos rojos representan números primos. Este arreglo reveló un misterioso patrón de diagonales que se mantení­a sin importar la cantidad de números representados o si se cambiaba el primer número del espiral por otro distinto de 1. Este hallazgo le significó a Ulam aparecer con su diagrama en la portada de la revista Scientific American. Con la idea de poder encontrar patrones ocultos en los números primos hice un pequeño programa para modular distintos tipos de espirales, partiendo del famoso espiral de Ulam. Se trata de una herramienta de visualización para descubrir algo que nadie haya visto. Tal vez puedas descubrir un patrón oculto y tener un espiral con tu nombre.

Primes Modulator

Este programa fue realizado en processing y permite generar documentos PDF de los espirales (Actualización) Debido a los cambios del lenguaje de Processing en los últimos 10 años, he dejado una versión estable y compatible con la versión actual en un repositorio de Github.

Civilscope

Civilscope Logo

La idea de este proyecto es mostrar de manera fácil y ní­tida las capas y fronteras cí­vicas en las cuales estamos inmersos. Civilscope es un servicio web que, a partir de una dirección determinada, mapea todas las divisiones, distritos y circunscripciones que la rigen. Este servicio funciona solamente para la gente de Chicago porque opera sobre la API de Civic Footprint, una iniciativa del Center for Neighborhood Technology de Chicago. Pienso que tener algo así­ en Chile serí­a buení­simo para poder transparentar en algo las oscuras y arcanas fronteras polí­ticas que nos gobiernan. En parte por eso me entusiasmé cuando Simon me propuso la idea; para poderlo mostrar como ejemplo y poder desarrollar algo así­ para nosotros. De hecho, nuestra estructura es bastante más sencilla, con menos capas y jerarquí­as traslapadas. Particularmente en Chicago existen distritos verdaderamente extraí±os en cuanto figura. Esto se debe a una práctica de distritage llamada “gerrymandering”. En el sistema norteamericano los votantes son divididos por distritos. Lo que cuenta al final no es la cantidad total de votos sino la cantidad de distritos en los que tal o cual candidato ha ganado. Esto lleva a practicar estrategias de “pack & crack”, es decir, agrupar a la oposición y concentrarla lo más posible en un distrito para que arrase, pero para que pierda por poco en todas las demás. Esta práctica de redibujar los distritos ocurre cada vez que hay alternancia en el poder, para perjudicar a la opsición. Cada dí­a esta operación se vuelve más sofisticada ya que se ocupan programas computacionales para redibujar los distritos basados en los registros de votantes. Es por eso que herramientas como esta permiten transparentar en algo estas prácticas. http://www.civilscope.org/

Filippo 3D ver 0.1

f3d rotations Filippo 3D is my final project for Golan‘s class, the Interactive Image. This project is inspired by the idea of drawing in a 3D canvas. After seeing Amit Pitaru‘s work, the famous sonic sculptor or the gesture machines from Zack Lieberman, I decided to create a small application that allowed to transfer 2D hand strokes into a 3D space.

Download

I’d be really happy to receive feedback for further improvements and/or the PDFs (360 Sample) you create with it. I hope that the next version will have load/save capabilities since the only possible output right now is into a PDF (or animated series of PDFs) or DXF (an old 3D) format. Enjoy! sillas
/* English ends here :) */
Filippo3d Interface La diferencia con los ejemplos anteriores es que en ellos el dibujo rota en el espacio y el plano de la pantalla –en el cual uno dibuja– se intersecta con el espacio tridimensional en un plano fijo. Lo que querí­a hacer yo era poder mover ese plano, como si la hoja de papel sirviera para fijar las lí­neas no en el papel, sino en el espacio construí­do por ese plano. Dicho de otro modo, un cuaderno que permitiera dibujar, luego mover el cuaderno y dejar las lí­neas flotando en el aire, en su posición original: la construcción de un plano-andamio para fijar lí­neas en el espacio. Finalmente el resultado no es literalmente esta imagen del cuaderno desplazable por el espacio, principalmente porque uno siempre dibuja frontalmente y no tiene sentido mover un plano que será mediado ineludiblemente por el plano de la pantalla. Lo que el programa hace es mover y rotar el modelo para hacerlo coincidir con el plano de dibujo (plano-pantalla); en el fondo es lo mismo pero pero tiene más sentido al momento de dibujar. El modelo matemático que sustenta la traducción de un espacio bidimensional a un espacio tridimensional implica multiplicación de matrices al modo inverso de lo que el computador hace cuando presenta modelos tridimensionales en la pantalla: a cada vértice con ubicación (x,y,z) le asigna su correspondiente (x,y) en la pantalla. Lo que este programa hace es partir de un (x,y) –con un z igual a 0– que se traduce a un espacio tridimensional con rotaciones en los ejes x,y,z.
Traslación en x,y,z:

| 1   0   0   x |
| 0   1   0   y |
| 0   0   1   z |
| 0   0   0   1 | 

Rotación en X:

| 1     0     0     0 |
| 0    cosα -sinα   0 |
| 0    sinα  cosα   0 |
| 0     0     0     1 | 

Rotación en Y:

| cosα  0    sinα   0 |
| 0     1     0     0 |
|-sinα  0    cosα   0 |
| 0     0     0     1 | 

Rotación en Z:

| cosα -sinα  0     0 |
| sinα cosα   0     0 |
| 0     0     1     0 |
| 0     0     0     1 | 

Multiplicación de Matrices:	

| 1 0 0 |     | x |     | 1 * x + 0 * y + 0 * z |
| 0 1 0 |  *  | y |  =  | 0 * x + 1 * y + 0 * z |
| 0 0 1 |     | z |     | 0 * x + 0 * y + 1 * z | 	

| A1,1  A1,2  ... |     | B1,1  B1,2  ... |     | A1,1 [B1,1 B1,2 ...] + A1,2 [B2,1 B2,2 ...] + ... |
| A2,1  A2,2  ... |  *  | B2,1  B2,2  ... |  =  | A2,1 [B1,1 B1,2 ...] + A2,2 [B2,1 B2,2 ...] + ... |
| ...   ...   ... |     | ...   ...   ... |     |         ...                   ...             ... |
Si bien esta parte es bastante árida, una vez funcionando uno puede olvidarse de eso y enfocarse en cosas más importantes, como para qué puede servir algo semejante 🙂 En fin, Filippo 3D permite hacer varias cosas, entre ellas generar PDFs de las distintas vistas (tecla ‘p’minúscula) y exportar modelos DXF para programas de edición en 3D (tecla ‘d’ minúscula). También permite generar secuencias de PDFs del modelo rotando en el eje Y, (tecla ‘P’ mayúscula). Todo esto queda guardado en la misma carpeta del programa, ojo. Creo que este programita podrí­a ser útil en las salidas a croquear con una tablet PC. Creo que mis amigos diseñadores y arquitectos podrí­an sacarle buen partido al asunto. Estén atentos a las próximas versiones del programa que incluirán la capacidad de guardar y cargar dibujos.

Requierimientos

  • Targeta gráfica con soporte OPENGL
  • Un computador rápido, ojalá con procesador INTEL
  • Resolución de 1024 x 768 como mí­nimo
  • mucho tiempo para dibujar

Funciones

  • traslación, rotación y escala en 3D
  • control de color
  • control de grosor de trazo
  • exporta PDF de la vista actual
  • exporta una serie de 36 PDFs rotando en Y
  • exporta modelo DXF para edición 3D
Si lo usan y lo encuentra útil, porfavor dejen comenatrios de cómo podrí­a mejorarse, qué cosas quedan poco claras y qué funciones serí­a bueno incorporar para la próxima, además de los PDFs (ejemplo) que hagan con la maquinita, claro.

2x2x2

Los arreglos 2×2 son utilizados para visualizar relaciones entre dos conceptos. Por ejemplo, el eje X puede representar ‘lo privado’ (-x) y ‘lo público’ (+x) y el eje Y puede referirse a la relación ‘adquirir/consumir’ (-y) ‘crear/generar'(+y). Lo potente de esta representación es que admite todos los puntos intermedios entre los conceptos asignados a cada eje, las llamadas “áreas grises”. A partir de esta “cancha” podemos construir un modelo; por ejemplo podrí­amos mapear distintios servicios web (lectores RSS, herramientas de blogging, wikis, calendarios, AIM, email, etc). Por ejemplo, un lector RSS estarí­a en el cuadrante inferior izquierdo porque apunta más a la lectura (adquirir/consumir) personal(privada); ahora, si mapeamos distintos servicios de lectura de RSS y comparamos los que permiten compartir tags, o generar “rolls”, etc; podrí­amos ubicarlo en una zona más próxima a lo público, como el caso de un blog. Una wiki podrí­a estar en el punto de pivote porque su estructura facilita el consumo privado como la participación en la generación de contenidos. Imagino que para poder construir una buen modelo 2×2 hay que validar las impresiones personales en una discusión grupal, calibrando todas estas ubicaciones para dejarlas lo menos arbitrarias posibles. Aquí­ hay un ejemplo que encontré (no es muy bueno pero sirve para que entiendan la idea) y aquí­ hay otro que hice yo, para identificar un área de oportunidad para un proyecto especí­fico. Normalmente la información representada en estos modelos es de naturaleza cualitativa y está sujeta a la percepción del diseñador en el sentido de la exactitud de su ubicación. En el fondo corresponde a un profundo proceso de sí­ntesis y el arreglo bidimensional (2×2) resultante permite identificar oportunidades para diseñar en áreas no exploradas por los productos existentes (esto se aplica al ejemplo particular que estoy dando, pero pueden ser utilizados para otra cosa, por cierto). Lo que hice aquí­ es un experimento en processing que construye un 2x2x2. Se trata de un intento de construir una relación entre 3 dimensiones semánticas y permitir la construcción de un modelo que sea consistente con las tres simultáneamente. El hecho de que la secuencia entre las distintas vistas (x,y), (y,z), (x,z), etc. esté animada, constituye la clave cognitiva para que el lector pueda hacer el puente entre cada una de ellas. Este ejemplo no representa ninguna relación en particular, tan sólo se trata de puntos dispuestos al azar (en una función de ruido espefí­cicamente); la idea es comprobar si una representación de esta naturaleza ofrece la coherencia y legibilidad necesaria como para construir un argumento a partir de ella. A disposición de ustedes les dejo el código para que jueguen. Aquí también hay un ejemplo aplicado.
// navigate with keys 1..6
// press SPACE to regenerate the from

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

// camera variables
float distancia = 600.0;
int delayer = 10;
float currentX = 0.0;
float currentY = 0.0;
float currentZ = distancia;
float nextX;
float nextY;
float nextZ;
boolean flying = false;

//drawing variables
int axisLenght = 300;
int cube = 350;
int numDots = 225;
float[] dotX = new float[numDots];
float[] dotY = new float[numDots];
float[] dotZ = new float[numDots];
float[] dotRadius = new float[numDots];
boolean dots = false;

void draw(){
  background(255);
  camera(currentX, currentY, currentZ, 0, 0, 0, 0, 1, 0); //setup camera, target and 'up'

  if(flying == true) {
    currentX += (nextX - currentX)/delayer;
    currentY += (nextY - currentY)/delayer;
    currentZ += (nextZ - currentZ)/delayer;
    if( dist(currentX,currentY,currentZ,nextX,nextY,nextZ) < 1) {
      //currentX = nextX;
      //currentY = nextY;
      //currentZ = nextZ;
      flying = false;
    }
  }
  // 3 AXIS IN RGB
  stroke(255,0,0,100); //color + alpha
  line(-axisLenght, 0, 0, axisLenght, 0, 0); //RED X
  stroke(0,255,0,100);
  line(0, -axisLenght, 0, 0, axisLenght, 0); //GREEN Y
  stroke(0,0,255,100);
  line(0, 0, -axisLenght, 0, 0, axisLenght); //BLUE Z

  if(dots == false){// generate the dots only once
    generateDots();
    dots = true;
  }
  drawDots();
}

// the random values for the spheres
void generateDots() {

  int rand = (int)random(1000);

  for(int i = 0; i < numDots; i ++){

    float xgen = i;
    float ygen = i+rand;
    float zgen = i+2*rand;

    // the noise function (by Ken Perlin) provides a continous randomness
    dotX[i] = (noise(xgen/80.0)*600)-300;
    dotY[i] = (noise(ygen/80.0)*600)-300;
    dotZ[i] = (noise(zgen/80.0)*600)-300;
    dotRadius[i] = noise(xgen/10.0)*60;
  }
}

// draw the translucent spheres
void drawDots(){
  sphereDetail(8);
fill(#CC0000, 40);// color + alpha of the spheres
  noStroke();
  for(int i=0; i