potencia - tipos de recursividad en java

Triángulo de recursión de Java con desviación

Question

Hola, soy bastante nuevo en programación y estoy intentando, en Java, crear una función que cree triángulos recursivos desde un triángulo más grande puntos medios entre esquinas donde los nuevos puntos de triángulos se desvían de la posición normal en el valor y. Vea las imágenes a continuación para una visualización.

La primera imagen muestra la progresión del algoritmo recursivo sin ninguna desviación (orden 0,1,2) y la segunda imagen lo muestra con (orden 0,1).

He logrado producir una pieza de código de trabajo que crea justo lo que quiero para los primeros dos pedidos, pero cuando alcanzamos el orden 2 y superior me encuentro con el problema donde los triángulos más pequeños no usan los mismos puntos medios y por lo tanto se ve como la imagen de abajo

Entonces necesito ayuda con una forma de almacenar y llamar a los puntos medios correctos para cada uno de los triángulos. He estado pensando en implementar una nueva clase que controle el cálculo de los puntos medios y los almacene, etc., pero como he dicho, necesito ayuda con esto.

A continuación está mi código actual

La clase de punto almacena el valor ax y y para un punto

lineBetween crea una línea entre los puntos seleccionados

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

Gracias por adelantado

Víctor

Answer 1

Calcula los puntos medios de cualquier vértice una y otra vez en las diferentes rutas de su recursión. Siempre que no los cambie aleatoriamente, obtendrá el mismo punto medio para cada ruta, por lo que no hay problema. Pero, por supuesto, si modifica los puntos medios al azar, terminará con dos puntos medios diferentes en dos rutas de recursión diferentes.

Puede modificar su algoritmo de manera que no solo pase las 3 esquinas del triángulo, sino también los puntos medios modificados de cada vértice. O manténgalas en una lista o mapa separado o algo así y solo cómprelas una vez y búsquelas de otra manera.

Answer 2

Puedes definir un triángulo por 3 puntos (vértices). Entonces los vértices a, b y c formarán un triángulo. Las combinaciones ab, ac y bc serán los bordes. Entonces el algoritmo va:

1. Primero comience con los tres vértices a, byc
2. Obtenga los puntos medios de los 3 bordes p1, p2 y p3 y obtenga los 4 conjuntos de vértices para los 4 triángulos más pequeños. es decir, (a, p1, p2), (b, p1, p3), (c, p2, p3) y (p1, p2, p3)
3. Encuentre recursivamente los sub-triángulos de los 4 triángulos hasta que se alcance la profundidad.

Entonces, como una guía aproximada, el código va

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

Tienes que almacenar los triángulos relevantes en una estructura de Datos.