8.4 Baumstrukturen

Gegeben ein ``Ast'', repräsentiert durch ein 5-seitiges Polygon:

An den Kanten bzw. können nun weitere ``Äste'' als Polygone angesetzt werden, die bzgl. des gegebenen Polygons mit 0.75 bzw. 0.47 skaliert sind. Durch wiederholtes Anstückeln entsteht ein Baum mit immer feinerer Verästelung. Statt dieses deterministischen Verfahrens kann man z.B. die Lage des Punktes C von einem Zufallsparameter beeinflussen lassen.

Vom Baum-Algorithmus erzeugter Baum mit 11, 47 bzw. 3071 Polygonpunkten

/*****************************************************************************/
/*                                                                           */
/*                              Baum                                         */
/*                                                                           */
/*****************************************************************************/

public void baum()             // wendet eine Iteration auf die Ansatzstuecke an
        //Point ansatz[],      // alte und neue Folge von Ansatzstuecken
        //int   anzahl,        // Anzahl der Anzsatzstueckendpunkte
        //Point poly_punkt[],  // alte und neue Folge von Polygonecken
        //int   poly_point_cnt // Anzahl der Polygonecken
{
        int i,j,k,p;
        double a,b,l,si_de,co_de;
        Point P;
        Point Q;
        Point A;
        Point B;
        Point C;
        Point[] ast = new Point[3];
        Point[] Hpunkt = new Point[MAX_POINTS];
        Point[] Hansatz = new Point[MAX_POINTS];

        DoublePoint[] schema = new DoublePoint[3];

        ast[0] = new Point();
        ast[1] = new Point();
        ast[2] = new Point();
        
        schema[0] = new DoublePoint();
        schema[1] = new DoublePoint();
        schema[2] = new DoublePoint();

        schema[0].x = 0.0;                    // generiere Schema
        schema[0].y = 2.0;                                
        schema[1].x = 2.0/3.0;
        schema[1].y = 7.0/3.0;
        schema[2].x = 1.0;
        schema[2].y = 2.0;

        j=0;                                  // Index fuer neue Ansatzstuecke
        k=0;                                  // Index fuer neue Polygonpunkte
        for (p=0; p<anzahl; p=p+2)
        {
                P = ansatz[p];
                Q = ansatz[p+1];
                
                a     = P.y - Q.y;            // bestimme l, sinus, cosinus
                b     = Q.x - P.x;
                l     = Math.sqrt(a*a + b*b);
                si_de = a/l;
                co_de = b/l;

                for (i=0; i<3; i++)           // fuehre Skalierung und Rotation aus
                {
                    ast[i].x = P.x + (int)(l*schema[i].x*co_de-l*schema[i].y*si_de);
                    ast[i].y = P.y - (int)(l*schema[i].y*co_de+l*schema[i].x*si_de);
                }

                A = ast[0];                   // kreiere neue Ast-Punkte
                B = ast[1];
                C = ast[2];

                if (anzahl>2) del_line(P, Q); // loesche Ansatzstueck

                set_line(P,A);                // zeichne Figur P,A,B,C,Q
                set_line(A,B);
                set_line(B,C);
                set_line(C,Q);
                                              // speichere neue Ansatzstuecke
                Hansatz[j]          = new Point(A); 
                Hansatz[j+1]        = new Point(B);
                Hansatz[j+2]        = new Point(B);
                Hansatz[j+3]        = new Point(C);
                j=j+4;
        }

        i=0;                                  // Index fuer altes Polygon
        k=0;                                  // Index fuer neues Polygon
        for (p=0; p<anzahl; p=p+2)            // Index fuer alte Ansatzstuecke
        {
                while  ((poly_punkt[i].x !=ansatz[p].x) ||
                        (poly_punkt[i].y !=ansatz[p].y))
                                              // uebernimm unveraenderte Polygonpkte
                    Hpunkt[k++] = poly_punkt[i++];
 
                Hpunkt[k]   = ansatz[p];      // uebernimm neue Polygonpunke
                Hpunkt[k+1] = Hansatz[2*p];
                Hpunkt[k+2] = Hansatz[2*p+1];
                Hpunkt[k+3] = Hansatz[2*p+3];
                Hpunkt[k+4] = ansatz[p+1];
                k+=4;
                i++;
        }

        while (i<poly_point_cnt) Hpunkt[k++]=poly_punkt[i++];
        
        for (i=0; i<j; i++) 
                ansatz[i] = Hansatz[i];       // neu berechnete Ansatzstuecke kopieren 
        anzahl=j;                             
        
        for (i=0; i<k; i++) 
                poly_punkt[i] = Hpunkt[i];    // neu berechnete Polygonpunkte kopieren
        poly_point_cnt=k;                   
}