Ecco, nello scorso post dicevo che forse sarebbe valsa la pena di proseguire la ricerca nel campo dei ‘pixel’ per arrivare ad una specie di word processor che usa questo sistema di particelle per comporre i caratteri a video; una prima Applet corredata di sorgente è visualizzabile qui ed in questo video. Per ora ha un bug: non posso cancellare i caratteri e c’è un problema con l’ultima lettera a dx.
Esigenza: trovare un modo per spostare dei punti (istanze di una ipotetica classe con proprietà relative a massa, accelerazione, velocità e posizione e relativo moto e forze - da qui l’effetto ‘organico’ se si usano sempre Vettori per muovere un punto) verso un determinato altro punto. Esiste in processing un metodo statico (get(x,y)) per ricavare il colore e (per come esso viene ricercato) la posizione x y del suddetto pixel (con un doppio loop per popolare un Array 2D).
Ipotizzando di avere una scritta o una forma all’occhio non visibile - perchè renderizzata con un canale alpha troppo basso, ma sufficiente ad essere rilevato come un valore rgb (es. 122545) - ecco che di conseguenza si può (sopratutto) conoscere quella posizione in coordinate cartesiane xy; da qui ho voluto - con la solita classe dei precedenti esperimenti che però appena sono creati vengono solo accelerati verso un altro punto - creare delle istanze che sanno - anche - quale è la loro origine, cioè per ognuna una posizione ‘originaria’ espresa in x ed y alla quale si può ‘tornare’ magari premendo un tasto.
Più o meno è questo il concetto di base e comunque il codice è visualizzabile in questa pagina insieme alla Applet. Premendo un tasto, tutte si spostano verso la loro origine perchè viene applicata una accelerazione verso quel punto; tutte insieme danno origine ad una forma o come in questo caso, del testo. Ma potrebbbe essere il solo colore nero di una qualsiasi foto, non visibile all’occhio ma scannerizzata pixel per pixel da una più evoluta classe Pixel(x, y, color, mass etc)…
Il prossimo step (e su questo progetto forse vale la pena spendere qualche ora) sarebbe di far andare le particelle in una certa direzione che viene impostata in tempo reale, cioè caratteri che si formano mentre si scrive sulla tastiera … E se pò fà…
Ah un’ultima nota su Processing. Ovviamente per quasi qualsiasi applicazione scriviate e certamente per tutte quelle che hanno un otput video, c’è sempre la possibilità (per default, solo importando una delle librerie presenti nel pacchetto) di fare un movie quicktime della grandezza che la vs macchina permette di generare come questo (QT movie 19.729 Kb) in tempo reale mentre la vostra applicazione gira nel suo IDE oppure gererare jpg, png, tiff e pdf.
Emitter series, realizzati con Processing; qui trovate la Applet ed il sorgente della prima versione. Di questa seconda versione, denominata IR1916 (come la galassia a noi più lontana, circa 120 milioni di anni luce dalla Terra) ho caricato il file .mov su Vimeo; purtroppo la compressione non risparmia i singoli pixel in movimento - che sono il particolare che ho cercato e ricercato - e per questo consiglio di scaricare il .mov originale nel portfolio (se scrollate, lo trovate); ho comunque estratto alcuni frames dai quali si nota come l’uso del perlin noise fà sì che si formino delle textures durante la generazione delle particelle e anche per spiegare i concetti di base che governano la colorazione di questo Emitter. mò, con due minuti lo spiego…
Il mio secondo sketch fatto con processing. magnet-ink.
In modalità HSB i colori sono distribuiti su una gamma di 360 possibilità (H), poi c’è la saturazione (S) con scala da 0 a 100 e lo stesso vale per la luminosità (B). Con questo nuovo sketch continuo la mia esplorazione della classe Vector3D: un campo gravitazionale (in realtà è un nuovo vettore di coordinate, e al click calcoliamo la differenza di posizione tra il mouse e tutte le particelle) è creato dal mouse e l’effetto di tavolozza magnetica è dato dal fatto che i colori vengono creati in base alla posizione delle due stecchette da 3px bianche poste a sx e dx dello schermo; tali colori sono strettamente connessi con la massa (in realtà è una doppia mappatura cioè colore in base all’indicatore e massa in base all’indicatore).
L’accelerazione verso il mouse è: accelerazione = Forza / Massa e siccome la massa è variabile, i rossi saranno sempre prossimi al mouse (attratti con più forza e, una volta rilasciati più soggetti all’attrito) e i blu essendo più pesanti arrivano ‘dopo’ verso il mouse e l’attrito li ferma dopo, anche. E ‘ normale, se prendete due biglie di ferro una da 1Kg e l’altra da 1/2 Kg e le lanciate lungo un piano, quella più pesante a parità di velocità iniziale, si fermerà dopo.
Ho distribuito i 360 colori in rapporto all’altezza dello schermo (mi sembrava più semplice ) e sempre in base alla posizione delle due stecchette (li chiameremo indicatori), la particella nascente viene anche dotata di una massa (più è alto l’indicatore verso il punto y=0, meno massa ha la particella). E così progressivamente dall’alto verso il basso le particelle hanno colore e massa differente. Quelle rosse, create in alto avranno massa leggerissima quelle in mezzo (gialle, verdi, azzurre) media e quelle in basso, blu, turchesi, alta.
Ma quante particelle? 35000. Ah. Eh; ho scoperto che in processing, se si usa il renderer P3D, size(800, 600, P3D) si possono applicare calcoli a molte particelle (e anche l’alpha incide sulla smoothness del rendering), ma la cosa che rende possibile il tutto, è l’uso di un ArrayList per craere/distruggere le particelle. Eh si, perchè la tavolozza magnetica magnet-ink ha a disposizione il numero massimo di oggetti definito come limite dell’array (35000). Se una particella tocca il bordo viene eliminata - remove(i) - e crata un’altra al suo posto, in una posizione (quindi con colore, massa e posizione) relativi alla posizione dell’indicatore. Così la tavolozza disegna sempre e soltanto le particelle nuove, rese disponibili sotto forma di nube di particelle colorate con un determinato colore non appena altre escono dallo schermo. Ed escono, poichè c’è un effetto di gravità che trasporta inevitabilmente le particelle fuori dallo schermo, in basso.
Giocateci un pò, io ce posso stare minuti. Un consiglio: fate brevi click col mouse, cercate di mantenere le particelle (tutte) intorno al mouse e poi, in base a dove si trovano gli indicatori (alto o basso) cliccate e muovete il mouse.
Forme che ricordano le esplosioni delle galassie si formeranno in magnet-ink. In più ha un effetto ‘nevicata’ e visto che siamo in periodo…. buone Feste e buona fine e buon inizio!
drawConnections è il mio primo sketch realizzato con Processing, in Java; è quindi una Applet. Si tratta di un modesto esempio di Computational Art: una prima esplorazione della classe (libreria) Vector3D di Daniel Shiffman, per mezzo della quale ho realizzato un piccolo mondo di trenta particelle che sono attratte da due oggetti con forza gravitazionale. Ogni particella, con massa differente, disegna una connessione tra l’una e l’altra se si trova ad una certa distanza. Lo spazio ha un vago attrito, quindi, anche se non si nota poichè le particelle sono solo punti, quelle con più massa (più pesanti) si fermano dopo, quelle più leggere, prima. Alla fine tutte le particelle (ci vuole almeno un minuto) trovano un equilibrio tra i due attrattori, fermandosi al centro dei due campi gravitazionali.
In ogni caso: la forza (o lavoro) = massa * accelerazione, accelerazione = forza/massa, (ed è quello che abbiamo voluto calcolare in questa simulazione) , velocità = velocità + accelerazione, e posizione = posizione + velocità.
package net.gcmingati.jsp.beans;
import java.util.*;
public class RoomBean implements java.io.Serializable {
private static int index = -1;
private List staffNames;
public static void main(String [] args)
{
RoomBean rb = new RoomBean();
rb.getStaffNames();
}
public RoomBean() {
initStaff();
}
public List getStaffNames() {
for (int i=0; i<staffNames.size(); i++)
{
//return (String) staffNames.get(index);
System.out.println((String) staffNames.get(i));
}
return staffNames;
}
private void initStaff() {
staffNames = new ArrayList();
staffNames.add("Gian Carlo Mingati");
staffNames.add("Francesco D.");
staffNames.add("Fabrizio L.");
}
}
Un semplice esercizio con la sintassi Java; con questa classe (o JavaBean), visualizziamo gli elementi di un array (di stringhe) su una pagina JSP (in locale con Jakarta Tomcat) per mezzo dei tags JSTL e del linguaggio di espressione EL.
<jsp:useBean id="stanza" class="net.gcmingati.jsp.beans.RoomBean" />
<ul>
<c:forEach items="${stanza.staffNames}" var="selezione">
<li>
<c:out value="${selezione}"/>
</li>
</c:forEach>
</ul>
E’ che sono stato abbastanza fortunato da poter seguire - obbligatoriamente - un corso di quattro settimane sulla programmazione Object-Oriented, ed in particolare su J2EE (Java Enterprise Edition), ed in particolare sull’utilizzo del framework Java che usiamo qui per sviluppare applicazioni; in partica è Struts 1.2 con una serie di plugins.
Un’esperienza che è giusto definire tale, che ha subito stimolato tutta una serie di considerazioni tra le quali, la più importante è che – con Java si può fare qualsiasi cosa.
Il bello é che comunque i concetti di base sono applicabili a qualsiasi linguaggio di programmazione e una volta che sai cosa vuoi ottenere e sai come scriverlo, il solo limite è la tua fantasia; insomma, passo molto volentieri dalla ricerca sul DOM scripting a quella su come creare applicazioni J2EE basate sul design-pattern Model-View-Controller.
Aaah, finalmente ci siamo tolti di mezzo una parte (seppur minima) di casta, e abbiamo scongiurato il pericolo di un nuovo esecutivo di sinistra. Oggi il verdetto finale delle elezioni in Italia, ma come già si è appreso dal tardo pomeriggio di ieri, il PDL ‘infila’ 171 senatori in parlamento contro i 130 del PD. Già ieri sera si avvicinava un tornado di proporzioni inaspettate, in grado di spazzare via l’arcobaleno e così (finalmente) mettere fuori combattimento la sinistra radicale; - nessun - rappresentante in Parlamento; Bertinotti si dice pronto ad andare in pensione; ieri in TV le sparava davvero grosse (come al solito) della serie “abbiamo fallito perché dalla nostra ‘posizione’ in Parlamento non siamo stati in grado di cogliere le difficoltà e le richieste degli Italiani…” bah sono parole che si commentano da sole. Sarà che siete stati tutti troppo occupati a farvi gli affari vostri?!
In Italia si và affermando il bipolarismo (meno litigi in Parlamento?) e spero vivamente che questo sia l’inizio di un vero processo di trasformazione e modernizzazione di questo Paese. Di seguito riporto la mia wishlist, se questo post sarà ancora visibile (credo di si) fra cinque anni, vedremo i risultati della scelta fatta da gran parte degli elettori.
Se tutti questi punti venissero realmente sviluppati, forse fra cinque anni ci troveremmo con qualche migliaio di clandestini/delinquenti in meno, i conti personali un pò meno in rosso, qualche treno ad alta velocità, qualche milione di tonnellate di CO2 in meno, vedremmo riformato il mercato del lavoro, e quelli che hanno le Ferrari solo grazie ai soldi non versati al fisco andare in giro con la Punto a Metano.
Update 28/04/2008
Gianni Alemanno Sindaco della Capitale.
La voglia di ordine, sicurezza e cambiamento da parte dell’elettorato ha spazzato via l’equilibrio impossibile di una Capitale in bilico fra magìe cinematografiche e periferie abbandonate a se stesse.
Entries (RSS) - Powered by WordPress - Hosting provided by (mt)
