Monthly Archives: January 2010

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

Web Design All-in-One For Dummies

web design all in one for dummiesQualche mese fa, Sue Jenkins (Luckychair) mi ha chiesto il permesso – prontamente accordato – per poter pubblicare sul suo libro di prossima uscita “Web Design All-in-One For Dummies“, in una sezione relativa alla creazione di gallerie di immagini, un tutorial su slideViewer – il mio famigerato quanto semplice (per dummies?) jQuery plugin; il libro è uscito, e alle pagine 447-449 (Chapter 8 > Creating slide shows) si parla proprio del mio plugin e di come costruire una galleria di immagini per il proprio sito. Sono piccole soddisfazioni, ma questo dimostra quanto alla fine, lavorare ‘per gli altri’ porti sempre buoni frutti.

pineTree forest

Innanzi tutto, felice 2010.

Sarà stata l’aria di Ortisei, la neve e i boschi ma da quando sono tornato ho in mente di voler realizzare degli alberi con Processing. Ho creato una versione molto semplificata e stilizzata di un pino (per il momento é quanto sono riusciuto a pensare con qualche ora di tempo libero) ma ammetto che per realizzare forme convincenti c’è molto da approfondire sulle strutture geometriche e matematiche costruite dalla natura – in particolare sui frattali. Si può trovare qualche compromesso, probabilmente, ma ritengo interessante cercare di riprodurre il pattern col quale si dispongono e suddividono i rami nelle piante. Si lo so, non ci siamo. Almeno non al primo sketch.

forest

Per creare questi alberelli ’simil-Lego’ ho pensato di partire disegnando un tronco principale (una linea posizionata randomicamente e con altezza casuale, il cui spessore diminuisce mentre si sale) e dei rami, anche questi con spessore e lunghezza decrescente.

forest02

Per i rami ho quindi semplicemente disegnato delle rette le cui coordinate esterne x e z (come fosse solo in 2D) fossero: x = initPos.x + radius * cos(theta); z = initPos.z + radius * sin(theta); qui PVector initPos contiene le coordinate x, y, z del tronco; radius è la lunghezza del ramo, e diminuisce mentre si sale. In pratica non ho fatto altro che calcolare alcuni dei punti che descrivono una serie di cerchi con raggio decrescente e poi ho usato tali coordinate per descrive l’ancoraggio del secondo punto (quello esterno) dei rami (i punti iniziali sono gli stessi del tronco). Salendo con la y (-y) ecco che i rami vengono wrappati attorno al tronco e divengono sempre più corti, fino alla cima, dove radius è 0. Il codice dello sketch e la Applet li trovate nel link sotto al video (il risultato finale è abbastanza gradevole).

recursive tree
Recursive Tree. Rendered with p5sunflow lib – GC Mingati

Ecco invece una versione in cui rami e tronchi sono formati da coni/cilindri. Questo mi permette di ottenere un effetto 3D pieno e – se riesco – texturizabile; ma quello che appare subito evidente é che usando una funzione ricorsiva si ottengono rapidamente più rami (una funzione ricorsiva richiama se stessa fino a quando una data condizione non viene raggiunta – in questo esempio un numero di 5 cicli). Anche questo esempio é visibile sotto forma di Applet a questa url, ma credo dovrò cambiare radicalmente modalità di generazione: la ricursività non soddisfa la randomicità di forma/lunghezza che desidero poichè in realtà i rami nascono ruotati randomicamente sugli assi Z ed X solo alla prima generazione; i rami più piccoli sono copie rimpicciolite dei primi e non sono riuscito a trovare un modo per allontanarli dai loro ’simili’; credo però che aggiungendo una forza magnetico-repulsiva ad ogni ramo eviterò che essi si sovrappongano (al momento è inevitabile) e probabilmente avranno una forma più naturale.

pineTree forest http://www.openprocessing.org/visuals/?visualID=6824 – GC Mingati

Anche quest’anno quindi parecchi progetti da realizzare – alcuni ancora troppo complessi visti i miei skills attuali e per il tempo che richiedono (terreni 3D, alberi, flocking e piante mosse dal vento) e altri certamente più ‘alla portata’ (approfondire Struts e lo sviluppo delle apps J2EE) ma tutti comunque necessiteranno di costanza ed impegno. Ho un anno a diposizione, e Saturno contro…