Escape Time version of the Tetrahedral Apollonian Gasket

[Aexion]

Hello,

This is my first topic post, so excuse me if I make something wrong.. 

Recently DarkBean asked me about the escapetime version of the Tetrahedral Apollonian Gasket (its on my da gallery), and after sometime searching on my old files, I have found it, so here is the code:

First, variable initializations:

Code:

float Tetrahedron[]={
0.000,  0.000,  1.000, 
0.943,  0.000, -0.333, 
-0.471,  0.816, -0.333, 
-0.471, -0.816, -0.333 
};

float Ta[5],Tb[5],Tc[5],Td[5];

for (int tr=0; tr<5;tr++){ 
		if (tr<4){
		Ta[tr]=Tetrahedron[tr*3];
		Tb[tr]=Tetrahedron[tr*3+1];
		Tc[tr]=Tetrahedron[tr*3+2];
		Td[tr]=(0.81649658573140704000)*1.1;//this parameter is for distorting the size of the inversion..
		} else {
		Ta[tr]=0;
		Tb[tr]=0;
		Tc[tr]=0;
		Td[tr]=(0.18350338935852051000)*1.1;//this parameter is for distorting the size of the inversion..
		}
		Td[tr]=Td[tr]*Td[tr];
		}

And the function. it returns true if its solid, false if its just empty space (its crude and unnoptimized!..)
Scan the area around the unit sphere..

Code:

bool TGasket(float x, float y, float z)
{
	if(sqrt(x*x+y*y+z*z)>0.75)return false; //filter unnecessary areas, must be removed for other sets
	bool escape;//if the orbit escapes, it returns false, else it return true..
	int ic;
	float X1[5],Y1[5],Z1[5],DST[5];//temporal storage of the iteration values and distances
	for (ic=0;ic<12;ic++){
		for (int tr=0;tr<5;tr++){
			const float ax=x - Ta[tr];
			const float ay=y - Tb[tr];
			const float az=z - Tc[tr];
			const float radius=Td[tr]/(ax*ax+ay*ay+az*az);	
			X1[tr] = Ta[tr] + (x - Ta[tr])*radius;	
			Y1[tr] = Tb[tr] + (y - Tb[tr])*radius;
			Z1[tr]=  Tc[tr] + (z - Tc[tr])*radius;

			//Method 1 Centered at Origin only valid for hedra like fractals
			DST[tr]=X1[tr]*X1[tr]+Y1[tr]*Y1[tr]+Z1[tr]*Z1[tr];
			
			//Method 2 General, using transformation centers. valid for all sets
			//DST[tr]=(Ta[tr]-X1[tr])*(Ta[tr]-X1[tr])+(Tb[tr]-Y1[tr])*(Tb[tr]-Y1[tr])+(Tc[tr]-Z1[tr])*(Tc[tr]-Z1[tr]);
			
		}

		int tr1=0;
		float rdst=0;
		//select the transformation..the most distant one wins
		for (int tr=0;tr<5;tr++){
			if (rdst<DST[tr]){
				rdst=DST[tr];
				tr1=tr;
			}
		}
		x=X1[tr1];
		y=Y1[tr1];
		z=Z1[tr1];
		if(2.5<DST[tr1])break;
	}
	if(ic<11 && ic>1)escape=true;else escape=false;//filter the first iteration, the set lies in the center of a coconut like sphere
	return escape;
}

This solution may work for every circle inversion based fractal. I have tested it on the Icosahedral and the Dodecahedral gaskets and it produce very interesting results.

If anyone is interested on this, I can post other variations..

Thanks

Aexion



 

[fractalrebel]

Hi Aexion,

I am not sure this is quite right. The standard Appllonian Gasket is created from circle inversions. The Gasket for the Platonic Solids cases should be from Sphere inversions. Here is my Tetrahedral Appollonian Gasket. The coloring is chosen so that each sphere is colored according to its generator. There are four generators so there are four colors. If you look closely, no to spheres that are the same color should touch.

[fractalrebel]

The previous example had 100 iterations. This example has only 5 and the spheres are set to show partial transparency so that you can readily see the internal structure.

[fractalrebel]

Here is a Tetrahedral Gasket that has been "sliced", which is another way to see some of the internal structure. Some texture has also been added to the spheres.

[fractalrebel]

One last image. This one is a Dodecahedral Gasket with coloring based upon the sphere radius. Small spheres are colored gold and the larger ones blue.

[DarkBeam]

@Aexion
This formula looks very good to me - except for the fact that spheres seems to have a wrong radius settings (they should touch in a single point )

The only problem is that uses lists, and it's quite not easy to translate in assembly. I bet that I must use those complicated instructions like fld qword ptr ds:[EBP+EAX] ...

But I will try

[DarkBeam]

Hi Aexion,

I am not sure this is quite right. The standard Appllonian Gasket is created from circle inversions. The Gasket for the Platonic Solids cases should be from Sphere inversions. Here is my Tetrahedral Appollonian Gasket. The coloring is chosen so that each sphere is colored according to its generator. There are four generators so there are four colors. If you look closely, no to spheres that are the same color should touch.

Are you sure you have readed carefully the formula?

const float radius=Td{ tr }/(ax*ax+ay*ay+az*az);

   

[Aexion]

@Aexion
This formula looks very good to me - except for the fact that spheres seems to have a wrong radius settings (they should touch in a single point )

The only problem is that uses lists, and it's quite not easy to translate in assembly. I bet that I must use those complicated instructions like fld qword ptr ds:[EBP+EAX] ...

But I will try

Oh,I forgot to mention that.. look at the code initialization, you will see this line:

Code:

Td[tr]=(0.81649658573140704000)*1.1;//this parameter is for distorting the size of the inversion..

and:

Code:

Td[tr]=(0.18350338935852051000)*1.1;//this parameter is for distorting the size of the inversion..

By changing the 1.1 by 1.0, you will get the real solution, but its boring, very boring.. hence why I have increased the size of the inversion..

I forgot that you cannot use arrays, let me try to unwind the loops, but the formula will be larger..

[DarkBeam]

Yeah I can try to use arrays but it's hard to do, I am not as expert by Jesse

Anyway I will not transpose this formula tomorrow, so let me take my time. If you want to add something you are welcome!

For example, I need to know exactly what parameters should be user defined before beginning

[Aexion]

Yeah I can try to use arrays but it's hard to do, I am not as expert by Jesse

Anyway I will not transpose this formula tomorrow, so let me take my time. If you want to add something you are welcome!

For example, I need to know exactly what parameters should be user defined before beginning

Ok..
The formula has very few params, so later I will unwind the loops and rewrite it in a more clearly way..

Here is also another formula..this uses the vertices of a Icosahedron, but I think that you can hardly use it, since it uses 13 transformations and it requires a double  type  (if you use floats, some strange box shapes appers).. anyways, here is it:

Initializations:

Code:

const float Icosahedron[]={
   0.000f,  0.000f,  1.000f, 
  0.894f,  0.000f,  0.447f, 
  0.276f,  0.851f,  0.447f, 
 -0.724f,  0.526f,  0.447f, 
 -0.724f, -0.526f,  0.447f, 
   0.276f, -0.851f,  0.447f, 
   0.724f,  0.526f, -0.447f, 
  -0.276f,  0.851f, -0.447f, 
 -0.894f,  0.000f, -0.447f, 
  -0.276f, -0.851f, -0.447f, 
   0.724f, -0.526f, -0.447f,
  0.000f,  0.000f, -1.000 
};

float Ta[15],Tb[15],Tc[15],Td[15];



const float disx=Icosahedron[0]-Icosahedron[3];
const float disy=Icosahedron[1]-Icosahedron[4];
const float disz=Icosahedron[2]-Icosahedron[5];
const float tdistance=sqrt(disx*disx+disy*disy+disz*disz)/2;//calc the size of the transformation
const float variation=1.05;//make the transformation a little bigger, so they intersect.

for (int tr=0; tr<13;tr++){ 
		if (tr<12){
		//Icosahedron corners
		Ta[tr]=Icosahedron[tr*3];
		Tb[tr]=Icosahedron[tr*3+1];
		Tc[tr]=Icosahedron[tr*3+2];
		Td[tr]=tdistance*variation;
		} else {
		//central transformation
		Ta[tr]=0;
		Tb[tr]=0;
		Tc[tr]=0;
		Td[tr]=(1-tdistance)*variation;
		}
		Td[tr]=Td[tr]*Td[tr];
		}

And the formula:

Code:

bool Icosa(double x, double y, double z, int iter)
{
	if(sqrt(x*x+y*y+z*z)>1.1)return false; //filter unneresary areas, must be removed for other sets
	bool escape;//if the orbit escapes, it returns false, else it return true..
	int ic;
	double X1[13],Y1[13],Z1[13],DST[13];//temporal storage of the iteration values and distances
	for (ic=0;ic<iter;ic++){
		for (int tr=0;tr<13;tr++){
			const double ax=x - Ta[tr];
			const double ay=y - Tb[tr];
			const double az=z - Tc[tr];
			const double radius=Td[tr]/(ax*ax+ay*ay+az*az);	
			X1[tr] = Ta[tr] + (x - Ta[tr])*radius;	
			Y1[tr] = Tb[tr] + (y - Tb[tr])*radius;
			Z1[tr]=  Tc[tr] + (z - Tc[tr])*radius;

			//Method 1 Centered at Origin
			//DST[tr]=X1[tr]*X1[tr]+Y1[tr]*Y1[tr]+Z1[tr]*Z1[tr];
			
			//Method 2 General, using transformation centers
			DST[tr]=(Ta[tr]-X1[tr])*(Ta[tr]-X1[tr])+(Tb[tr]-Y1[tr])*(Tb[tr]-Y1[tr])+(Tc[tr]-Z1[tr])*(Tc[tr]-Z1[tr]);
			
		}

		int tr1=0;
		double rdst=0;
		//select the transformation..the most distant one wins
		for (int tr=0;tr<13;tr++){
			if (rdst<DST[tr]){
				rdst=DST[tr];
				tr1=tr;
			}
		}
		x=X1[tr1];
		y=Y1[tr1];
		z=Z1[tr1];
		if(1.5<DST[tr1])break;
	}
	if(ic<iter && ic>1)escape=true;else escape=false;
	return escape;
}

call it by:
bool Icosa(x, y,z, 16);  //16 iterations

This formula is very interesting and beautiful, saddly my renders are not very good, but the internal structure is very fine..

I have included the renders of the two methods.

[DarkBeam]

The problem is not in the var type; I use QWORD pointers so they are natively double precision, but the more the code is long the more it takes to translate.

Anyway really thanks for the effort! It's not said that I will not be able to do the translation