END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

Anyone knows if this formula is convertible to escape-time ifs for MB3d or something... I'm not good at this, plus I'm trying to do a formula by scratch without success. Please help me

http://bernhardhaeussner.de/blog/65_Processing%3A_3D-Koch-Kurve_mit_Sierpinski-Dreieck

Source code;

fraqTriang trs[]=new fraqTriang[4];

void setup(){
  size(640, 480, P3D);
  noStroke();
  fill(150,150,150,20);
  int bigrad=200;
  int req=6;
  
  PVector A=new PVector(-bigrad,0,0);
  PVector B=new PVector(bigrad/2,0,-173.21);
  PVector C=new PVector(bigrad/2,0,173.21);
  PVector D=new PVector(0,-bigrad*(sqrt(6)/3),0);
  
  trs[0]=new fraqTriang(A,B,C,req);
  trs[1]=new fraqTriang(A,D,B,req);
  trs[2]=new fraqTriang(A,C,D,req);
  trs[3]=new fraqTriang(B,D,C,req);
}


void draw(){
  background(255);
  lights();
  
  float winkel=(mouseX/float(width))*TWO_PI;
  float xpos=cos(winkel);
  float ypos=sin(winkel);
  float radius=300.000;
  camera(xpos*radius, mouseY, ypos*radius, // eyeX, eyeY, eyeZ
         0.0, -50.0, 0.0, // centerX, centerY, centerZ
         0.0, -1.0, 0.0); // upX, upY, upZ
      
  for (int i=0;i<trs.length;i++) {
    trs[i).display();
  }
  //saveFrame("frames/koch3d-####.png"); //uncomment to record
}

class fraqTriang{
  PVector PointA;
  PVector PointB;
  PVector PointC;
  fraqTriang recTris[]=new fraqTriang[6];
  int rec;
  float scaling;
  
  fraqTriang(PVector A,PVector B,PVector C, int recursion){
    scaling=0.7;
    PointA=A;
    PointB=B;
    PointC=C;
    rec=recursion;
    applyRecursion ();
  }
    
 void applyRecursion () {
    if (rec!=0) {
      PVector PointAB2=PVector.add(PointA,PointB);
      PointAB2.div(2);
      PVector PointAC2=PVector.add(PointA,PointC);
      PointAC2.div(2);
      PVector PointBC2=PVector.add(PointB,PointC);
      PointBC2.div(2);
      
      PVector PointZ=PVector.add(PointA,PointB);
      PointZ.add(PointC);
      PointZ.div(3);
      PVector PointAB=PVector.sub(PointA,PointB);
      PVector PointAC=PVector.sub(PointA,PointC);
      PVector PointH=PointAB.cross(PointAC);
      PointH.normalize();
      PVector PointAAB2=PVector.sub(PointA,PointAB2);
      float a=PointAAB2.mag();
      float pheight=a*(sqrt(6)/3)*scaling;
      PointH.mult(-pheight);
      PVector PointZH=PVector.add(PointZ,PointH);
      
      recTris[0]=new fraqTriang(PointA,PointAB2,PointAC2,rec-1);
      recTris[1]=new fraqTriang(PointB,PointBC2,PointAB2,rec-1);
      recTris[2]=new fraqTriang(PointC,PointAC2,PointBC2,rec-1);
      
      recTris[3]=new fraqTriang(PointZH,PointAC2,PointAB2,rec-1);
      recTris[4]=new fraqTriang(PointZH,PointAB2,PointBC2,rec-1);
      recTris[5]=new fraqTriang(PointZH,PointBC2,PointAC2,rec-1);
    }
  }  
  
  void display () {
    if (rec==0) {
      beginShape();
      vertex(PointA.x, PointA.y ,PointA.z);
      vertex(PointB.x, PointB.y ,PointB.z);
      vertex(PointC.x, PointC.y ,PointC.z);
      endShape(CLOSE);
    } else {
      for (int i=0; i<recTris.length;i++) {
        recTris.display();
      }
    }
  }
  
}

The interesting part is highlighted...

DarkBeam: I've been thinking recently about how to make arbitrary IFS fractals using escape time. It's a little tricky to do, but well worth it when we figure it out.
The problem is that escape time works by taking functions of functions of functions, etc. Each time a function is applied it skews the entire 3-D space. If the function isn't conformal then after a few iterations space gets drawn out into spikes.

Meanwhile, recursive IFS's don't transform the entire space over each iteration, just a few registration points (i.e., A, B, C). The child object has essentially a fresh new Euclidean (orthogonal) space to be generated in.

So, I've concluded that for escape time, if the function has non-uniform scaling, it must be re-scaled on the next few iterations to restore uniform space. E.g. , if a matrix specifies the function, then some variant of the matrix inverse must be used on the next step to restore the space to conformal.

-mike

This is a scheme of the transform, but it's hard to write it, I get lost...



At first we need to bring all 3D space to the "red area", with a 3D rotation (it's already hard!)

Then, we must do a translate+scaling for regions 1 and 3 and an additional rotation for 2 and 4.

What I miss is the exact values for all vectors and angles!

I'm afraid this is not possible with KIFS. It's not symmetric enought. I've tried the symetric 3D Koch based on a tetrahedra but the result is a simple cube... Maybe I'm wrong. In fact, I hope so.

Well you can do it with regular IFS. It is possible to do IFS as escape time fractal but you would need a stack (see this paper.). You could also do it with some sort of combination between IFS ans KIFS by using the symmetries of that object.
With KIFS it is possible to reproduce only a subset of regular IFS: Those whose Transformation set is symmetric, that is, there is a set of folding planes that transform (the order is important because of the non commutativity of linear operator algebra) any of the IFS transformation to any other. In fact this condition is not sufficient apparently: I coudn't obtain the squarry Koch but the squarry koch + something...Humm... I'm talking like a mathematician. Hope that it makes sens .

Kind of! Here is attached a fragmentarium shader. There are some interresting variations by changing offset, rotation, scale and the order of foldings...

Ok, I have translated to Mandelbulb, but it is discontinue in some points,  and discontinue figures have a kinda weird look, but it is nice.

Very similar to my Menger Koch. I will see if it's worth to add to my DB!

A picture?

Something similar to the "squarey" Koch using escape time. It's in Tglad's table, too, I think.
The algorithm is you keep clipping off the corners of 3x3 cubes.