La curva del matematico svedese Helge von Koch,è una delle prime curve frattali di cui si conosca una descrizione(1904).

Il mio metodo e i parametri:

        /// <summary>

        ///  public void curvaC(int dimensione, int livello)

        /// </summary>

        /// <param name="dimensione"></param>

        /// <param name="livello"></param>

 

Wacław Franciszek Sierpiński (14 marzo 1882 - 21 ottobre 1969) fu un matematico polacco che studiò questo particolare frattale.

       Il mio metodo e i parametri:

        /// <summary>

        /// void triangolo_ricorsivo(int dimensione, int tratto)

        /// </summary>

        /// <param name="dimensione"></param>

        /// <param name="tratto"></param>

il metodo è ricorsivo (richiama se stesso per tre volte e usa un angolo di 120°)

 /// <summary>

        ///metodo albero_simmetrico(int lunghezza,int livello)

        /// </summary>

        /// <param name="lunghezza"></param>

        /// <param name="livello"></param>

        #region//albero_simmetrico(int lunghezza,int livello)

public void albero_simmetrico(int lunghezza, int livello)

       

        

public void albero_simmetrico_nocolor(int lunghezza, int livello)

       

       

public void albero_simmetrico2(int lunghezza,int angolo1,int angolo2, int livello,int tratto,int value)

        

 Per queste immagini ho programmato in linguaggio C# / WPF che implementa e usa il logo. 

ho usato il mio metodo:

       public void nome metodo (int ripeti, int ripetizione, int lato,int livello, int tratto, int value, bool attivo)

Le righe di seguito definiscono il valore dei due angoli, parametri del secondo metodo

Random tt = new Random();

            int angolo1 = tt.Next(1, 360);

            int angolo2 = tt.Next(1, 360);

 contiene tre cicli for annidati con vari compiti, di cui il terzo al suo interno richiama :

public void nome metodo(int lunghezza,int angolo1,int angolo2, int livello,int tratto,int value)

Il metodo contiene la vera geometria ad albero.

Il parametro livello è quello che definisce la complessità dell'albero.

    

"Pluristelle"Strutture ad albero e rotazioni

 Per queste immagini ho programmato in linguaggio C# / WPF che implementa e usa il logo. 

Il metodo si occupa di definire il punto di partenza, in questo caso centrale, sceglie il colore di fondo e ripete più volte con un ciclo for la chiamata ad un secondo metodo.

Il secondo metodo definisce il colore del pennino (pen),usa la tartaruga (turtle graphic) sceglie, richiamando un'altro metodo, tre immagini da un set personale e una geometria (cerchio, ellisse, quadrato o rettangolo)

I tre metodi concatenati:

public void nome_metodo (int ripetizione, int ripeti, int tratto,int scala,int modalità, int numpic,int numpic2,int numpic3,int value_color,int value_fondo)

{ righe di programma }

/// <summary>

        /// 

        /// </summary>

        /// <param name="ripetizione"></param>

        /// <param name="ripeti"></param>

        /// <param name="tratto"></param>

        /// <param name="scala"></param>

        /// <param name="modalità"></param>

        /// <param name="numpic"></param>

        /// <param name="numpic2"></param>

        /// <param name="numpic3"></param>

        /// <param name="value_color"></param>

        /// <param name="value_fondo"></param>

public void nome_metodo2(ripeti, tratto,scala,modalità, numpic,numpic2,numpic3,value_color)

{ righe di programma }

/// <summary>

        /// 

        /// </summary>

        /// <param name="ripeti"></param>

        /// <param name="tratto"></param>

        /// <param name="scala"></param>

        /// <param name="modalità"></param>

        /// <param name="numpic"></param>

        /// <param name="numpic2"></param>

        /// <param name="numpic3"></param>

        /// <param name="value_color"></param>

 public void nome_metodo3 (int caseSwitch)

{ righe di programma }

 

 /// <summary>

        /// 

        /// </summary>

        /// <param name="caseSwitch"></param>

 

 Hilbert (1862-1943) 

Il matematico, studiò una curva tramite un processo iterativo che finisce per riempire l'intero quadrato di lato unitario.

Nel caso dello schermo ovviamente per avere il riempimento, il quadrato esce dai limiti dello stesso.

Curva di Hilbert il mio metodo:

 

//hilbert_monocromatico(2, 8, 1, 100/4, 90, 2,blu_acquamarina);//Hilbert tipico

I miei metodi [1] usano la curva di Hilbert, ma al termine di ogni passo viene disegnata o un'immagine da una mia libreria o una forma geometrica, ovvero ambedue le cose.

Le chiamate ai metodi, sono tutte disattivate da una doppia barra obliqua (slash //) la chiamata, (rappresentata per riconoscerla in blu), senza doppia barra obliqua (slash //) è invece attiva questo mi permette di scegliere cosa far fare al programma.

In fase di lavoro posso modificare i valori dei parametri per la ricerca di diverse configurazioni delle immagini risultanti, per colore, forma, angoli, ecc.

Spesso con un'unica chiamata, sono riuniti più metodi e spesso un metodo può richiamare se stesso.

//-----------curva di hilbert-----------------------------------------------------------------------------------

                

                ///PARAMETRI:

                /// <summary>

                /// 

                /// </summary>

                /// <param name="dimensione"></param>

                /// <param name="livello"></param>

                /// <param name="parità"></param>

                /// <param name="lunghezza"></param>

                /// <param name="angolo"></param>

                /// <param name="tratto"></param>

                /// <param name="colore"></param>

                /// <param name="vero"></param>

                //hilbert(1500, 300, 2, 28, 91,6,true,false);

                //hilbert(200, 200, 1, 620, 77,5,false,true);

                //hilbert(200, 200, 1, 200, 61, 2,true,false);

                //hilbert(200, 200, 4, 40, 80, 9,false,true);

                //hilbert(200, 200, 1, 50, 100,1,true,false);

                //hilbert(200, 200, 1, 300, 115, 10,false,true);             

                //hilbert(1500, 14, 1, 15, 90,24,true,false);

                //hilberth(2, 8, 1, 15, 90, 6, true, false);

                //--------------------------------------------------------------------------------------------------

                //hilbert_riempimenti(100, 100, 1, 190, 90,90,1,true,false,true);

                //hilbert_riempimenti(100, 100, 1, 50, 120, 120, 1, true, false,true);

               

               //hilbert_monocromatico(2, 8, 1, 100/4, 90, 2,blu_acquamarina);//Hilbert tipico

                //hilbert_variazioni(2, 8, 1, 6 , 90, 2, true, 3, 6, 9,true);               

                //hilbert_immagini(2, 8, 1, 70, 90, 2, false,true,1,1,1,43,53);

                //hilbert_immagini(2, 8, 1, 70, 94, 2, false, true, 1, 1, 1, 20, 30);

                //hilbert_immagini(2, 8, 1, 70, 90, 2, false, true, 1, 1, 1, 30, 31);

                //hilbert_alfabeti(1112, 8, 1,30, 90, 2, false, true, 1, 1, 1, 1, 28);

                //hilbert_alfabeti(1112, 30, 1, 25, 90, 2, true, false, 1, 1, 1, 1, 28);

                //****************************************************************

                  hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 7, 7);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 6, 6);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 5, 5);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 4, 4);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 3, 3);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 2, 2);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 1, 3);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 1, 5);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 1, 10);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 30, 33);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, false, 1, 1, 1, 35, 45);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 20, 30);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 25, 25);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 22, 22);

                //hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 35, 35);

                

                /// <summary>

                /// 

                /// </summary>

                /// <param name="dimensione"></param>//numero iterazioni

                /// <param name="livello"></param>//livelli di complessità

                /// <param name="parità"></param>parità * angolo

                /// <param name="lunghezza"></param>lunghezza lato

                /// <param name="angolo"></param>angolo

                /// <param name="tratto"></param>spessore tratto

                /// <param name="colore"></param>colore della penna

n.b. - colore solido se = true 

         radiale se = false

                /// <param name="invisibile"></param> rende invisibile la penna 

n.b. - penna invisibile se=true

                /// <param name="aaa"></param>lunghezza/aaa

                /// <param name="bbb"></param>lunghezza/bbb

                /// <param name="ccc"></param>lunghezza/ccc

                /// <param name="inizio"></param>inizio immagine

                /// <param name="fine"></param>fine immagine

                 //****************************************************************

//---usa piccoli cerchi o quadrati o rettangoli---------------------------------------------------------------

//hilbert_cerchietti(1112 * 6, 40 * 20, 1, 20, 90, 2, true, true, 1, 1, 1, 35, 41, 40, 40, 90, 90);                

//hilbert_cerchietti(1112 * 6, 40 * 20, 1, 100, 120, 2, true, false, 1, 1, 1, 35, 35, 120, 120, 90, 90);

//hilbert_cerchietti(1112 * 6, 40 * 20, 1, 1, 144, 2, true, false, 1, 1, 1, 35, 35, 120, 120, 14, 14);                      //***************************************************************

[1] Con il termine "metodo"si intende un blocco di codice che contiene una serie di istruzioni.

[2] nel programma "Hilbert" è minuscolo, perché non uso in genere maiuscole nel nome del metodo

hilbert_tasselli(1112 * 6, 40 * 20, 1, 20, 90, 22, true, true, 1, 1, 1, 7, 7);il metodo richiama le immagini con il metodo public void random_pic2(int inizio, int fine) passando gli ultimi due parametri interi: 

(inizio, fine) che richiamano le immagini dalla libreria, una sola se uguali, da numero a numero se diversi

 

 Per queste immagini ho programmato in linguaggio C# / WPF che implementa e usa il logo.

Ho realizzato vari metodi, basati sulla Spirale di Archimede, è possibile assegnare come input parametri diversi: colore, filling ( valore boleano true or false), numero di cicli, angolo usato, punto iniziale sullo schermo ( "Panel" in WPF) centrale o random. 

possibili parametri:

        

/// <summary>

        /// 

        /// </summary>

        /// <param name="ripeti"></param>

        /// <param name="tratto"></param>

        /// <param name="scala"></param>

        /// <param name="modalità"></param>

        /// <param name="numpic"></param>

        /// <param name="numpic2"></param>

        /// <param name="numpic3"></param>

        /// <param name="value_color"></param>

Lo stesso metodo con uso di geometrie vedi esempi.

esempi usando la classe: class System.Windows.Media.Geometry: 

Derivato

System.Windows.Media.CombinedGeometry

System.Windows.Media.EllipseGeometry

System.Windows.Media.GeometryGroup

System.Windows.Media.LineGeometry

System.Windows.Media.PathGeometry

System.Windows.Media.RectangleGeometry

System.Windows.Media.StreamGeometry

 

          Geometry ellisse = new EllipseGeometry(new Rect(0, 0, 50, 50));            Cerchio

          Geometry ellisse = new EllipseGeometry(new Rect(0, 0, 10, 50));            Ellisse

 

Geometry rectangle= new RettangleGeometry(new Rect(0, 0, 50, 50));    Quadrato

          Geometry rectangle= new RettangleGeometry(new Rect(0, 0, 10, 50));    Rettangolo