Rekursion Schneeflocke - Kurze Frage zur Methode

[bob651]

Hi, ich benötige Hilfe für das Folgende:
Vier überkreuzte Linien programmieren.
An jedem Ende dasselbe, nur um den Faktor 0,33 gekürzt.
Die Rekursion soll bei n=3 abgebrochen.

Ich habe schon die Linien programmiert. Mir fehlt nur noch der Rekursionsteil. Hier mein Code:

import java.applet.Applet ;
import java.awt.* ;
import java.lang.Math ;

public class schnee extends Applet
{
  Graphics graph;
  
  private void schneeflocke( int x, int y, int size )
  {
    int endX, endY ;
   
   
    for ( int i = 0; i<8; i++ )
    {
      endX = x + (int)(size*Math.cos( (2*Math.PI/8)*i ));
      endY = y - (int)(size*Math.sin( (2*Math.PI/8)*i ));
      graph.drawLine( x, y, endX, endY );
    
    }
  }
        

  public void paint ( Graphics gr )
  {
    graph = gr;
    int breite  = getSize().width;
    int höhe = getSize().height;
    int min;
   
    if ( höhe > breite )
      min = höhe;
    else
      min = breite;
     
    schneeflocke( breite/2, höhe/2, min/2 );
  }}

 

[bob651]

Hat jemand eine Idee? Pseudocode würde mir auch reichen xD Die 4 Linien habe ich schon. Muss diese 4 Linien an jedes Ende rankleben, das wars

 

[bob651]

ok, habs schon

 

[Xyz1]

Fonts zeichnet man eigentlich mit anderen Techniken ...
Aber ich implementiere das mal, wie vom Lehrer gewünscht (habe noch Zeit, bis meine Pizza fertig ist 😀 )

 

[bob651]

//
import java.applet.Applet ;
import java.awt.* ;
import java.lang.Math ;

public class flocke extends Applet
{
  Graphics graph;
  
  private void flockemale( int x, int y, double size )
  {
    int endeX ;
    int endeY ;
   
    if ( size <= 10 ) return;
   
   
    for ( int i = 0; i<8; i++ )
    {
      endeX = x + (int)(size*Math.cos( (2*Math.PI/8)*i ));
      endeY = y - (int)(size*Math.sin( (2*Math.PI/8)*i ));
      graph.drawLine( x, y, endeX, endeY );
      flockemale( endeX, endeY, size/3 );
    }
  }
        
  public void paint ( Graphics gr )
  {
    graph      = gr;
    int breite  = getSize().width;
    int höhe = getSize().height;
    int min;
   
   
   
    if ( höhe < breite )
      min = höhe;
    else
      min = breite;
     
    flockemale( breite/2, höhe/2, min/4 );
  }
}

so klappts, aber wenn es einfacher geht, nur zu und danke 😀

 

[Xyz1]

Ich nehme an, das soll so schauen:

    private static void zeichneFlocke() {
        JFrame jf = new JFrame("Flocke");
        JPanel jp = new JPanel() {
            @Override
            public void paint(Graphics g) {
                super.paint(g);
                g.setColor(Color.WHITE);
                paint1(g, 200, 400, 400);
            }

            void paint1(Graphics g, int len, int x, int y) {
                if (len < 21) {
                    return;
                }

                //g.drawOval(x - len, y - len, len * 2, len * 2);
                g.drawLine(x + len, y + 0, x - len, y + 0);
                g.drawLine(x + 0, y + len, x + 0, y - len);
                g.drawLine((int) (x + len * Math.sqrt(2) / 2), (int) (y + len * Math.sqrt(2) / 2), (int) (x - len * Math.sqrt(2) / 2), (int) (y - len * Math.sqrt(2) / 2));
                g.drawLine((int) (x + len * Math.sqrt(2) / 2), (int) (y - len * Math.sqrt(2) / 2), (int) (x - len * Math.sqrt(2) / 2), (int) (y + len * Math.sqrt(2) / 2));

                paint1(g, (int) Math.round(len * 0.33), x + len, y + 0);
                paint1(g, (int) Math.round(len * 0.33), x + 0, y + len);
                paint1(g, (int) Math.round(len * 0.33), x - len, y + 0);
                paint1(g, (int) Math.round(len * 0.33), x + 0, y - len);

                paint1(g, (int) Math.round(len * 0.33), (int) (x + len * Math.sqrt(2) / 2), (int) (y + len * Math.sqrt(2) / 2));
                paint1(g, (int) Math.round(len * 0.33), (int) (x - len * Math.sqrt(2) / 2), (int) (y + len * Math.sqrt(2) / 2));
                paint1(g, (int) Math.round(len * 0.33), (int) (x + len * Math.sqrt(2) / 2), (int) (y - len * Math.sqrt(2) / 2));
                paint1(g, (int) Math.round(len * 0.33), (int) (x - len * Math.sqrt(2) / 2), (int) (y - len * Math.sqrt(2) / 2));
            }
        };
        jp.setBackground(Color.RED);
        jp.setPreferredSize(new Dimension(800, 800));
        jf.add(jp);
        jf.pack();

        jf.setVisible(true);
    }

🙂

 

[Xyz1]

Frag mich jetzt bitte nicht, wie man den Fensterrahmen rot färbt oder das Icon ersetzt. 😀

Ich schau gerade, durch Symmetrieüberlegungen und Schleife hast du ein besseres Ergebnis erreicht als ich. 🙂

 

[Xyz1]

Schaut eine Schneeflocke so:

Ich meine, das waren immer Hexaeder ...
https://de.wikipedia.org/wiki/Kubisches_Kristallsystem
https://de.wikipedia.org/wiki/Natriumchlorid-Struktur
Bearbeitung: Ikosaeder!

 

[bob651]

oh, nice. dein code ist ja ez zu verstehen. Danke man.
soll ich jetzt deinen nehmen oder meinen code? 😀

die frage ist, wieso rot als background xD

 

[Xyz1]

die frage ist, wieso rot als background xD

Einfach so, es geht auch schwarz und weiß oder kein background (grau und schwarz). 😀 Einfach, was gut zu erkennen ist. 🙂

Wenn du keinen Logischen Fehler gemacht hast, ist das in einer Schleife etwas eleganter.

 

[Xyz1]

Du musst auch mal schauen, wie du das übersichtlich aufbaust,

            void paint1(Graphics g, int len, int x, int y) {
                if (len < (int) min.getValue()) {
                    return;
                }

                //g.drawOval(x - len, y - len, len * 2, len * 2);
                int x1 = x + 0;
                int x2 = x + len;
                int x3 = x - len;
                int x4 = (int) Math.round(x + len * Math.sqrt(2) / 2);
                int x5 = (int) Math.round(x - len * Math.sqrt(2) / 2);
                int y1 = y + 0;
                int y2 = y + len;
                int y3 = y - len;
                int y4 = (int) Math.round(y + len * Math.sqrt(2) / 2);
                int y5 = (int) Math.round(y - len * Math.sqrt(2) / 2);
                int f = (int) Math.round(len * ((double) faktor.getValue()));

                g.drawLine(x1, y2, x1, y3);
                g.drawLine(x2, y1, x3, y1);
                g.drawLine(x4, y4, x5, y5);
                g.drawLine(x4, y5, x5, y4);

                paint1(g, f, x2, y1);
                paint1(g, f, x1, y2);
                paint1(g, f, x3, y1);
                paint1(g, f, x1, y3);
                paint1(g, f, x4, y4);
                paint1(g, f, x5, y4);
                paint1(g, f, x4, y5);
                paint1(g, f, x5, y5);
            }

so gibt's bei mir keine Rundungsfehler,

aber wirklich ... Ich verliere bei sowas Überblick ... Math.sqrt(2) / 2 lässt sich vielleicht schreiben als Math.sqrt(1.5) !!! Aber du siehst, große Unwissenheit 🙁

Ist aber auch Wurscht, schöne Weihnachten !!!![/code]

 

[bob651]

Schöne Weihnachten dir auch xD