Ok

Hoy os traigo una fotografía recursiva, que se contiene a si misma de manera infinita.

Fotográficamente hablando, el efecto es popularmente conocido como “Droste” y la técnica toma su nombre de una marca holandesa de cacao en polvo cuyo envase contenía una imagen recursiva.

En la misma aparecía una enfermera sosteniendo una bandeja plateada sobre la cual portaba una taza humeante y un envase de cacao, el cual a su vez contenía la imagen anteriormente descrita.

Técnicamente una imagen “Droste” se obtiene a partir de una fotografía convencional, a la que se le aplica un tratamiento digital posterior.

En la imagen que os presento el tratamiento ha sido realizado con la herramienta de edición fotográfica Gimp y el plugin MathMap, el cual nos permite distorsionar imágenes a partir de una fórmula matemática que le proporcionemos.

La fórmula matemática original procede de Breic, aunque las características adicionales y la conversión a MathMap 1.2 han sido llevadas a cabo por Josh Sommers. y la traducción al castellano realizada por Roberto Robles.

A continuación algunas otras pruebas:

 

Por si a algun@ os interesa os proporciono el código matemático empleado:

########################################
# Código para el Efecto Droste version 10 for Mathmap 1.2.0
# Última modificación: 29/7/2007
########################################

#Descripción de los valores modificables:

###Características de la Versión 10###
#MuestraAmbosPolos: selecciona esta opción para ver los dos polos del efecto Droste. Se mostrará un polo con Periodicidad=-1 y otro con Periodicidad=1. Al usar esta opción se deben aumentar los valores de NivelInicio y NumeroDeNiveles.

#RotacionPolo: rotación del polo cuando MuestraAmbosPolos está activado. Con +/-90 los dos polos son visibles, mientras que con +/-180 sólo se verá uno.

#LatPolo: esta opción se usa conjuntamente con las opciones MuestraAmbosPolos, EmbaldosaPolos o HiperDroste y se usa para ajustar la latitud.

#LongPolo: igual que LatPolo, pero para ajustar la longitud.

#EmbaldosaPolos: activa esta opción para embaldosar los polos horizontalmente. No se puede usar conjuntamente con MuestraAmbosPolos.

#HiperDroste: un bonito efecto Droste similar a un fractal.

#PuntosFractales: se usa conjuntamente con EmbaldosaPolos o con HiperDroste para crear imágenes Droste similares a un fractal.

###Características anteriores a la Versión 10###
#RadioInterior: porcentaje de la imagen que debe ser ocupado por la espiral.

#RadioExterior: porcentaje de la imagen que debe ser usado en el efecto.

#Periodicidad: número de veces que la imagen debe ser ocupada en cada iteración de la espiral.

#Brazos: número de brazos que tendrá la espiral.

#Zoom: acerca o aleja el efecto.

#Rotar: Rotar la espiral. Números positivos implican una rotación en el sentido de las agujas del reloj.

#DesplX: desplazamiento de la imagen en el eje X. Los números positivos significan un desplazamiento a la derecha.

#DesplY: desplazamiento de la imagen en el eje Y. Los números positivos significan un desplazamiento hacia arriba.

#DesplCentroX: mueve el centro de la espiral en el eje X. Números positivos mueven a la derecha.

#DesplCentroY: mueve el centro de la espiral en el eje Y. Números positivos mueven hacia arriba.

#NivelInicio: nivel en el que empieza la espiral. Para transparencia interior o sin usar transparencia el primer nivel es el más externo. Para la transparencia interior el primer nivel es el más interno.

#NumeroDeNiveles: número de repeticiones de la espiral.

#FrecuenciaDeNiveles: frecuencia de los niveles. Cuando toma el valor 1 se muestra cada nivel. Si toma el valor 2 se muestran niveles alternos, si toma el valor 3 muestra uno de cada tres niveles y así consecutivamente.

#PeriodicidadAutomatica: si está activado se selecciona el valor óptimo para el valor Periodicidad.

#SinTransparencia: se activa si no se quiere basar el efecto en la región transparente de la imagen.

#TransparenciaExterna: activar si se quiere utilizar una región transparente en el exterior de la imagen. Por defecto se utiliza una región transparente en el interior de la imagen.

#EfectoEspejo: activar para reflejar los brazos. Sólo funciona si se utilizan varios brazos.

#Untwist: activar para ver en coordenadas logarítmicas.

#NoAplanarTransparencia: activar para dejar los puntos semi-transparentes como semi-transparente.

#MostrarRed: la red verde muestra cada anillo básico, con (radio exterior)/(radio interior) = r2/r1. La red azul muestra la red verde transformada en coordenadas logarítmicas (en las cuales de verdad es una red), rotada y vuelta a exponenciar. De este modo se puede ver la transformación Droste.

#MostrarMarco: el marco es un borde en blanco y negro en la vista normal y su imagen en coordenadas logarítmicas. En estas coordenadas la región sombreada a la derecha del marco se transformará fuera de la la parte visible, mientras que la parte a la izquierda será visible.

###########################################################
## No es necesario cambiar nada por debajo de esta línea ##
###########################################################

filter droste (
image in,
float RadioInterior: 1 – 100 (25),
int RadioExterior: 1 – 100 (100),
float Periodicidad: -6 – 6 (1),
int Brazos: -6 – 6 (1),
int Zoom: 1-100 (1),
int Rotar: -360-360 (0),
int DesplX: -100 – 100 (0),
int DesplY: -100 – 100 (0),
int DesplCentroX: -100 – 100 (0),
int DesplCentroY: -100 – 100 (0),
int NivelInicio: 1-20 (1),
int NumeroDeNiveles: 1-20 (10),
int FrecuenciaDeNiveles: 1-10 (1),
bool MuestraAmbosPolos,
int RotacionPolo: -180-180 (90),
int LongPolo: -100-100 (0),
int LatPolo: -100-100 (0),
bool EmbaldosaPolos,
bool HiperDroste,
int PuntosFractales: 1-10 (1),
bool PeriodicidadAutomatica,
bool SinTransparencia,
bool TransparenciaExterna,
bool EfectoEspejo,
bool Untwist,
bool NoAplanarTransparencia,
bool MostrarRed,
bool MostrarMarco)

#Set code variables from user variables
r1= RadioInterior/100;
r2= RadioExterior/100;
p1= Periodicidad;
p2= Brazos;
xCenterShift = DesplCentroX/100;
yCenterShift = DesplCentroY/100;
xShift = (DesplX*W/X)/100;
yShift = (DesplY*H/Y)/100;
tileBasedOnTransparency = !(SinTransparencia);
transparentPointsIn = !(TransparenciaExterna);
levelsToLookOut=NivelInicio;
levelToShow=FrecuenciaDeNiveles;
retwist=!(Untwist);

if (PeriodicidadAutomatica) then
p1= p2/2 * (1+sqrt(1-(log(r2/r1)/pi)^2));
end;

#Set Rotation
if p1 > 0 then
rotate=-(pi/180) * Rotar;
else
rotate=(pi/180) * Rotar;
end;

#Set Zoom
zoom=((Zoom+RadioInterior-1)/100);

epsilon=.01;

#######################
# Set up the viewport #
#######################
if (retwist) then
xbounds=[-r2,r2];
ybounds=[-r2,r2];
else
ybounds=[0,2.1*pi];
xbounds=[-log(r2/r1), log(r2/r1)];
end;

minDimension=min(W, H);
xymiddle=ri:[0.5*(xbounds[0]+xbounds[1]),0.5*(ybounds[0]+ybounds[1])];
xyrange=xy:[xbounds[1]-xbounds[0], ybounds[1]-ybounds[0]];
aspectRatio=W/H;
xyrange[0]=xyrange[1]*aspectRatio;
xbounds=[xymiddle[0]-0.5*xyrange [0],xymiddle[0]+0.5*xyrange[0]];
z=ri:[xbounds[0]+(xbounds[1]-xbounds[0])*(x+W/2)/W,ybounds[0]+(ybounds[1]-ybounds[0])*(y+H/2)/H];

# only allow for procedural zooming/scaling in the standard coordinates
if (retwist) then
zinitial=z;
z = z – ri:[xShift,yShift];
z=xymiddle+(z-xymiddle)/zoom*exp(-I*rotate);
else
zinitial=r1*exp(z); # save these coordinates for drawing a frame later
zinitial=zinitial*Zoom*exp(I*rotate);
end;

if MuestraAmbosPolos then
theta=(pi/180)*RotacionPolo;
xx = z[0];
yy = z[1];
div = .5 * (1+ xx^2 + yy^2 + ((1-xx^2-yy^2) * cos(theta)) – (2 * xx * sin(theta)));
xx = xx * cos(theta) + (0.5*(1 – xx^2 – yy^2) * sin(theta));
z = ri:[xx,yy];
z = z/div;
else

if HiperDroste then
z = sin(z);
end;

if EmbaldosaPolos then

z = z^PuntosFractales;
z = tan(2*z);
end
end;

pLat = (LatPolo*W/X)/100;
pLon = (LongPolo*W/X)/100;
z= z + ri:[pLat,pLon];

if (retwist) then
z2=log(z/r1);
else
z2 = z;
end;

##################################
# Droste-effect math starts here #
##################################

alpha=atan(p2/p1*log(r2/r1)/(2*pi));
f=cos(alpha);
beta=f*exp(I*alpha);

# the angle of rotation between adjacent annular levels
if (p2 > 0)
then angle = 2*pi*p1;
else
angle =-2*pi*p1;
end;

if EfectoEspejo then
angle=angle/Brazos;
end;

z=p1*z2/beta;
rotatedscaledlogz=z; # save these coordinates for drawing a grid later
logz=z2; # save these coordinates for drawing a grid later
z=r1*exp(z);

################################
# Droste-effect math ends here #
################################

if (tileBasedOnTransparency && levelsToLookOut > 0) then
if (!transparentPointsIn) then ratio=r2/r1*exp( I*angle); end;
if ( transparentPointsIn) then ratio=r1/r2*exp(-I*angle); end;
z = z * (ratio^levelsToLookOut)/1;
end;

colorSoFar=rgba:[0,0,0,0];
alphaRemaining=1;
ix=minDimension/2*(z[0]+xCenterShift);
iy=minDimension/2*(z[1]+yCenterShift);
iXY = xy:[ix,iy];

ColorOut=in(iXY);
colorSoFar = colorSoFar = colorSoFar + (ColorOut*(alpha(ColorOut)*alphaRemaining));
alphaRemaining=alphaRemaining*(1-alpha(ColorOut));
sign=0;

if (tileBasedOnTransparency) then
if ( transparentPointsIn && alphaRemaining > epsilon) then
sign=-1;
end;
if (!transparentPointsIn && alphaRemaining > epsilon) then
sign= 1;
end;
else
radius=sqrt(z[0]*z[0]+z[1]*z[1]);
if (radius < r1) then sign=-1; end;
if (radius > r2) then sign= 1; end;
end;

if (sign < 0) then
ratio=r2/r1*exp( I*angle);
end;

if (sign > 0) then
ratio=r1/r2*exp(-I*angle);
end;

if (levelToShow > 1) then
ratio = exp(log(ratio)*levelToShow);
end;

iteration=NivelInicio;
maxiteration=NumeroDeNiveles+NivelInicio-1;

while (sign != 0 && iteration < maxiteration) do
z2=z*ratio;
z=z2;
rotatedscaledlogz=rotatedscaledlogz+ri:[0,-sign*angle];
ix=minDimension/2*(z[0]+xCenterShift);
iy=minDimension/2*(z[1]+yCenterShift);
iXY = xy:[ix,iy];
sign=0;
if (tileBasedOnTransparency) then
ColorOut=in(iXY);
colorSoFar = colorSoFar + (ColorOut*(alpha(ColorOut)*alphaRemaining));
alphaRemaining=alphaRemaining*(1-alpha(ColorOut));
if ( transparentPointsIn && alphaRemaining > epsilon) then sign=-1; end;
if (!transparentPointsIn && alphaRemaining > epsilon) then sign= 1; end;
else
radius=sqrt(z[0]*z[0]+z[1]*z[1]);
colorSoFar=in(iXY);
if (radius < r1) then sign=-1; end;
if (radius > r2) then sign= 1; end;
end;
iteration=iteration+1;
end;

ColorOut=colorSoFar;

if (MostrarRed) then
gridz=xy:[(logz[0]+10*log(r2/r1))%log(r2/r1), (logz[1]+10*2*pi)%(2*pi)];

if (gridz[0] < epsilon || gridz[0] > (log(r2/r1)-epsilon) || gridz[1] < epsilon || gridz[1] > (2*pi-epsilon)) then
ColorOut=rgba:[0,1,0,1];
end;

gridz=xy:[(rotatedscaledlogz[0]+10*log(r2/r1))%log(r2/r1), (rotatedscaledlogz[1]+10*2*pi)%(2*pi)];

if (gridz[0] < epsilon || gridz[0] > (log(r2/r1)-epsilon) || gridz[1] < epsilon || gridz[1] > (2*pi-epsilon)) then ColorOut=rgba:[0,0,1,1];
end;
end;

if (MostrarMarco) then
gridz=xy:[zinitial[0],zinitial[1]];
if (gridz[0] < (aspectRatio*r2) && gridz[0] > -(aspectRatio*r2) && gridz[1] < r2 && gridz[1] > -r2) then
dx=min((aspectRatio*r2)-gridz[0], gridz[0]+(aspectRatio*r2));
dy=min(r2-gridz[1], gridz[1]+r2);
if (dx < (4*epsilon) || dy < (4*epsilon)) then
ColorOut=rgba:[1,1,1,1];
end;
if (dx < (2*epsilon) || dy < (2*epsilon)) then
ColorOut=rgba:[0,0,0,1];
end;
else
ColorOut=rgba:[0.75*red(ColorOut),0.75*green(ColorOut),0.75*blue(ColorOut),1];
end;
end;

if !(NoAplanarTransparencia) then
ColorOut=rgba:[ColorOut[0], ColorOut[1], ColorOut[2], 1];
end;

ColorOut

end