venerdì 22 marzo 2024
giovedì 21 marzo 2024
venerdì 1 gennaio 2021
Dal mio programma Automat 2021
Il metodo public void rosa_caratteri_filling() richiama al suo interno più volte il metodo ramificazioni_a_stella_caratteri(20, 150, 90,1,true); variando solo il terzo parametro, che è un angolo, che determina la rotazione della tartaruga, il metodo fa uso dei caratteri di punteggiatura(,.'/"ecc.) ed il filling è impostato come "vero"(true).
#region//rosa_caratteri_filling()
public void rosa_caratteri_filling()
{
ramificazioni_a_stella_caratteri(20, 150, 90,1,true);
ramificazioni_a_stella_caratteri(20, 150, 24, 1, true);
ramificazioni_a_stella_caratteri(20, 150, 31, 1, true);
ramificazioni_a_stella_caratteri(20, 150, 120, 1, true);
ramificazioni_a_stella_caratteri(20, 150, 60, 1, true);
ramificazioni_a_stella_caratteri(30, 150, 70, 1, true);
ramificazioni_a_stella_caratteri(30, 150, 54, 1, true);
ramificazioni_a_stella_caratteri(30, 150, 21, 1, true);
ramificazioni_a_stella_caratteri(30, 150, 144, 1, true);
ramificazioni_a_stella_caratteri(30, 150, 75, 1, true);
}
#endregion
Il metodo public void rosa_caratteri_no_filling() richiama al suo interno più volte il metodo ramificazioni_a_stella_caratteri(20, 150, 90,1,false); variando solo il terzo parametro, che è un angolo, che determina la rotazione della tartaruga, il metodo fa uso dei caratteri di punteggiatura(,.'/"ecc.) ed il filling è impostato come "falso"(false).
#region//rosa_caratteri_no_filling()
public void rosa_caratteri_no_filling()
{
ramificazioni_a_stella_caratteri(20, 150, 90,1,false);
ramificazioni_a_stella_caratteri(20, 150, 24, 1, false);
ramificazioni_a_stella_caratteri(20, 150, 31, 1, false);
ramificazioni_a_stella_caratteri(20, 150, 120, 1, false);
ramificazioni_a_stella_caratteri(20, 150, 60, 1, false);
ramificazioni_a_stella_caratteri(30, 150, 70, 1, false);
ramificazioni_a_stella_caratteri(30, 150, 54, 1, false);
ramificazioni_a_stella_caratteri(30, 150, 21, 1, false);
ramificazioni_a_stella_caratteri(30, 150, 144, 1, false);
ramificazioni_a_stella_caratteri(30, 150, 75, 1, false);
}
#endregion
sabato 24 ottobre 2020
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
(inizio, fine) che richiamano le immagini dalla libreria, una sola se uguali, da numero a numero se diversi
 |
Iscriviti a:
Commenti (Atom)