Lo scopo di questo tutorial è quello di capire come è possibile creare immagini del genere, usando come base di partenza dei temi fotografati nella vita reale (muri, pavimenti, roccie, etc…) ed effettuare le trasformazioni necessarie con pochi strumenti e senza ricorrere a particolari software per la generazione procedurale (che in questo caso non servono proprio a niente).   (screenshot preso dal sito http://cgtextures.com/)

Come esempio pratico partiremo da una foto priva di loop presa dal sito http://cgtextures.com/, dentro il quale potrete trovare molte immagini di questo tipo. L’immagine si presenta inizialmente in questo modo:

Costruiamo una seconda immagine di dimensioni doppie in altezza e larghezza, ed accostiamo la texture in modo da evidenziare la totale mancanza di loop:

Adesso l’unica cosa da fare è ritagliare all’interno di questa immagine un rettangolo di dimensioni pari quelle della texture di partenza, in modo da ottenere una seconda texture sulla quale sarà necessario lavorare da questo momento in poi:

E’ meglio se non fate copia e incolla del rettangolo, ma continuate a lavorare all’interno della parte evidenziata in viola, perchè potrebbe essere necessario dover ritagliare alcuni pezzi che giacciono proprio sul bordo evidenziato. Per eliminare quella percezione di tassellamento è necessario fornire una continuità naturale all’immagine lavorando sul bordo di discontinuità (non quello viola!) con le diverse tecniche messe a disposizione dal programma di grafica che usate ed individuando, se è il caso, degli elementi naturali all’interno dell’immagine (come un mattone, una pietra, un teschio, etc…) da ritagliare e incollare sul bordo, per poi fonderlo in un secondo momento con altri effetti grafici. Il primo passo è formare un’immagine con discontinuità sempre meno evidenti operando una sorta di collage, come suggerito dalla seguente figura:

Una volta che avrete reso i bordi meno discontinui, potete passare alla fase di ritocco durante la quale potete fondere gli elementi per eliminare le imperfezioni di questo collage di ritagli. Se state usando il paint shop pro vi consiglio un effetto di smudge, da applicare a mano nei punti critici come nel seguente esempio:

Alla fine del lavoro, se avete proceduto correttamente, dovreste ottenere il risultato mostrato qui di seguito:

che mantiene un perfetto loop orizzontale e verticale:

Conclusioni

Come abbiamo visto la creazione di texture fotorealistiche è veramente semplice, non richiede software di fotoritocco particolarmente complessi ne eccessive tribolazioni da parte di chi le realizza. L’importante è cercare di ottenere una certa continuità nell’immagine finale evitando di usare sempre lo stesso sistema o produrre delle immagini visivamente antiestetiche, come l’orrendo effetto di mirror ai bordi usato spesso nei videogiochi oppure la perdità della ruvidità usata dai grafici inesperti per diminuire la definizione del taglio. Per la verità esistono in rete dei programmi per la creazione automatica di questo tipo di texture, ma li sconsiglio caldamente perchè un risultato esteticamente perfetto lo si può ottenere solo con l’esperienza manuale di un essere umano: l’immagine oggetto di questo tutorial è perfetta ed è stata realizzata dal sottoscritto in meno di 5 minuti, quindi non esiste la reale necessità di usare un software dedicato. Ho usato un’immagine già presente in un sito, ma avrei potuto fotografare un muro vicino casa oppure la facciata di un palazzo, questa tecnica non presenta limiti e può essere usata per comporre qualsiasi tipo di ambientazione fotorealistica.

©2008 Gianpaolo Ingegneri

Se è mia intenzione fare un editor di testo, devo necessariamente ottenere il codice ascii per ogni rispettivo tasto premuto nella tastiera, dato che il virtual key non può essere gestito direttamente. Ho notato che in rete non circola granchè al riguardo e che la guida msdn è così confusa e superficiale da far venire i brividi, per questo motivo ho deciso di pubblicare questo piccolo listato in c++ che risolve alla perfezione il problema:

LRESULT WINDOWPROC(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
BYTE keyStateArr[256];
WORD value;
CHAR asciicode;

switch( message )
{
case WM_KEYDOWN:

//preleva lo stato della tastiera
GetKeyboardState(keyStateArr);

//converte la virtual key wParam in codice ascii
if (ToAscii(wParam, (T_DWORD)lParam, keyStateArr, &value, 0)  != 0)
{
asciicode = (T_CHAR) value;

//restituisce le maiuscole se è premuto il tasto shift
if ((GetKeyState(VK_SHIFT) & 0×8000) && wParam >= ‘a’ && wParam <= ‘z’)
asciicode += ‘A’-'a’;
}
else
{
//restiruisce 0 se non è premuto alcun tasto con codice ascii
asciicode = 0;
}

Scrivi_il_testo(asciicode);

break;
}

return DefWindowProc(hWnd, message, wParam, lParam);
}

Fortunatamente esistono delle tecniche di conversione che permettono di minimizzare queste differenze e rendere la vita più facile ai programmatori che tutt’ora, per scopi puramente hobbystici, hanno intenzione di sviluppare qualche piccolo lavoro grafico su questa macchina del passato. Anch’io mi ci sono cimentato con esiti positivi e dato che in rete il materiale scarseggia ho deciso di pubblicare in questo articolo un piccolo progetto che incorpora le tecniche di conversione c2p e p2c più veloci (programmate in assembler) con un esempio di utilizzo all’interno di un listato in c per la visualizzazione degli effetti grafici in tempo reale.

Per chi non dovesse conoscere le terminologie:

- Il planar era una tecnica di visualizzazione delle bitmap con la quale i bit dei pixel da visualizzare sullo schermo dovevano essere memorizzati sotto forma di più array booleani detti appunto bitplane. Un’immagine da 8-bit, ad esempio, era composta da otto bit-plane, cioè da ben otto array booleani in memoria distinti e separati. E’ facile capire che se in questo modo avessi avuto la necessità di accedere ad un pixel in memoria, dato che possono essere letti da un array soltanto 8 bit (1 byte)  alla volta, avrei dovuto leggere 8 array diversi per ciascun pixel dell’immagine, il che è così dispendioso da rendere inutilizzabile questa tecnica per effetti real time.

- Il chunky invece è il modo nativo con cui le schede grafiche del pc (ma oggi giorno direi tutte) permettono di visualizzare sullo schermo un’immagine memorizzata come una successione di byte stipati all’interno di un unico array. Uno o più byte, letti in modo sequenziale all’interno dell’array, rappresentano il pixel che verrà visualizzato sullo schermo. Quindi per un’immagine a 8 bit è necessario un unico array, e per accedere ad un pixel serve un solo accesso al relativo byte. Se l’immagine è a 16 bit devo leggere i 2 byte disposti in memoria l’uno dopo l’altro per ciascun pixel, e così via. E’ questo il modo corretto di rappresentare, lavorare e visualizzare le immagini digitali.

- Una ChunkyToPlanar è un algoritmo super ottimizzato in assembler (non esistono c2p in c)  che ha lo scopo di convertire in una sola botta l’intera immagine chunky in un’altra di tipo planar, per poter essere visualizzata da un hardware che supporta solo il planar.

- Una PlanarToChunky è lo stesso tipo di algoritmo solo che converte le immagini da planare a chunky. Esso non è usato quasi mai nell’Amiga per effetti in tempo reale, ma probabilmente per catturare degli schermi elaborati via hardware dai chip custom per poi poterli memorizzare in un’immagine digitale da elaborare oppure salvare su file secondo i formati attualmente esistenti.

Nel listato che ho incluso c’è un esempio utile su come aprire uno schermo nuovo con la intuition, per poi creare un semplice algoritmo di disegno (una texture mapping dei pavimenti con filtraggio bilineare) e visualizzare il risultato sullo schermo. Vediamo soltanto di commentare le parti di codice più salienti:

struct Screen *scr;

if(scr=OpenScreenTags(NULL, SA_Title,”New chunky to planar”, SA_DisplayID, 0×00000000, SA_Depth, 8, SA_FullPalette, TRUE, SA_Exclusive, TRUE, TAG_DONE))
{//codice}

Questo serve ad aprire uno schermo con le funzioni del sistema operativo. Ciò che viene visualizzato del sistema è una bitmap di tipo planar a 8 bit con palette. Per settare una semplice palette di tipo grayscale:

for (y = 0; y < 256; y++)
SetRGB32( &scr->ViewPort, y, (y << 24), (y << 24), (y << 24));

I canali rgb della palette sono a 8bit ciascuno, tuttavia devono essere shiftati in quel modo, forse per motivi di allineamento in memoria (infatti amiga usa il big-endian). Passiamo al pezzo forte, e cioè alla creazione della struttura per poter in seguito utilizzare la chunky to planar:

// creo un’immagine a 8bit di 320×256

unsigned char *image;
image = new unsigned char[320*256];

// costruisco le informazioni per la ChunkyToPlanar

struct c2pStruct c2p;
c2p.bmap = scr->RastPort.BitMap; //indirizzo bitmap dello schermo amiga
c2p.startX = 0; //posizione x
c2p.startY = 0; //posizione y
c2p.width = 320; //larghezza
c2p.height = 240; //altezza
c2p.ChunkyBuffer = image; //immagine chunky da visualizzare

Questo significa che convertiremo direttamente il contenuto di image nella bitmap di visualizzazione, cioè chiamando la chunkytoplanar visualizzaremo sullo schermo il contenuto di image nel seguente modo:

ChunkyToPlanarAsm(&c2p);

Prima di chiudere il programma non dobbiamo scordarci di rilasciare l’immagine e di chiudere lo schermo amiga:

//rilascio la memoria usata per l’immagine
delete [] image;

//chiudo lo schermo amiga
CloseScreen(scr);

E’ ovvio che questi listati possono essere messi insieme in un progetto compilabile solo da persone che hanno una certa esperienza, per questo motivo ho incluso anche l’eseguibile in formato Amiga, come dimostrativo per quegli utenti che vogliono vedere subito il risultato senza avere il tempo di compilare. Ricordate che l’effetto potrebbe sembrarvi lento non perchè la chunky to planar è lenta ma perchè l’algoritmo di disegno implementa un filtraggio di tipo bilineare. Per l’esecuzione sul pc consiglio l’ultima versione di winuae con harddisk e workbench installati, minimo 1mb di memoria e il coprocessore matematico casomai doveste usare  il processore 68030. Per una velocità di esecuzione decente settate il modo JIT (Just In Time).

©2008 Gianpaolo Ingegneri

Il sottocampionamento dei segnali digitali

Per capire meglio di cosa stiamo parlando, riprendiamo velocemente qualche cenno di segnali digitali. Un segnale digitale è una raccolta di n campioni, tipicamente campionati da un segnale analogico in base a un tempo di campionamento (durata temporale del campione), quindi si ha una frequenza di campionamento che corrisponde al numero massimo di campioni riprodotti al secondo (es: 44000). Il teorema del campionamento dice che la massima frequenza di campionamento (e quindi il numero di campioni) è scelta come circa il doppio della frequenza di taglio del segnale analogico da campionare, per esempio un suono con massimo 20000 Hz di banda passante (udibile umano) può essere campionato usando 48000 campioni al secondo per ottenere una qualità perfetta durante la fase di ascolto (ossia durante la conversione digitale-analogico). Tuttavia se riduciamo il numero di campioni da 48000 a 12800 al secondo otteniamo un’irrimediabile perdita di informazione ed un conseguente effetto di aliasing, che all’orecchio ci suonerà come un fastidioso brusio o altri tipi di rumore.

Vediamo in pseudocodice come viene operata questa riduzione dei campioni:

prima = 48000; dopo = 12800;
step = prima / dopo; p = 0;

For n = 0  to dopo-1
segnale_nuovo[n] = segnale_vecchio[int(p)];
p += step;
Next

Con questo algoritmo, noto anche come stretching, abbiamo costruito un nuovo segnale digitale sulla base di quello vecchio, che era da ridurre. Il nuovo segnale digitale ha preso un campione da quello vecchio, poi ne ha incrementato la posizione di lettura di 3.75 per poi prenderne un altro, questo significa che almeno 2 o 3 campioni sono stati scartati per ogni ciclo. Vediamo numericamente come si comporta la posizione di lettura p (che è un numero in virgola) e la posizione effettiva del campione da leggere (che è un numero intero).

n = 0;    p = 0;         int(p) = 0;
n = 1;    p = 3.75;     int(p) = 3;     ’scartati 1, 2
n = 2;    p = 7.5;       int(p) = 7;     ’scartati 4, 5, 6
n = 3;    p = 11.25;   int(p) = 11;   ’scartati 8, 9, 10
n = 4;    p = 15;        int(p) = 15;   ’scartati 12, 13, 14
n = 5;    p = 18.75;   int(p) = 18;   ’scartati 16, 17

Il sottocampionamento di un segnale consiste proprio nell’evitare di scartare questi campioni ed attribuire il loro peso informativo al nuovo campione sotto forma di media pesata per evitare l’effetto di aliasing. Il peso da associare ad ogni campione viene stabilito in base alla sua dimensione (misurata da 0 e 1) e prevedendo quanti campioni verrebbero scartati dopo un incremento della posizione di lettura. Vediamo come dovrebbe essere calcolato il nuovo campione, nel caso di n = 1:

p1 = 3.75; int(p1) = 3; peso1 = 4 – 3.75 = 0.25;
p2 = 4;      int(p2) = 4; peso2 = 5 – 4 = 1;
p3 = 5;      int(p3) = 5; peso3 = 6 – 5 = 1;
p4 = 6;      int(p4) = 6; peso4 = 7 – 6 = 1;
p5 = 7.5;   int(p5) = 7; peso5 = 7.5 – 7 = 0.5;

Il campione nella posizione 3 ha un peso informativo di 4-3.75 = 0.25. Poi in ordine viene letto il campione successivo della posizione 4 con un peso di 1, e così via, fino ad arrivare alla posizione 7 con un peso di 0.5. Possiamo dunque renderci conto che il nuovo campione dovrà essere uguale alla media pesata di ben 5 campioni (la somma del campione di partenza, i 3 che sarebbero stati scartati e l’ultimo di arrivo). Indichiamo con s[n] il vecchio segnale e calcoliamo il nuovo campione nel seguente modo: nuovo_campione[1] = (s[3]*0.25 + s[4]*1 + s[5]*1 + s[6]*1 + s[7]*0.5) / 3.75; Osservando questa formula possiamo notare che gli unici campioni da moltiplicare per i pesi sono quello di partenza e quello di arrivo, mentre gli altri andrebbero moltiplicati per 1, cioè andrebbero sommati per come si presentano. Inoltre la somma dei pesi è pari alla lunghezza massima del campione, che in questo caso è pari allo step: possiamo creare dunque un algoritmo ottimizzato, abbastanza leggero dal punto di vista computazionale. Generalizzando il caso appena preso in esame, possiamo costruire in pseudo-codice l’algoritmo definitivo per il sottocampionamento di un segnale digitale:

prima = 48000; dopo = 12800;
step = prima / dopo; p = 0;For n = 0  to dopo-1
nuovo_campione = segnale_vecchio[int(p)] * (1 – (p-int(p)));
For j = int(p)+1  to int(p+step)-1
nuovo_campione += segnale_vecchio[j];
Next

nuovo_campione += segnale_vecchio[int(p+step)] * ((p+step)-int(p+step));
nuovo_segnale[n] = nuovo_campione / step;
p += step;
Next

Il sottocampionamento delle immagini digitali

Le immagini digitali possono essere trattate come il caso particolare di un segnale a due dimensioni: possiamo così estendere al caso bidimensionale l’algoritmo usato in precedenza per i segnali digitali. ll nuovo campione deve essere calcolato non più in base alla media pesata di un solo vettore di campioni, ma di un’intera matrice di campioni, come è possibile vedere dalla figura qui accanto. Dobbiamo eseguire il calcolo del nuovo campione con media pesata esattamente come avevamo fatto in precedenza per un vettore di campioni, ripetendo l’operazione per ogni riga della matrice e tenendo conto che, nel bordo superiore ed in quello inferiore, i pesi di ciascun campione dovranno essere moltiplicati per un peso che è pari rispettivamente a [int(ty+1) – ty] e [(ty+sy) – int(ty+sy)]. Alla fine, la somma totale dei pesi che abbiamo attribuito a ciascun campione dovrà essere esattamente uguale a sx*sy, cioè l’area del rettangolo preso in considerazione (i pesi infatti sono proprio le aree di ogni singolo campione). Sviluppando l’algoritmo del sottocampionamento di un’immagine digitale otteniamo il seguente pseudo-codice:

Dim old_width, old_height
Dim new_width, new_height
sx = old_width / new_width;
sy = old_height / new_height;

For py = 0  to new_height-1
tx = 0;

For px = 0  to new_width-1

‘riga superiore
j = int(ty);
new_sample = old_image[int(tx), j] * (1 – (tx-int(tx)));
For i = int(tx)+1  to int(tx+sx)-1
new_sample += old_image[i, j];
Next
new_sample += old_image[int(tx+sx), j] * ((tx+sx)-int(tx+sx));
new_sample = new_sample * (1 – (ty-int(ty)));

‘righe intermedie
For j = int(ty)+1  to int(ty+sy)-1
new_sample = old_image[int(tx), j] * (1 – (tx-int(tx)));
For i = int(tx)+1  to int(tx+sx)-1
new_sample += old_image[i, j];
Next
new_sample += old_image[int(tx+sx), j] * ((tx+sx)-int(tx+sx));
Next

‘riga inferiore
j = int(ty+sy);
new_sample2 = old_image[int(tx), j] * (1 – (tx-int(tx)));
For i = int(tx)+1  to int(tx+sx)-1
new_sample2 += old_image[i, j];
Next
new_sample2 += old_image[int(tx+sx), j] * ((tx+sx)-int(tx+sx));
new_sample = new_sample2 * ((ty+sy)-int(ty+sy));

’scrivo il nuovo campione calcolato
new_image[px, py] = new_sample / (sx * sy);
tx += sx;
Next
ty += sy;
Next

Com’è possibile vedere da questo esempio, l’immagine ridotta con lo stretch dei campioni presenta dei difetti di aliasing che non sono presenti nell’immagine ridotta con il sottocampionamento. Il subsampling è quasi sempre usato quando si devono ridurre delle immagini troppo grandi in immagini più piccole, come gli screenshot di un videogioco da inserire nell’articolo di una rivista, senza perdere qualità, anzi, nella maggior parte dei casi le immagini ridimensionate con questa tecnica risultano visivamente più gradevoli rispetto a quelle mostrate nelle loro dimensioni originali. Per questo motivo il sottocampionamento viene implementato in una sua variante, chiamata supercampionamento (supersampling) come tecnica di antialiasing per migliorare la qualità delle immagini generate da alcuni motori grafici, programmi di raytracing, generatori procedurali di texture e campionatori di forme geometriche anche complesse (come le clipart).

©2008 Gianpaolo Ingegneri

Nel pacchetto sono inclusi i sorgenti completi in c, alcune immagini in formato pgm per fare delle prove e l’eseguibile nel caso abbiate subito voglia di vedere qualcosa di pratico. Oltre alla realizzazione della trasformata di fourier veloce, per poter lavorare in modo completo sullo spettro delle frequenze, sono stati presi in esame tre tipi di filtri diversi: ideale, butterworth e gaussiano. Viene affrontato anche il tema dell’uso dei filtri passabanda come soluzione per correggere eventuali disturbi periodici all’interno di un’immagine.

©2008 Gianpaolo Ingegneri