Voxelizer

Lyapunov 3D

2011-05-26T03:36:00.007+02:00

Today I'm going to comment a small program that it's not fully related to raytrace, but is related to 3D.

It has been some time since I have tried to represent the Markus-Lyapunov fractal. The 3D version extends the exponent computation one dimension. I have used CUDA and OpenGL to represent that.

Thanks to CUDA it's possible do computation using the GPU, so, if you have a good video card, the computation will be quite fast.

The variation of the algorithm is simple. The sequences contain one more letter, in this case C, that represents a point in the Z coordinate (or 'c'). Everything else is similar to the previous algorithm.

In order to do the renders I use two VBOs: One for storing positions and another one to store colors. The positions will be arranged in a volume of 256x256x256 elements. To compute the colors of each voxel I use two kernels. One computes the positions of each point and stores them in one VBO. The other use that positions to compute the color, that is the lyapunov exponent in that point. The points with an exponent greater than zero (or greater than a cut-off value) are moved to a region in order to not disturb. The points with a negative exponent (or lower than the cutoff value) will be drawn with a color proportional to the absolute value of the exponent.

Space region (0,4)-(0,4)-(0,4)

Space region (1,4)-(1,4)-(1,4)

Adjusting the cut-off value in order to remove some information about stability.

Readjusting the cut-off value to be nearer to zero.

The code for computing the Lyapunov 3D exponent for the sequence ABC is this:

__device__ float evalLyap(float3 p)
{
float sum=0;
float Xn=0.5f;


for (int i = 0; i < 3; i++) {
 float rn = i==2 ? p.x : i==1? p.y : p.z;
 Xn=rn*Xn*(1-Xn);
}

int iterations=lyapunovParams.iterations;
for (int n=0;n<iterations;n++){
 float prod_deriv=1;
 for (int i = 0; i < 3; i++) {
  float rn = i==2 ? p.x : i==1? p.y : p.z;
  Xn=rn*Xn*(1-Xn);
  prod_deriv *= rn*(1-2*Xn);
 }
 float q=log(fabs(prod_deriv));
 sum+=q;
}

return sum/(iterations*3);
}

This is the Kernel code for computing the positions of the evaluating points:

__global__ void kernelGeneration(float3 *ptr, int dim)
{
int xx=threadIdx.x + blockIdx.x*blockDim.x;
int yy=threadIdx.y + blockIdx.y*blockDim.y;
int offset=xx + yy*blockDim.x*gridDim.x;

int res=dim*dim;
int z=truncf(offset/res);
res=offset-z*res;
int y=truncf(res/dim);
int x=res-y*dim;

float fx = x/(float)dim;
float fy = y/(float)dim;
float fz = z/(float)dim;

ptr[offset].x=fx;
ptr[offset].y=fy;
ptr[offset].z=fz;
}

And finaly this is the Kernel code for computing the colors of those points:

__global__ void kernelComputation(float3 *ptrPos, float4 *ptrCol, int dim)
{
int xx=threadIdx.x + blockIdx.x*blockDim.x;
int yy=threadIdx.y + blockIdx.y*blockDim.y;
int offset=xx + yy*blockDim.x*gridDim.x;

float3 pos=ptrPos[offset];

pos.x*=lyapunovParams.maxX-lyapunovParams.minX;
pos.y*=lyapunovParams.maxY-lyapunovParams.minY;
pos.z*=lyapunovParams.maxZ-lyapunovParams.minZ;
pos.x+=lyapunovParams.minX;
pos.y+=lyapunovParams.minY;
pos.z+=lyapunovParams.minZ;

float lambda=evalLyap(pos);
float alpha=1;

if (lambda<-lyapunovParams.cut_off) {
 lambda+=lyapunovParams.cut_off;
 float l=-lambda*lyapunovParams.factor;
 if (l<0)l=0;
 if (l>1)l=1;
 ptrCol[offset].x=l;
 ptrCol[offset].y=l;
 ptrCol[offset].z=l;
 ptrCol[offset].w=l;
} else {
 ptrCol[offset].x=0;
 ptrCol[offset].y=0;
 ptrCol[offset].z=0;
 ptrCol[offset].w=0;
 ptrPos[offset].x=0;
 ptrPos[offset].y=0;
 ptrPos[offset].z=0;
}
}

Hoy voy a comentar un pequeño programa que no está totalmente relacionado con el tema del raytrace pero sí con el 3D.

Desde hace tiempo he intentado representar una versión tridimensional del fractal de Markus-Lyapunov. La versión 3D extiende el cómputo del exponente una dimensión más. Para realizarlo he utilizado CUDA y OpenGL.

Gracias a CUDA se puede realizar computación utilizando la GPU, lo cual, si se tiene una buena tarjeta de vídeo, puede hacer que la velocidad de cálculo sea bastante rápida.

La variación del algoritmo es sencilla. La secuencias contienen una letra más, en este caso C, que representa el punto en la coordenada Z (o 'c'). Todo lo demás es similar al algoritmo anterior.

Para realizar los renders utilizo dos VBOs: uno para almacenar posiciones y otro almacenar para colores. Las posiciones están repartidas en un volumen de 256x256x256 elementos. Para computar los colores de cada voxel utilizo dos kernels. Uno realiza el computo de las posiciones y las almacena en un VBO. El otro utiliza esas posiciones para realizar el computo de color, que es el exponente de lyapunov en ese punto. Para los puntos en los que el exponente es mayor que cero (o si se desea mayor que un valor de corte dado) el punto se lleva al origen para que no moleste. Para los puntos en que el exponente es menor que cero (o que el valor de cutoff) se pinta con un color proporcional al módulo de ese exponente.

Región espacial (0,4)-(0,4)-(0,4)

Región espacial (1,4)-(1,4)-(1,4)

Ajuste del valor de corte para quitar algo de información de estabilidad.

Reajuste del valor de corte para que esté más cercano a cero.

El código para computar el exponente de Lyapunov en 3D es este:

__device__ float evalLyap(float3 p)
{
float sum=0;
float Xn=0.5f;


for (int i = 0; i < 3; i++) {
 float rn = i==2 ? p.x : i==1? p.y : p.z;
 Xn=rn*Xn*(1-Xn);
}

int iterations=lyapunovParams.iterations;
for (int n=0;n<iterations;n++){
 float prod_deriv=1;
 for (int i = 0; i < 3; i++) {
  float rn = i==2 ? p.x : i==1? p.y : p.z;
  Xn=rn*Xn*(1-Xn);
  prod_deriv *= rn*(1-2*Xn);
 }
 float q=log(fabs(prod_deriv));
 sum+=q;
}

return sum/(iterations*3);
}

Este es el código de Kernel para computar las posiciones de los puntos de evaluación:

__global__ void kernelGeneration(float3 *ptr, int dim)
{
int xx=threadIdx.x + blockIdx.x*blockDim.x;
int yy=threadIdx.y + blockIdx.y*blockDim.y;
int offset=xx + yy*blockDim.x*gridDim.x;

int res=dim*dim;
int z=truncf(offset/res);
res=offset-z*res;
int y=truncf(res/dim);
int x=res-y*dim;

float fx = x/(float)dim;
float fy = y/(float)dim;
float fz = z/(float)dim;

ptr[offset].x=fx;
ptr[offset].y=fy;
ptr[offset].z=fz;
}

Y finalmente este es el código de kernel para computar los colores de dichos puntos:

__global__ void kernelComputation(float3 *ptrPos, float4 *ptrCol, int dim)
{
int xx=threadIdx.x + blockIdx.x*blockDim.x;
int yy=threadIdx.y + blockIdx.y*blockDim.y;
int offset=xx + yy*blockDim.x*gridDim.x;

float3 pos=ptrPos[offset];

pos.x*=lyapunovParams.maxX-lyapunovParams.minX;
pos.y*=lyapunovParams.maxY-lyapunovParams.minY;
pos.z*=lyapunovParams.maxZ-lyapunovParams.minZ;
pos.x+=lyapunovParams.minX;
pos.y+=lyapunovParams.minY;
pos.z+=lyapunovParams.minZ;

float lambda=evalLyap(pos);
float alpha=1;

if (lambda<-lyapunovParams.cut_off) {
 lambda+=lyapunovParams.cut_off;
 float l=-lambda*lyapunovParams.factor;
 if (l<0)l=0;
 if (l>1)l=1;
 ptrCol[offset].x=l;
 ptrCol[offset].y=l;
 ptrCol[offset].z=l;
 ptrCol[offset].w=l;
} else {
 ptrCol[offset].x=0;
 ptrCol[offset].y=0;
 ptrCol[offset].z=0;
 ptrCol[offset].w=0;
 ptrPos[offset].x=0;
 ptrPos[offset].y=0;
 ptrPos[offset].z=0;
}
}

Infinite Pipes

2010-08-22T17:39:00.007+02:00

English Spanish

Today I'm going to show a set of renders that extends the model of infinite labyrinths.

To represent them it has been slightly modified the algorithm that represents the type of shape that a ray will encounter in a space region.

The operation of this algoritm is very similar to the previously described to generate infinite labyrinths. It's presented now: We began with an object composed of two infinite planes separated by a arbitrary distance, let it be, for example a unit length. When a ray which its origin is outside the space contained between the two planes intersects with any of these two planes, an intersection position is computed. This position is a real vector. It's possible to take the X and Y coordinates (assuming that both planes cover a constant Z value) and covert it into integer coordinates (from now, j and i respectively). If the sum of this integer numbers is an even value one algorithm will be applied, if it's an odd value another algorithm will be applied. This is made in order to avoid adyacent regions share the same algorithm.
The algorithm of the even regions is simple, a LCG type random number generator will use the j and i values in order to generate a boolean value. This boolean value will determinate if a straigt tube is place along X or Y direction. So if we randomly fill even regions with straight tubes that moves along random directions X or Y we got a constraint in order to choose a shape to fill the odd regions. So if the adjacent regions (sharing an edge) of an odd region got straight tubes in the Y direction, the shape of that odd region will be a Y direction tube. If the up and down region got a Y direction tube, and the left got another Y direction and the right a X direction tube, the shape will be a T.

In order to achieve the effect of rusty it has been used a Perlin noise as a mask and then another configuration of Perlin noise for bumpmapping and color. To get the effect of water/ice it have been used a cellular fractal noise generator.

Here we can see the same image without bumpmapping and color:

Another view using a cylindrical camera:

The same with texture and bumpmapping:

Finaly here, we can see another view from a high Z value. The shape reminds quite well a maze:

Hoy voy a presentar una serie de renders que extienden el modelo de laberintos infinitos.

Para representarlo se ha modificado ligeramente el algoritmo que determinaba el tipo de forma que se va a encontrar un rayo en una región del espacio.

El funcionamiento de este algoritmo es muy similar al anteriormente descrito para laberintos infinitos. Se presenta a continuación. Se parte de un objeto compuesto por dos planos infinitos separados una distancia arbitraria, pongamos por ejemplo una unidad. Cuando un rayo cuyo origen está fuera del espacio comprendido entre los planos intersecta con alguno de los dos planos se determina la posición de impacto. Esta posición es un vector real. Se pueden tomar las coordenadas x e y (asumiendo que ambos planos cubren un valor Z constante) y convertirlas a coordenadas enteras (a partir de ahora j e i respectivamente). Si la suma de estos dos numeros enteros es un número par se aplicará un algoritmo y si es impar se aplicará otro. Esto se realiza para hacer que regiones cuadradas de espacio adyacentes no compartan el mismo algoritmo. De esta manera el algoritmo aplicado a las regiones de coordenadas impares dependerá de los valores computados para regiones pares adyacentes.
El algoritmo de las regiones pares es sencillo, un generador de números aleatorios de tipo LCG utilizará los valroes j e i para producir un valor booleano. Este valor booleano determina si un tramo recto recorre la dirección X o la Y. Por lo tanto si rellenamos aleatoriamente el espacio de regiones pares de tramos rectos que recorren direcciones aleatorias tenemos una condición restrictiva para elegir las formas que ocuparán las regiones impares. Así por ejemplo si nos centramos en una región impar y las regiones pares adyacentes (por arista) contienen tramos rectos en la dirección Y, la forma de la región impar será un tramo en la dirección Y. Si arriba y abajo tiene un tramo en Y, a la izquierda en Y y a la derecha en X, la forma será una T.

Para conseguir el efecto oxidado se ha utilizado ruido de perlin como máscara y posteriormente otra configuración de ruidl de Perlin para bumpmapping y color. Para conseguir el efecto del agua/hielo se ha utilizado un generador de ruido fractal celular.

Aquí podemos ver la misma imagen sin el bumpmapping ni el color:

Otra vista utilizando una cámara cilíndrica:

La misma con textura y bumpmapping:

Finalmente aquí, podemos ver otra vista desde un valor de Z alto. La forma recuerda bastante bien a un laberinto:

House Of Stairs

2009-11-08T18:29:00.014+01:00

English Spanish

Today I'm going to show a set of renders that although they are not totally finished I would like to show.

The target is the representation in 3D of the picture "House Of Stairs" of M.C.Escher. I focused the representation of walls and stairs. The strange animals and the doors are missing.

The results are these, in black and white and in color:

In the color version I have simply used blackbody illuminants with temperatures of 3000, 4000, 5000 and 7000 Kelvin.

In order to make the renders we have to do this. It's necessary to model the scenery in such a way so the dimensions fit using whole units (fitting into a grid). So we make sure that all walls, walkways and stairs have similar widths. With any CAD program it's possible to model the scenery looking the original drawing. The objects at this point have box geometry.

Because the rendering of boxes is too dull we have to add some effects. One of those has to emulate the round shape of a stone. In order to achieve that we can use textures or 3D models. In this case I preferred using 3D models to achieve more quality. Accomplishing this is simple. We cubicate the scene with the same resolution of the design grid. Now we have a set of voxels. Each voxel is replaced by a rounded cube mesh shape. The only problem is the amount of data and so the high processing time.

Later we apply a material to the surface. For that is used a composite material. The material is composed by one control map and two data maps. The control material is used to decide the amount of blending between the data materials. It's similar to an alpha blending. For the control map I have used a binary threshold discretized Perlin noise function. In the high part I have assigned one kind of bumpmap and in the lowest part another kind. So, two bumpmaps of controllable independent characteristics are obtained. Now we simply apply a greater scale factor and noise to one to look like holes in stone, while applying a smoother noise to the other. With only one bumpmap would have achieved a smoothed and polished stone effect with some holes. We don't want it.

Finally to render it's used a cylindrical camera to emulate the curved effect of "The House of Stairs". With a little wise we can place the camera more or less the same position where Escher sat it.

Hoy voy a mostrar una serie de renders que aunque no están totalmente acabados me gustaría enseñar.
El objetivo es la representación en 3D del dibujo "Casa de Escaleras" de M.C.Escher. Me he centrado en la representación de los muros y las escaleras. Faltan los animales extraños y las puertas.

Los resultados son los siguientes, en blanco y negro y en color:

Para la versión en color simplemente he utilizado iluminantes de cuerpo negro a temperaturas de 3000, 4000, 5000 y 7000 Kelvin.

Para realizar los renders se parte de lo siguiente. Es necesario modelar un escenario de tal forma que las medidas se ajusten a unidades enteras (ajustado a un grid). Así nos aseguramos que todos los muros, pasarelas y escaleras tienen anchuras similares.
Con cualquier programa de CAD se puede modelar el escenario fijándose bien en el dibujo original. Los objetos en este punto tienen una geometría de cajas.

Cómo la renderización de cajas es muy sosa se han de añadir algunos efectos. Uno tiene que poder emular la forma redondeada de la piedra. Para ello se pueden utilizar texturas o modelos 3D. En este caso he preferido utilizar modelos 3D para obtener una mejor calidad. La realización de esto es sencilla. Se cubica la escena a la misma resolución que la del grid de diseño. Ahora tenemos un conjunto de vóxeles. Cada vóxel se sustituye por una malla en forma de cubo con bordes redondeados. El único problema de esto es la cantidad de datos y por lo tanto el tiempo elevado de proceso.

Posteriormente se aplica un material a la superficie. Para ello se utiliza un material compuesto. El material se compone de un mapa de control y dos de datos. El mapa de control se utiliza para determinar la cantidad de mezcla de los materiales de datos. Similar a una mezcla alfa. Para el mapa de control he utilizado ruido de Perlin discretizado por un umbral binario. A la parte superior le aplico un tipo de bumpmap y a la parte inferior otro. Por lo que se obtienen dos bumpmaps de características controlables independientemente. Ahora simplemente se aplica un mayor factor de escala y ruido a uno para que parezcan agujeros en piedra, mientras que al otro un ruido mucho más suave. Con un solo mapa de bumpmap se habría conseguido un efecto de pierda lisa y pulida con algunos agujeros, cosa que no se quiere.

Finalmente para la renderización se utiliza una cámara cilíndrica para emular el efecto de "La Casa de las Escaleras". Con un poco de tino se puede situar la cámara más o menos en la misma posición de dónde la situó Escher.

Spatial Labyrinths

2009-09-14T18:56:00.015+02:00

English Spanish

Today I'm going to show a set of renders that I did some time ago. The general idea is to make a spatial maze.

That is, one that allows movements upwards and downwards as well as forward, backward, right and left. The movements that a player can do are in any spatial axis. In this case, Theseus has to know how to climb well.

One simple is this one:

In this one we see a tridimensional labyrinth bounded by the surface of a cube.

The procedure to accomplish this renders is not complex.

We start from a tridimensional shape. Then it's discretized in voxels marking as active the ones that are partially or totally included in the volume defined by the surface of the figure.
Now we are going to discard the non active voxels and we work with the ones that intersect or are included inside the volume.
We start from a random voxel and we move in a random direction, marking as visited the currant voxel.
As we move through the voxels we can find a visited voxel in the chosen direction. In this case we chose another direction.
In the case that there are not any available directions we move backwards and we chose another direction.
The algorithm ends when all the nodes (voxels) have been visited.

This algorithm allows a unique path from one point of the labyrinth to another. Obviously if we set two poins, one as starting and another one as ending, there will be a unique path between both, and then any other bifurcation that moves away from the path will bring us to a dead end.

Other views of the cube:

It's possible to use other figures as a "mould" of the labyrinth.

Here we can see a sphere:

And with a spherical camera:

The Utah teapot:

and a some renderings of a lying woman:

Spherical Renders of Labyrinths

2009-08-02T18:11:00.014+02:00

English Spanish

Recently I was thinking about how one of the mazes that I programmed would it seen using a spherical lens. Spherical lens deform parts of the images that are away from center, so the things that are far away looks like further away indeed. So more things "fits" inside the image.
When the deformation is low the result is similar to a wide angle lens. When the deformation is high we get images more dificult to achieve in reality. When the deformation is very high the images are imposible to obtain in reality.
The code that generates a particular ray for a pixel can be coded like this:


Ray RayGenerator::GenerateRay(int pixel_x, int pixel_y)
{
Ray ray;
double u,v;

ConvertPixel_to_Unit(pixel_x,pixel_y,u,v);

ray.orig=From;
ray.dir=-Normalize3d(-i + u*tanFov*aspect*j + v*tanFov*k);

return ray;
}

This code generates rays that advance in the negative direction of the X axis

Slightly modifying the code we can obtain our new spherical camera:


Ray SphericalRayGenerator::GenerateRay(int pixel_x, int pixel_y)
{
Ray ray;
double u,v;

ConvertPixel_to_Unit(pixel_x,pixel_y,u,v);

u*=fishEyeFactor*aspect;
v*=fishEyeFactor;

Vector V;
double r=sqrt(u*u+v*v);

double a=atan2(v,u);
V.y=sin(a)*(1-cos(r));
V.z=-cos(a)*(1-cos(r));
V.x=sin(r);
V=Normalize3d(V);

Matrix matrix=Construct4d(i,j,k,VECTOR3D(0,0,0));
V=TransformVector3d(V,matrix);

ray.orig=From;
ray.dir=Normalize3d(V);

return ray;
}

This type of projection generates a pole (or singularity) in the positive direction of the X axis. This generates images wery similar to the ones that Escher made in Circle Limit. As we aproach to the horizon we go to infinity.
With the value 'fishEyeFactor' we replicate the plane several times over the sphere reaching infinity as concentrical circular shapes.

This image is a normal render of an infinite labyrinth:

As we increase the spherical factor we slightly deform the image:

If we increase too much the factor we reach infinity several times:

We can make a render looking "down" obtaining an image that remainds quite well to the ones of M.C.Escher:

Likewise it's possible to increase the spherical factor:

Hace poco estuve pensando cómo se vería uno de los laberintos infinitos que programé bajo una lente esférica. Las lentes esféricas deforman partes de la imagen que se alejan del centro de ésta, haciendo que lo que está más lejos aparezca más lejos todavía. Así "entran" más cosas en la imagen.
Cuando la deformación es baja el resultado es similar a lentes de gran angular. Cuando la deformación es alta tenemos imágenes que son más difíciles de obtener en la realidad. Si la deformación es muy alta, las imagénes son imposibles de obtener en la realidad.
El código que genera un rayo para un pixel determinado se puede codificar así:


Ray RayGenerator::GenerateRay(int pixel_x, int pixel_y)
{
Ray ray;
double u,v;

ConvertPixel_to_Unit(pixel_x,pixel_y,u,v);

ray.orig=From;
ray.dir=-Normalize3d(-i + u*tanFov*aspect*j + v*tanFov*k);

return ray;
}

Este código genera rayos que avanzan en la dirección negativa del eje X.

Modificando ligeramente el código anterior podemos obtener nuestra cámara esférica:


Ray SphericalRayGenerator::GenerateRay(int pixel_x, int pixel_y)
{
Ray ray;
double u,v;

ConvertPixel_to_Unit(pixel_x,pixel_y,u,v);

u*=fishEyeFactor*aspect;
v*=fishEyeFactor;

Vector V;
double r=sqrt(u*u+v*v);

double a=atan2(v,u);
V.y=sin(a)*(1-cos(r));
V.z=-cos(a)*(1-cos(r));
V.x=sin(r);
V=Normalize3d(V);

Matrix matrix=Construct4d(i,j,k,VECTOR3D(0,0,0));
V=TransformVector3d(V,matrix);

ray.orig=From;
ray.dir=Normalize3d(V);

return ray;
}

Este tipo de proyección genera un polo (o singularidad) en la dirección positiva de las X. Esto genera imágenes muy similares a las que Escher realizaba en Límite Circular (Circle Limit). A medida que nos acercamos al horizonte nos vamos hasta infinito.
Con el valor 'fishEyeFactor' "replicamos" el plano varias veces sobre la esfera encontrando el infinito en forma de círculos concéntricos.

Esta imagen es un render normal de un laberinto infinito:

A medida que aumentamos el factor esférico deformamos la imagen ligeramente:

Si aumentamos demasiado el factor alcanzamos el infinito varias veces:

Podemos realizar un render mirando hacia "abajo" obteniendo una imagen que recuerda bastante a las de M.C.Escher:

Se puede igualmente aumentar el factor esférico:

Top Mod 3D Images

2009-04-26T16:58:00.011+02:00

English Spanish

Today i'm going to upload a set of renders that I did recently with a fantastic topological modelling program. The program's name is TopMod3D. Although the figure may seem complicated, thanks to this program are simple to perform.

Using a white skydome.

Using a blue skydome.

Using a blue skydome and a lightsource.

The figure uses a phong material with a high phong exponent.

Set of two objects: A box defined with a phong material and a totaly lambertian figure.

The figure's material simulates a laquer phong coating.

Material with bumpmapping for the box.

Changing the floor's material so a shadow can be appearing (adding a diffuse component)

A high contrast image with a front lightsource.

A high contrast image with a rear lightsource.

Infinite Labyrinths

2009-02-05T18:10:00.017+01:00

English Spanish

In a previous article (Truchet Tilings) I showed a way to represent labyrinths in a sphere and at the end, in a plane. In this one I'm going to show a way to represent infinite labyrinths in a plane.

Usually these labyrinths are finite sets of triangles. One of the problems in this type of representations is that you can see boundings.

One way to solve this is replicating the figure. Sooner or later you'll be able to see a periodic shape, noticing an artificial behaviour.

So, if you want to show infinite labyrinths, you'll have to find a method that satisfy these conditions:

Covers all the visible domain.
Absence of periodicity in the image.

The way that I present here in order to do this task is the next one:

Split the plane (in an algorithmic manner) in square regions of unit size (a grid of infinite squares, each one with one unit of side length).
Asign to each square region a tridimensional figure (for example, a wall in a side).

When a ray step inside a region, it will intersect with the associated shape in that region. When, by reflexion or traversing, it changes the region, a new intersection will be computed with the new form associated to the new region.

Here I show a sample using always the same shape.

This method presents a set of decissions:

How many types of shape should I use.
How I assign to each region a concrete shape.

The first point is chosen by the user. For example, my set of shapes will be:

A wall of 0.1 units width and 1 unit length arranged in a north face of the region.
Another similar wall arranged in the west face.

For the second point we have to think a bit. To each coordinate (integer) of the space I have to assign a random number. The function will be f(i,j)->n. Being i and j integer numbers and n a real number from 0 to 1. This function has to return values highly distinct of 'n' using slight variations of i and j. This is either a hashing function or a pseudorandom generator. Esentially are the same.
The generator will be a LCM (Linear Congruent Method) generator. We run the risk of having the Marsaglia effect. It will appear, and the user might see a certain periodicity but will be very dificutl to distinguish.

Each shape has a certain probability for appearing (for example: 1/number_of_figures). It will choose the figure using the method of the Russian roulette depending on the generated random number. As the number is pseudorandom and depends on the input paramaters, it always return the same value for the same input parameters.

The results are these:

And with a different probability distribution:

As you can see, choosing this kind of figures, as the norwest corner is always occupied, the aspect seems to be a growing figures in the same direction.

It can be resolved by adding another figure that is a double wall south and east. So using this way the distribution of corners is uniform and doesn't seem to grow in any direction. Althoug this adds more holes and makes the maze looks more closed.

This is with a figure with a column in the middle of the region:

Making simplier walls appears problems of double corners and doesn't seems very well.

Finaly there is a more complex method than the previous one. Consists on chosing figures randomly only in pair coordinates (i,j) which sum i+j are even (from this point, even regions). That yields a checker pattern. In the even regions we assign one shape selected by the pseudorandom generator. In the other hand, in the odd regions the shape is assigned by a shape that matchs with the shapes that are sharing each face. That is, if the north face of the figure that I have in the south has a wall, my south face should have a wall. So, both walls match together.

Choosing correctly the shapes and with a little extra programming we can achieve these images:

Using non linear cameras:

Using some procedural textures and phong materials:

If we use the first proposed method the labyrinth looks like this:

That's wrong but nice to test global illumination.

Obviously changing slightly the hashing function (adding a sum operation, in example) we can make labyrinths totaly indistinguishable ones with each others. We have graphically represented the hashing function.

En un artículo anterior (Truchet Tesellations) mostré una forma de representar laberintos en una esfera y por el final, en un plano. En este voy a mostrar otra forma de representar laberintos infinitos en un plano.

Normalmente estos laberintos son conjuntos finitos de triangulos. Uno de los principales problemas en este tipo de representaciones es que se pueden ver límites.

Una manera de resolver esto es replicando la figura. Tarde o temprano se puede intuír una figura periódica, notándose un comportamiento artificial.

Por lo tanto si se desea representar laberintos infinitos habrá que buscar una manera que cumpla las siguientes condiciones:

Cubra todo el dominio visible.
Ausencia de periodicidad en la imagen.

La manera que presento para realizar este cometido es el siguiente:

Dividase el plano (de forma algorítmica) en regiones cuadradas de dimension unitaria (una rejilla de infinitos cuadros, en los que cada cuadro mide una unidad de lado).
Asígnese a cada region cuadrada una figura tridimensional (por ejemplo, un muro en una pared).

Cuando un rayo incida en una región, intersectará con la forma asociada a esa región. Cuando, por reflexión o atravesamiento, cambie de región se computará la intersección con la asignada a ésta.

Aquí muestro un ejemplo usando siempre la misma forma.

Este método presenta una serie de decisiones:

Cuántos tipos de figuras uso.
Cómo asigno cada región una figura determinada.

El primer punto lo elije el usuario. Por ejemplo, mi conjunto de figures será:

Un muro de 0.1 unidades de ancho por 1 unidad de largo puesto en la cara norte de la región.
Otro muro similar orientado en la cara oeste.

Para el segundo punto hay que pensar un poco. A cada coordenada (entera) del espacio le he de asignar un número aleatorio. La función sería f(i,j)->n. Siendo i y j números enteros y n un número real de 0 a 1. Esa función ha de devolver valores muy dispares de 'n' para valores cercanos de i y j. Esto es o una función de hashing o un generador de números pseudo-aleatorios. Esencialmente son lo mismo.
El generador será un LCM o congruente lineal. Corremos el riesgo de que se de el efecto Marsaglia. Se dará, y el usario quizás vea una cierta periodicidad, pero dificil de ver.

Cada figura tiene una probabilidad de aparición determinada (por ejemplo, 1/número_de_figuras). Se seleccionará la figura usando la técnica de la ruleta rusa según el número aletorio generado. Como el número es pseudoaleatorio y depende de los parámetros de entrada siempre devolverá el mismo valor para mismos valores de entrada.

Los resultados son los siguientes:

Y con una distribución de probabilidad diferente:

Como puede verse, al escoger este tipo de figuras, hace que la esquina noroeste siempre esté ocupada por lo tanto el aspecto es de figuras que parece que crecen en una misma dirección.

Se pueden resolver añadiendo otra figura más que es un muro doble este-sur. De esta manera la distribución de esquinas es uniforme y no se ve que "crezca" en ninguna dirección. Esto añade más huecos y hace que el laberinto esté mas cerrado.

Esta es con una figura con una columna en el medio de la región:

Haciendo muros simples aparecen problemas de esquinas dobles y no queda bien.

Finalmente hay un método más complicado que el anterior. Consiste en elegir figuras aleatoriamente sólo para coordenadas (i,j) cuya suma i+j sea par (a partir de ahora, regiones pares). Lo que produce un patrón ajedrezado. A las regiones pares se les asigna una figura según el generador de números aleatorios (o función de hashing). En cambio, a las regiones impares se les asigna una figura que case con las figuras con las que comparte una cara. Esto es, si la cara norte de la figura que tengo al sur tiene muro, mi cara sur ha de tener muro.

Eligiendo correctamente las figuras y con un poco de codificación extra se producen estas imágenes:

Usando cámaras no lineales:

Usando algunas texturas procedurales y materiales de phong:

Si usamos el primer método propuesto para el laberinot aparece así:

Esto es incorrecto pero queda bien para iluminación global

Obviamente cambiando ligeramente la función de hashing (añadiendo una suma, por ejemplo) se pueden construir laberintos totalmente indistinguibles unos de otros. Hemos representado gráficamente una función de hashing.

White Sky

2009-01-28T00:40:00.010+01:00

English Spanish

I put here some renders that I did some time ago and I have re-rendered recently. Simply they are simple geometric figures to test oclussions. The skydome is totaly white, as well as the reflectors and the luminarie. The result so it is gray. Originally these designs were backgrounds of a lost blog that I did long time ago. It can be work quite well as wallpapers.

Truchet Tilings

2009-01-18T19:49:00.002+01:00

English Spanish

Today I'm going to show a set of renders that are related to Truchet Tesellations. In 1704 Sebastien Truchet thought about a system of teselate a plane using oriented triangles. A modification of this one allow us to generate labyrinthic motifs using curved lines. In 1989 Pickover shown that it was an elegant method to see patterns in pseudorandom numbers secuences.

Seeing the Pickover's motifs I thought that it should be a way to tesselate a sphere without producing singularities at the poles.

So, here they are the ingredients:

Take a geodesic sphere discretized in triangles more or less regular with similar size.
Define 5 triangular tiles.
For each triangle replace it with one of the 5 tiles in a random fashion or with a certain probability distribution.

Here I show the results:

It can be shown only a certain kind of tiles:

Type 1

Type 2

Type 3

Type 4

Type 5

Only two types:

Uniform proability distributions:

Distributions of non uniform probability for each type:

Finaly all the types:

Images without the inner sphere:

and with a inner point of light:

With other materials:

Planar projections with non-linear cameras:

Finally, with all those projections depends on a triangular mesh it's possible to make denser motifs or even with a certain meshes. Like in this case, the Stanford Bunny:

Textos bilingües

2009-01-17T20:14:00.002+01:00

English Spanish

Este post no va dirigido a temas de informática gráfica. Presento una manera de poder mostrar 'posts' en dos idiomas. El sistema es muy sencillo y se puede utilizar en blogspot como voy a demostrar. No he perdido mucho tiempo buscando por internet mecanismos similares. Debido a la sencillez he preferido realizarlo por mi mismo.

Para llevar a cabo esto se usará Javascript. Expongo los pasos:

Modificación de la plantilla

Creación de los links de idioma en el post

Definición de los bloques de idioma en el post

Modificación de la plantilla
En las opciones de blogger de 'Diseño' se modifica la plantilla HTML. Añadiendo lo siguiente:


<script language='javascript' type='text/javascript'>
function showBlk_1 ()
{
    var nodeObj = document.getElementById('blk_1')
    nodeObj.style.display = 'inline';
    var nodeObj = document.getElementById('blk_2')
    nodeObj.style.display = 'none';
}
function showBlk_2 ()
{
    var nodeObj = document.getElementById('blk_2')
    nodeObj.style.display = 'inline';
    var nodeObj = document.getElementById('blk_1')
    nodeObj.style.display = 'none';
}
</script>

El código es sencillo. Si se invoca a showBlk_1 se cambia el estilo del bloque identificado como 'blk_1' a visible, y el identificado como 'blk_2' a invisible.

La otra función realiza la operación inversa.

Creación de los links de idioma en el post

Simplemente definimos etiquetas 'span' o 'a' con un href apuntando a '#' y esto es lo importante: Una función onclick.

Por ejemplo:


<a href='#'><span onclick="showBlk_1()">Spanish</span></a>
<a href='#'><span onclick="showBlk_2()">English</span></a>

Definición de los bloques de idioma en el post

Finalmente ahora se escriben los textos en los dos idiomas. El texto en el idioma asociado al bloque 1 (blk_1) estará dentro de un div identificado con blk_1.
Los textos en el otro idioma estarán metidos dentro del otro bloque.

Por ejemplo:


<div id="blk_1" style="display: inline;">Esto es un texto en idioma Español.</div>
<div id="blk_2" style="display: none;">This is an English text.</div>

Uno de los bloques ha de ser visible y los demás invisbles para que por defecto se muestre sólo un idioma.
Aquí por claridad se ha añadido un retorno de carro para separar los divs pero en el post han de estar los 'divs' pegados. Si no, el segundo idioma aparecerá con un retorno de línea extra.

Conclusión

Se ha presentado una manera muy sencilla de generar posts en dos idiomas. Este modelo es a su vez fácilmente escalable para esquemas de múltiples idiomas.

This post is not related to computer graphics. I present a way to show posts in two languages. The mechanism is very simple and can be used in blogspot as I'm going to show. I haven't wasted too much time in finding over internet similar mechanisms. Due to the simplicity of this method I had prefered doing it by myself.

In order to achieve this javascript will be used. I expose the steps:

Modifying the template

Creation of the language links in the post

Definition of the language blocks in the post

Modifying the template
The template can be modified in Design options of blogger. It's possible to add this:


<script language='javascript' type='text/javascript'>
function showBlk_1 ()
{
    var nodeObj = document.getElementById('blk_1')
    nodeObj.style.display = 'inline';
    var nodeObj = document.getElementById('blk_2')
    nodeObj.style.display = 'none';
}
function showBlk_2 ()
{
    var nodeObj = document.getElementById('blk_2')
    nodeObj.style.display = 'inline';
    var nodeObj = document.getElementById('blk_1')
    nodeObj.style.display = 'none';
}
</script>

The code is simple. If showBlk_1 is invoked, the style of the block identified by blk_1 is changed to visible, and the one identified with blk_2 is set to invisible.
The other function does the oposite operation.

Creation of the language links in the post
Simply we define the tags 'span' o 'a' with a href targeting '#' and this is the important thing: An onclick function:
For example:


<a href='#'><span onclick="showBlk_1()">Spanish</span></a>
<a href='#'><span onclick="showBlk_2()">English</span></a>

Definition of the language blocks in the post
Finaly now the texts in the two languages are written. The text in the language associated to the block 1 (blk_1) will be inside in a div block identified with blk_1.
The texts in the other language will be inside the other block.
For example:


<div id="blk_1" style="display: inline;">Esto es un texto en idioma Español.</div>
<div id="blk_2" style="display: none;">This is an English text.</div>

One of the blocks has to be visible and the other ones invisibles so by default only one language will be shown.

Here, for clarity it has been added a return carriage to separate the divs but in the post the 'divs' shouldn't be separated. If not, the second language will appear with an extra line.

Conclusion
It has been shown a very easy way to generate posts in two langages. This model it's also easily scalable to manage schemes with multiple languages.

Prueba bilingüe

2009-01-17T19:52:00.003+01:00

English Spanish

This is an English text.

Gravity Paths

2009-01-10T20:54:00.001+01:00

Dejo aquí unos renders que hice hace poco. Representan las trayectorias de partículas con masa dentro de un campo gravitatorio arbitrario. Para realizarlo he partido de un objeto tridimensional. He calculado su campo gravitatorio. Luego he dejado dentro del campo un conjunto de partículas. Avanzando la simulación las partículas se mueven dentro del campo. Se pueden registrar sus trayectorias a medida que se mueven. Una vez que se obtienen las trayectorias se pueden convertir a objetos sólidos tubulares. Con el objeto sólido se puede realizar un render de pathtracing y obtener estos resultados:

Lattice Object

2009-01-08T22:50:00.000+01:00

El otro día estuve mirando un libro de Escher que tengo desde hace tiempo. Hojeándolo llegué hasta uno de los dibujos que siempre me había sorprendido por su regularidad: "Cubic Space Division" . Este dibujo se puede representar a mano con un poco de paciencia, cosa que les sobra a las computadoras. Así, que decidí realizar un pequeño programa que representara escenarios parecidos a ese dibujo.

Cómo mostrar el espacio sin más es aburrido, decidí representar un enrejado acotado por la superficie de un objeto. Para ello utilicé una herramienta que codifiqué hace más o menos un año. La herramienta (una clase en C++) determina si un punto está dentro o fuera de un objeto cerrado. Esta herramienta se pensó para determinar el volumen de un objeto amén de utilizarse para obtener otras interesantes características como el tensor de inercia del sólido rígido que representaría. Para determinar el volumen, normalmente se eligen puntos aleatorios acotados dentro de una superfice que engloba el objeto y se haya una relación entre los que están dentro y los totales. Si esta relación se multiplica por el volumen acotado de la superficie englobante tenemos una aproximación del volumen. Estas técnicas de integración numérica son muy útiles cuando es muy complicado o imposible obtener una función analítica que represente la función de superficie que se desea integrar.

Para realizar este modelo simplemente hay seleccionar puntos equiespaciados en los tres ejes espaciales y almacenar los que están dentro del objeto a analizar. Analizando la vecindad de los nodos (ver si tiene vecinos en los tres ejes y sus dos direcciones) se pueden añadir empalmes que parejas de éstos. Es necesario elegir cautelosamente los tamaños de los nodos y de los empalmes para que el armazón no englobe todo el espacio.

Dejo por aquí algunos renders. Una vista interior:

Otras exteriores...

Y una exterior más de cerca:

Brócoli con suelo liso

2009-01-04T15:46:00.000+01:00

Dejo por aquí otros dos renders del brócoli de Romanesco. He quitado el fondo de ajedrez como comentó Mamen.

En este render el suelo es simplemente gris. El color azulado se debe a la radiancia que emite la cúpula celeste (si nos fijamos cuidadosamente veremos que en el mundo real pasa algo similar, las sombras diurnas son ligeramente azuladas).

En este otro render he cambiado la BRDF del suelo de difusa a una de phong (con un exponente de 1024). El efecto conseguido es un suelo reflectante que dispersa parcialmente los rayos de luz que llegan. Los reflejos más distantes se vuelven más difusos. Obviamente el color azulado es debido al color del cielo.

El brócoli de Romanesco

2008-12-28T16:55:00.000+01:00

Recursividad y autosimilaridad, dos características propias de los fractales. La autosimilaridad es propia de la naturaleza y la recursividad de las computadoras. Está por lo tanto la naturaleza, ¿computada?. No lo creo, es más probable que simplemente sea el resultado de una compresión de datos a nivel genético y una optimización de los recursos desde un punto de vista evolutivo. En cualquier caso es fascinante.

Las plantas son los seres vivos que mas relacionados están con la geometría fractal. El ejemplo clásico es el helecho (Fern) representado en otro 'post' mediante una técnica de IFS. Una técnica sorprendente dado que une el caos, la autosimilaridad y el orden en un único elemento. Representando puntos aleatorios y transformandolos usando una función iterada nace la autosimilaridad. Entrada aleatoria, mundo real; iteraciones, evolución. Personalmente no sé si la naturaleza funciona así, pero sus resultados son sorprendentes.

Uno de los ejemplos que más me ha impresionado del mundo vegetal es el brocoli de Romanesco. Conos organizados en espiral con otros conos dentro de los primeros y así sucesivamente, de tal suerte que se organizan de forma esferoide maximizando el volumen, minimizando los huecos, siendo una figura óptima.

Para representar por computadora este brócoli he utilizado simplemente un mecanismo recursivo. Siguiendo el concepto básico de función iterativa he partido de una matriz de transformación (identidad) que he ido rotando y escalando en cada iteración. Siendo el resultado de una iteración la fuente de la siguiente. Representando una esfera (o cualquier otro elemento) en el punto que determina la transformación de cualquier punto del espacio (constante en todo el proceso, por ejemplo (1,0,0) ) con dicha matriz se puede representar una forma. En este caso una espiral. Si se toma, para cada uno de esos puntos medidos en la primera pasada, su matriz de transformación asociada y se usa como matriz original de una nueva serie de transformaciones obtenemos el fenómeno de la autosimilaridad.

Esta técnica no se puede llevar hasta niveles elevados (más de 3) porque el número de elementos crece rápidamente. En el ejemplo hay dos niveles de recursividad. Nótese, a modo de comparación con la naturaleza, el detalle que tiene la forma real y cómo la computación (¡tan solo visual!) de su homólogo virtual puede llegar a ser impracticable.

Un cojín

2008-12-25T20:21:00.000+01:00

Dejo por aquí una primera prueba de un cojín. El cojín está modelado a mano. Sinceramente hubiera estado bien haber tenido algún programa de simulación física para realizar este tipo de modelos, pero por ahora a mano.

Para el efecto de iluminación he usado una BRDF de Minnaert. Esta BRDF se caracteriza por aumentar la reflectancia en ángulos alejados a la normal, justo al contrario de la Lambertiana.

Se pueden conseguir efectos similares al terciopelo. Os paso un pequeño render.

Fractal Flame

2008-12-23T18:15:00.000+01:00

Hoy he decidido revisar un módulo de fractales en C++ que empecé hace tiempo y lo he dejado bastante olvidado. Modificando ligeramente una función que calcula un fractal de tipo IFS se pueden conseguir curiosos efectos. Si se realizan principalmente dos transformaciones: Una espacial y otra de ajuste de tono, se pueden conseguir un tipo de fractales denominados Fractal Flames (creados originalmente por Scott Draves).
Este es el resultado de un programa que se puede desarrollar fácilmente (de media a una hora) para representar Fractal Flames.

Obviamente, mejorando la paleta de colores (el ejemplo tiene dos colores) se pueden llegar a obtener mejores resultados.
Si realmente os interesa explorar el mundo fractal de los IFS os recomiendo el software Apophysis. Para finalizar, os dejo un IFS bastante clásico, el del helecho.

Simulación de PinArt

2008-12-22T18:27:00.000+01:00

El otro día me acordé de aquellos juguetes con los que podías hacer una réplica de un objeto con agujas. Podéis echarle un vistazo a lo que me refiero aquí. Después de verlo me dije, por qué no hacer algo similar en 3D. Y aquí está.

Para realizar esta imagen tuve que hacer lo siguiente. Se parte de un modelo 3D. Este se puede hacer desde cero o se puede utilizar un modelo ya prehecho de Daz3D y darle una pose utilizando Poser.

Una vez que se tiene el modelo 3D, como una malla tridimensional es necesario transformarla a un objeto del estilo PinArt. Para ello es necesario crear en 3D las agujas. Esto se puede realizar con casi cualquier programa de modelado 3D.

Ahora hay que dar una cierta altura a las agujas con respecto la información de altura del modelo. Aquí hay dos maneras de atacar el problema, a mano y a máquina. Se puede tomar un programa de modelado 3D e ir ajustando las alturas de los pines uno a uno. O como elegí yo, se puede codificar un pequeño programa que determina la altura del modelo para una posición dada. Esta elección es la correcta si se desean realizar renders de otros modelos 3D. Aparte, teniendo en cuenta el número de agujas, te puedes pegar un buen rato moviéndolas de arriba a abajo. Hay que tener en cuenta que el programa que calcula las alturas de las agujas debe componer un nuevo objeto para exportarlo.

Para realizar el render he utilizado un programa de iluminación global codificado en C++. Se pueden usar programas comerciales o gratuitos como Indigo, o en mi caso, uno de fabricación propia.