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