Java Rekursionsdreieck mit Abweichung

Question

Hallo Ich bin ziemlich neu in der Programmierung und ich versuche, in Java, eine rekursive Dreiecke von einem größeren Dreiecke Mittelpunkte zwischen den Ecken zu schaffen, wo die neuen Dreiecke Punkte von der normalen Position in abweichen y-Wert. Siehe die Bilder unten für eine Visualisierung.

Das erste Bild zeigt den Verlauf des rekursiven Algorithmus ohne Abweichung (um 0,1,2) und das zweite Bild zeigt es mit (um 0,1).

Ich habe es geschafft, ein funktionierendes Stück Code zu erzeugen, das genau das schafft, was ich für die ersten paar Bestellungen möchte, aber wenn wir Ordnung 2 erreichen, stoße ich auf das Problem, wo die kleineren Dreiecke nicht die gleichen Mittelpunkte verwenden und sieht daher wie das Bild unten aus.

Also muss ich mit einer Art und Weise helfen, die richtigen Mittelpunkte für jedes der Dreiecke zu speichern und aufzurufen. Ich habe darüber nachgedacht, eine neue Klasse zu implementieren, die die Berechnung der Mittelpunkte steuert und sie usw. speichert, aber wie gesagt, ich brauche Hilfe dabei.

Im Folgenden finden Sie meine aktuellen Code

Der Punkt Klasse speichert Axt und y-Wert für einen Punkt

Linie zwischen einer Linie zwischen den

Voraus

void fractalLine(TurtleGraphics turtle, int order, Point ett, Point tva, Point tre, int dev) { 


    if(order == 0){ 
     lineBetween(ett,tva,turtle); 
     lineBetween(tva,tre,turtle); 
     lineBetween(tre,ett,turtle); 
    } else { 

      double deltaX = tva.getX() - ett.getX(); 
      double deltaY = tva.getY() - ett.getY(); 

      double deltaXtre = tre.getX() - ett.getX(); 
      double deltaYtre = tre.getY() - ett.getY(); 

      double deltaXtva = tva.getX() - tre.getX(); 
      double deltaYtva = tva.getY() - tre.getY(); 

      Point one; 
      Point two; 
      Point three; 

      double xt = ((deltaX/2))+ett.getX(); 
      double yt = ((deltaY/2))+ett.getY() +RandomUtilities.randFunc(dev); 
      one = new Point(xt,yt); 

      xt = (deltaXtre/2)+ett.getX(); 
      yt = (deltaYtre/2)+ett.getY() +RandomUtilities.randFunc(dev); 
      two = new Point(xt,yt); 

      xt = ((deltaXtva/2))+tre.getX(); 
      yt = ((deltaYtva/2))+tre.getY() +RandomUtilities.randFunc(dev); 
      three = new Point(xt,yt); 

      fractalLine(turtle,order-1,one,tva,three,dev/2); 
      fractalLine(turtle,order-1,ett,one,two,dev/2); 
      fractalLine(turtle,order-1,two,three,tre,dev/2); 
      fractalLine(turtle,order-1,one,two,three,dev/2);    
    } 
} 

Dank in

den ausgewählten Punkten schafft

Victor

Answer 1

Sie berechnen die Midpoi nts jedes Eckpunkts immer wieder in den verschiedenen Pfaden Ihrer Rekursion. Solange Sie sie nicht zufällig ändern, erhalten Sie für jeden Pfad den gleichen Mittelpunkt, so dass es kein Problem gibt. Aber natürlich, wenn Sie die Mittelpunkte zufällig ändern, enden Sie mit zwei verschiedenen Mittelpunkten in zwei verschiedenen Rekursionswegen.

Sie könnten Ihren Algorithmus so modifizieren, dass Sie nicht nur die 3 Ecken des Dreiecks, sondern auch die modifizierten Mittelpunkte jedes Eckpunkts passieren. Oder Sie behalten sie in einer separaten Liste oder Karte oder etwas und berechnen sie nur einmal und schauen sie anders auf.

Answer 2

Sie können ein Dreieck durch 3 Punkte (Scheitelpunkte) definieren. Die Eckpunkte a, b und c bilden also ein Dreieck. Die Kombinationen ab, ac und bc sind die Kanten. So ist der Algorithmus geht:

1. Erster Start mit den drei Eckpunkten a, b und c
2. Holen Sie sich die Mittelpunkte der drei Kanten P1, P2 und P3 und erhalten die vier Sätze von Eckpunkten für die 4 kleinere Dreiecke. dh (a, p1, p2), (b, p1, p3), (c, p2, p3) und (p1, p2, p3)
3. rekursiv die Unterdreiecke der 4 Dreiecke finden, bis die Tiefe erreicht ist .

So als grobe Orientierung, geht der Code

findTriangles(Vertexes[] triangle, int currentDepth) { 
    //Depth is reached. 
    if(currentDepth == depth) { 
      store(triangle); 
      return; 
    } 
    Vertexes[] first = getFirstTriangle(triangle); 
    Vertexes[] second = getSecondTriangle(triangle); 
    Vertexes[] third = getThirdTriangle(triangle);; 
    Vertexes[] fourth = getFourthTriangle(triangle) 

    findTriangles(first, currentDepth+1); 
    findTriangles(second, currentDepth+1); 
    findTriangles(third, currentDepth+1); 
    findTriangles(fourth, currentDepth+1); 
}  

Sie haben die entsprechenden Dreiecke in einer Datenstruktur zu speichern.