Welcome to Fractal Forums

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];
		}

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;
}

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

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

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];
		}

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;
}