View Full Version : [Java, C, C++] Algoritmi x grafica
Conoscete qualche sito dove possa trovare una raccolta di algoritmi comunemente usati per la grafica su PC (sul genere bacchetta magica, floodFill, alpha-blending etc.).
In ordine sparso sono riuscito a recupera qualche cosa su Bresenham (linee, cerchi rettangoli etc.), mi interessa sopratutto qualcosa sulla selezione di aree contigue, prima di fare una porcata rimaneggiando un flood-fill.
Grazie&Ciao.
Interessante...e vedere i sorgenti del gimp ? Senza copiarli, ma magari cercando di implementare lo stesso algoritmo...
Non ci avevo pensato (pensare! ahh, che attività faticosa :D ).
Mo' scarico i sorgenti e provo a vedere.
Nel frattempo, se qualcuno avesse sottomano un link ad uno degli argomenti di cui sopra, la questione resta aperta.
stai scrivendo Photoshop in java ? :D
Quasi :D. Dopo un anno di esperimenti adesso sono pronto a fare Corel Painter in Java (un hobby bisogna pur averlo). E' un bel po' che ce l'ho in testa, adesso parto "anima e core" a scrivere il progetto, (ricordami che devo appiopparti un modulo da scrivere aggratis :D)
Se avessero scritto i sorgenti di "The Gimp" in Aramaico braille, dal basso verso l'alto, avrei avuto miglior fortuna.
Forse è questo che distingue il vero programmatore dal dilettante, saper leggere l'Aram... il sorgente altrui :D.
mi "uppo" da solo.
Per l'alpha-blending dovrebbe essere una cosa del genere:
R = (1 - a)A + aB
Con Alpha compreso fra 0 e 1...
Mi manca il canale alpha del pixel di destinazione per applicare l'SRC_OVER di Porter-Duff. Però avevo letto da qualche parte che con un paio di passaggi la formula poteva essere usata anche avendo a disposizione i valori RGB premoltiplicati. Ovviamente, non ricordo più dove.
[edit]
Che stupido, se l'immagine di destinazione è opaca il canale alpha di ogni pixel di destinazione vale 1...adesso provo.
Dalla nota serie "ammazza il tuo processore":
public void draw(BufferedImage image, int x, int y) {
x -= size / 2;
y -= size / 2;
for(int i = 0; i < size; i++) {
for(int j = 0; j < size; j++) {
/* piglia il colore del pixel di destinazione prima */
/* dell'applicazione del colore */
rgb = image.getRGB(x + i, y + j);
/* se per la maschera di selezione il pixel è */
/* "manipolabile" e se il pixel dell'immagine che definisce il */
/* pennello non è "trasparente"... */
if(mask.isDrawablePixel(x + i, y +j, rgb) && track.getRGB(i, j) != nullColor) {
/* estrazione dei singoli componenti dall'intero rgb */
redDest = (rgb >> 16) & 0xff;
greenDest = (rgb >> 8) & 0xff;
blueDest = rgb & 0xff;
/* Porter duff, SRC_OVER, il pixel di partenza è opaco */
/* (alpha = 1.0): C = CaFa + CbFb, Fa = "alpha_immagine" */
/* Fb = 1 - "alpha_pennello" */
redDest = (int) (rgbColor[0] + (1.0f - transparency) * redDest);
greenDest = (int) (rgbColor[1] + (1.0f - transparency) * greenDest);
blueDest = (int) (rgbColor[2] + (1.0f - transparency) * blueDest);
/* ricompone l'intero rgb */
rgb = (redDest<<16)+(greenDest<<8)+blueDest;
/* colora il pixel */
image.setRGB(x + i, y + j, rgb);
}
}
}
}
No, quello che ho scritto è sbagliato, funziona solo con il nero :confused:
[edit]
Tutto ok (finalmente). Avevo dimenticato una "a".
Per i posteri, supponendo di avere un pixel di colore rgb_0, opaco, e di volerci sovrapporre un colore rgb_1 con valore alpha A, la combinazione (coma da formula indicata da cionci):
rgb_D = A * rgb_1 + (1 - A) * rgb_0;
Che culo...ho tirato a caso ;)
Io avevo trovato una formula simile alla tua di prima...
C = CaFa + CbFb con Ca e Cb compresi fra 0 e 1...e non indicava alcun rapporto fra Ca e Cb...ma non mi tornava molto perchè C poteva andare in overflow...quindi l'unico modo per evitare l'overflow era come ho scritto sopra...
Originariamente inviato da cionci
Io avevo trovato una formula simile alla tua di prima...
Sono quei carognoni di Porter e Duff che fan girare quella formula!
cionci, che faremmo senza di te!
(tieni in caldo i "ditini" :D , sento puzza di problemi per la "bacchetta magica").
Sto scrivendo l'algoritmo per l'UNDO-REDO
solo UNDO -> è facile, tutte le volte che si disegna qualcosa sull'immagine infilo una copia dell'immagine in una pila LIFO.
Quando l'utente preme su "undo" -> la pila "pòppa" il suo elemento.
Quando arriva il redo però, la pila non può più eliminare l'elemento estratto, per cui uso una lista con un indice che scorre all'interno degli elementi, verso il basso per l'undo e verso l'alto per il redo.
(0) <- UNDO - indice - REDO -> (SIZE-1)
Qualche confusione ce l'ho quando succede questo (i numeri sono indicativi).
l'utente disegna 18 linee.
poi, con l'UNDO, torna indietro di 8.
con il REDO torna avanti 3.
Ricomincia a disegnare: e 'mo la lista come la ordino?
Tutto quello che sta tra l'indice (spostato dall'UNDO-REDO) e l'ultima "copia" deve essere eliminato? Così però, dopo aver fatto un po' di UNDO si arriva ad un punto in cui due immagini successive nella pila non rappresentano più sequenze successive di modifiche?
Cerco di spiegarmi con uno schema: la X rappresenta l'indice dell'immagine che sarà estratta dalla lista quando l'utente premerà UNDO:
1 2 3 4 5 6 7 8 X (disegno)
1 X 3 4 5 7 8 9 (undo...)
1 2 3 X 5 6 8 9 (redo...)
1 2 3 10 11 12 13 X (disegno) si fa così?
1 2 3 9 8 7 6 5 10 11 12 13 X (disegno) o così?
Aita Aita :eek:
Ora... magari non so se ti può essere d'aiuto ma photoshop fa come hai spiegato fino alla penultima riga
1 2 3 4 5 6 7 8 X (disegno)
1 X 3 4 5 7 8 9 (undo...)
1 2 3 X 5 6 8 9 (redo...)
1 2 3 10 11 12 13 X (disegno) si fa così?
L'unica cosa che cambia è che se arrivi a visualizzare il numero 4 la sequenza va a sostituire il 5.
1 2 3 X 5 6 8 9 (redo...)
1 2 3 4 10 11 12 13 X (disegno)
(sempre se era questo che intendevi)
Era proprio questo. Grazie 1000.
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.