Tag Archives: organic

Automata

conesnail
Image credits: Conus Textile (da Wikipedia). Il pattern del guscio é generato con meccanismi che ricordano quelli degli automi cellulari, cioé ogni cellula secerne pigmento a seconda dello stato di attività delle cellule adiacenti.

Ho indagato sull’ offscreen buffer di Processing, ed in particolare su come lo si può usare per ottenere e manipolare immagini generate a runtime. Con l’oggetto PGraphics e i metodi beginDraw() ed endDraw(), è possibile disegnare (anche in 3D) fuori dallo schermo, e poi usare l’immagine ottenuta per eseguire ulteriori calcoli e/o applicare effetti e usarla come fosse una qualsiasi immagine da visualizzare a schermo; in realtà pGraphics si usa molto spesso per l’output ad alta risoluzione da Processing (per es. immagini TIFF da 3000 px di larghezza), ma in questo caso, ho utilizzato questi buffer (nel mio caso sono 6, 251 px di lato) per disegnare una serie di patterns per mezzo di un automa unidimensionale. Gli automi sono molto interessanti perchè a dispetto della loro apparente semplicità producono risultati inaspettati e sorprendenti; frattali, automi, L-systems e in genere tutte le funzioni ricorsive governate da ‘regole’ servono a comprendere e spiegare i modelli morfologici di una grande varietà di organismi del mondo che ci circonda; in computer graphics quindi, questa serie di algoritmi e regole rappresentano l’unica via per poter simulare efficacemente organismi complessi, come le piante.

cautomata
Elementary Cellular Automaton http://www.openprocessing.org/visuals/?visualID=8207 – GC Mingati

Un Cellular Automata (CA) di tipo unidimensionale é un sistema composto da griglie di celle e regole che definiscono le modalità di comportamento di ogni cella, per ogni nuova generazione, a seconda dello stato (colore) dei suoi vicini. In altre parole, supponendo di avere una riga di 3 pixel posti orizzontalmente ed il pixel di mezzo bianco con gli altre due vicini neri, possiamo stabilire, di generazione in generazione quale sarà il colore risultante da questa condizione di vicinato. Avremo quindi una nuova condizione, a cui applicare una nuova regola. E così via. Ci sono 8 possibili configurazioni di vicinato da cui scaturiscono 256 possibili regole.

Nella Applet ho usato l’oggetto PGraphics per disegnare un automa su ogni faccia. Una volta completato il render delle facce, potete premere ‘r’ da tastiera per disegnare nuovi pattern.

noise

screen0499
screen0211
pnoise3d
Perlin noise visualization. http://www.openprocessing.org/visuals/?visualID=8172 – GC Mingati

La funzione noise() é comoda per generare una serie di numeri in successione con casualità controllata; la tecnica inventata da Ken Perlin negli anni ‘80 é stata spesso usata in computer graphics per imitare l’ apparente randomicità delle textures in natura o per riprodurre terreni, forme ecc. In queste immagini, si può vedere come il ‘Perlin noise’, influenzando la velocità delle particelle rosse, faccia variare il moto delle stesse ammassandole in forme sinuose che ricordano i vasi sanguigni e i meandri dei fiumi visti da grande altitudine. Nella Applet, ho aggiunto attrito e gravità orizzontale per influenzare ulteriormente questo ordine aggiungendo disordine; ne é derivato un caos su cui ho voluto indagare qualche ora.

Tentacles

tent01
tent02
tent03

Investigando ulteriormente nella modellazione di coni e clindri al fine di poter generare alberi realistici, ho preso (come é naturale se si usa Processing) tutta un’altra strada; per realizzare ciò che avevo in mente avevo due problemi da risolvere: (1) orientare un oggetto nella direzione di un punto in continuo movimento e/o generato randomicamente e (2) scrivere una funzione di branching per i rami. Il punto 1 mi sembrava ragionevolmente semplice da risolvere, ma ben presto mi sono reso conto che non lo era affatto. Il punto 2, senza aver risolto il punto 1 era inutile affrontarlo. Grazie all’aiuto di Dave Bollinger però ho potuto fare il reverse-engineering del codice che descrive le coordinate sferiche ed in particolare, dato un punto iniziale ed uno finale, trattarli come fossero il centro ed un punto sulla superficie di una sfera e quindi calcolare raggio e rotazione sugli assi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Let particle b coords be the desired base center, and particle a coords be the desired top center.
Particle a;
Particle b;
//If that's where the center of the base stays, then the center of the top needs to end up at:
PVector c = new PVector(a.position().x()-b.position().x(),a.position().y()-b.position().y(),a.position().z()-b.position().z());
float h = dist(0,0,0,c.x,c.y,c.z);
//then define the radius
float r = sqrt(pow(c.x,2)+pow(c.y,2)+pow(c.z,2));
float theta = atan2(c.y,c.x);
float phi = acos(c.z/r); //thank you Dave!
pushMatrix();
//now translate to b position
translate(b.position().x(),b.position().y(),b.position().z());
//and rotate the new tentacle segment
rotateZ(theta);
rotateY(phi);
rotateX(-HALF_PI);
//Segment to rotate
popMatrix();

Queste poche righe, in Processing permettono di ruotare un qualsiasi oggetto nella direzione definita da un altro sistema di coordinate; se volete usarlo per i vostri esperimenti, troverete la Applet corredata di classi nel link sotto al video, o anche qui; col mouse e tasto sx premuto potete ruotare la bestia, e avvicinarvi ed allontanarvi col tasto dx.

Tentacles.
Il mostro é nato perchè una volta trovato il modo di orientare i nuovi coni verso la direzione voluta, ed avendo definito ognuno dei due punti di ancoraggio del cono (centro della circonferenza inferiore e centro della circonferenza superiore) con altrettante particelle unite da una spring (una molla), ecco che variando le distanze variava la lunghezza del cono ed anche (per via del ‘molleggio’ e qualche altro parametro) la rotazione. E’ stato un attimo creare tentacoli. Le particelle e le springs sono realizzate con la libreria per Processing traer.physics la quale permette anche – dato un sistema di particelle – di definire una gravità sui 3 assi ed un attrito. Applicando attrito, una gravità negativa sull’asse y, una differente massa per ogni particella del tentacolo (crescente verso la parte più lontana dalla base) ed una gravità che varia continuamente tra -1 ed 1 sull’asse x, ecco che i tentacoli hanno iniziato a muoversi sinuosamente e l’effetto finale é davvero naturale. Ho aggiunto una texture ‘urticante’ et voilà: Tentacles. Una bestia velenosissima – in genere le creature marine con colori sgargianti sono sempre velenose.

magTentacle http://www.openprocessing.org/visuals/?visualID=7207 – GC Mingati

anemone

Lavorando sul concetto dello steering vector (così ricavabile: ‘desired_velocity’ minus ‘velocity’) – un algoritmo ideato alla fine degli anni 80 da Craig W. Reynolds per far muovere in maniera automatica e pseudo-naturale degli oggetti (characters) nel loro mondo digitale implementando strategie per cercare, muoversi, arrivare, seguire, scappare, seguire un percorso, evitare ostacoli… insomma una sorta di intelligenza artificiale che facesse sembrare ‘vivo’ e in grado di prendere decisioni un character – sono arrivato a creare questo mostriciattolo, una sorta di anemone/medusa.

Senza entrare troppo nei dettagli che comunque potete leggere qui, qui e dal sorgente, ci basti sapere che per ottenere questo movimento ‘organic-like’ dei tentacoli del nostro anemone marino, ho applicato il metodo dello steering vector ad una serie di particelle contenute in 110 ArralyList (s) (particle Systems) con differente massa; il metodo riceve in input un vettore target (un punto x,y) e ritorna una ‘forza’ vettore steer (sterzante) che fa muovere in quella direzione l’oggetto. Poichè la chiave qui è la velocità col quale le particelle si muovono verso il target e visto che hanno massa differente, avremo le parti tonde dei tentacoli (più pesanti) che vi arrivano dopo e quelle più leggere che vi arrivano prima… inoltre usando una semplice sinusoide ecco che l’anemone sembra ‘pulsare’ ed in più ogni ‘tentacolo’ (il singolo particle system fatto di 100 particelle) ruota a partire dalla sua posizione iniziale.

Il bello di Processing, come direbbe Robert Hodgin è che non hai mai idea di dove ’sei diretto’ mentre lavori, cioè, le cose prendono forma mentre scrivi codice e magari parti con un’idea e alla fine ottieni un’altra cosa. Volete sapere a cosa stavo lavorando? Volevo simulare i coronal loops del sole, cioè quegli sbuffi di materia/plasma che si possono osservare sul sole se lo si osserva durante un’eclisse. Poi mi sono reso conto che la versione 2D già realizzata non poteva essere migliorata (a livello di prestazioni) se non facendola divenire 3D con opengl e quindi ho ‘ripiegato’ su quest’altro progetto.