Rekursive Sierpinski-Dreieck ist Java

Ich versuche zu zeichnen, Sierpinski-Dreieck ist rekursiv in Java, aber es funktioniert nicht, obwohl mir die Logik scheint in Ordnung. Der base case ist, wenn die Dreiecke sind innerhalb von 2 Pixel von einander, daher die Verwendung der abstandsformel.

import java.awt.Graphics;
import java.awt.Color;
import java.awt.Font;
import java.awt.Canvas;

public class Triangle extends Canvas implements Runnable
{
    private static final int WIDTH = 800;
    private static final int HEIGHT = 600;


public Triangle()
{
    setBackground(Color.WHITE);
}

public void paint( Graphics window )
{
    window.setColor(Color.BLUE);
    window.setFont(new Font("ARIAL",Font.BOLD,24));     
    window.drawString("Serpinski's Gasket", 25, 50);

    triangle(window, (WIDTH-10)/2, 20, WIDTH-40, HEIGHT-20, 40, HEIGHT-20, 4);
}

public void triangle(Graphics window, int x1, int y1, int x2, int y2, int x3, int y3, int r)
{


    //if statement base case
        //midpoint = (x1 + x2 /2), (y1 + y2/2)
        if(Math.sqrt((double)(Math.pow(x2-x1, 2)) + (double)(Math.pow(y2-y1, 2))) > 2)
        //if(r==0)
        {
            window.drawLine(x1, y1, x2, y2);     
            window.drawLine(x2, y2, x3, y3);
            window.drawLine(x3, y3, x1, y1);
        }

        int xa, ya, xb, yb, xc, yc;   //make 3 new triangles by connecting the midpoints of
        xa = (x1 + x2) / 2;             //. the previous triangle 
        ya = (y1 + y2) / 2;
        xb = (x1 + x3) / 2;
        yb = (y1 + y3) / 2;
        xc = (x2 + x3) / 2;
        yc = (y2 + y3) / 2;


        triangle(window, x1, y1, xa, ya, xb, yb, r-1);   //recursively call the function using the 3 triangles
        triangle(window, xa, ya, x2, y2, xc, yc, r-1);
        triangle(window, xb, yb, xc, yc, x3, y3, r-1);

}

public void run()
{
    try{
        Thread.currentThread().sleep(3);    
    }
    catch(Exception e)
    {
    }
}
}

Den Läufer ist

import javax.swing.JFrame;

public class FractalRunner extends JFrame
{
    private static final int WIDTH = 800;
    private static final int HEIGHT = 600;

public FractalRunner()
{
    super("Fractal Runner");

    setSize(WIDTH+40,HEIGHT+40);

    getContentPane().add(new Triangle());   

    setVisible(true);
}

public static void main( String args[] )
{
    FractalRunner run = new FractalRunner();
}
}

Mir das sollte funktionieren, aber es führt zu einer Laufzeit - /StackOverFlow-Fehler, ich weiß nicht, wie korrigieren. Keine Hilfe?

InformationsquelleAutor flaw600 | 2013-02-16
  1. 2

    Müssen Sie bewegen die rekursiven Aufrufe zum Dreieck, und die damit verbundene Mathematik, im bedingten schauen Sie auf die Trennung. Gerade jetzt, wird es immer es nennen und deshalb bekommen Sie die stack-überlauf.

    • Warum muss es immer es nennen wenn? Es soll anhalten, wenn der Abstand zwischen den Dreiecken wird auf weniger als 2 px
    • Aber die Anrufe werden nicht innerhalb der bedingten - so sind Sie immer gemacht. Stattdessen verschieben Sie die schließende Klammer, die auf den if-block an das Ende der Funktion so, dass die rekursiven Aufrufe sind, unterliegen der gleichen Prüfung.
    • Wenn diese Antwort für Sie gearbeitet, dann sollten Sie wohl akzeptieren.
    • Ich war nicht sicher, wie das zu tun. Es getan hat. Nochmals vielen Dank!
    InformationsquelleAutor DrC
  2. 0

    Chancen sind Ihr base-case könnte nicht richtig arbeiten - was ist, wenn der Abstand zwischen zwei Dreiecken wird niemals zwei Pixel? sagen wir Sterne mit y1 und x1 0 und 200. deren Mittelpunkt wäre 100, dann 50, 25, 12, 6, 3, 1<--- noch nie hat die 2-pixel-Basis-Fall...

    InformationsquelleAutor x86ris
  3. 0

    "StdDraw" stammt von hier:

    public class Sierpinski {

    public static void sierpinski(int n) {
        sierpinski(n, 0, 0, 1);
    }

    public static void sierpinski(int n, double x, double y, double size) {

        if (n == 0) return;

        //compute triangle points
        double x0 = x;
        double y0 = y;
        double x1 = x0 + size;
        double y1 = y0;
        double x2 = x0 + size / 2;
        double y2 = y0 + (Math.sqrt(3)) * size / 2;

        //draw the triangle        
        StdDraw.line(x0, y0, x1, y1);
        StdDraw.line(x0, y0, x2, y2);
        StdDraw.line(x1, y1, x2, y2);
        StdDraw.show(100);

        //recursive calls
        sierpinski(n-1, x0, y0, size / 2);
        sierpinski(n-1, (x0 + x1) / 2, (y0 + y1) / 2, size / 2);
        sierpinski(n-1, (x0 + x2) / 2, (y0 + y2) / 2, size / 2);
    }

    //read in a command-line argument n and plot an order Sierpinski Triangle
    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        StdDraw.setPenRadius(0.005);
        sierpinski(n);
    }
}

    Kerl

    InformationsquelleAutor Guyn
Schreibe einen Kommentar