Java Processing Sfumatura di colore

May 3

Le pendenze sono esteticamente piacevoli transizioni tra i colori. Java elabora automaticamente diversi tipi di gradienti tra i colori specificati dall'utente. È possibile impostare un gradiente come un colore mentre si disegna in Java per creare forme, testo e altri oggetti con un effetto sfumato. Se le classi gradiente di default di Java non sono abbastanza flessibili, è possibile elaborare le proprie pendenze in Java con cicli annidati.

GradientPaint Class

La classe GradientPaint fornisce il metodo più semplice per creare un semplice gradiente. il costruttore di GradientPaint accetta due punti, due colori e un valore booleano opzionale. Il gradiente risultante sposterà dal primo colore al primo punto al secondo colore al secondo punto. Se si passa il valore booleano vero, il gradiente ripeterà il gradiente in entrambe le direzioni oltre i punti di inizio e fine, la creazione di un andamento ciclico. Un oggetto GradientPaint che cicli attraverso blu e bianco è istanziato come tale:

GradientPaint p = new GradientPaint (nuovo punto (0,0), Color.BLUE, new Point (100,100), Color.white, true);

LinearGradientPaint Class

LinearGradientPaint è simile a GradientPaint, ma può creare un gradiente attraverso più di due colori e permette di definire l'ampiezza ciascuna sezione colorata del gradiente dovrebbe essere. il costruttore di LinearGradientPaint accetta due punti, una serie di carri, una vasta gamma di colori e un valore opzionale per indicare come il gradiente dovrebbe scorrere i colori. Ogni valore float corrisponde ad un colore e indica in quale punto gradiente che colore deve essere predominante. Ad esempio, se il gradiente dovrebbe essere blu un terzo del modo attraverso il suo ciclo 0.3f deve corrispondere con il colore blu. Un oggetto LinearGradientPaint che crea un gradiente attraverso blu, bianco e nero, senza ripetere usi il seguente costruttore:

float [] x = {0.0f, 0.3f, 1.0f};
Colore [] c = {Color.BLACK, Color.Blue, Color.white};
LinearGradientPaint lp = new LinearGradientPaint (nuovo punto (0,0), new Point (100,100), x, c);

RadialGradientPaint Class

RadialGradientPaint crea gradienti circolare si estende da un unico punto. Il costruttore accetta un singolo punto che rappresenta il centro del cerchio, un valore decimale che rappresenta il raggio del cerchio, una serie di carri per rappresentare la velocità di cambiamento tra colori e una gamma di colori. Opzionalmente, si può accettare un punto focale che sposta il centro della sfumatura per creare sfumature ellittiche e un valore per determinare come i cicli di gradiente attraverso i colori. Un'istanza di un oggetto RadialGradientPaint è simile alla creazione di un LinearPaintObject:

float [] x = {0.0f, 0.3f, 1.0f};
Colore [] c = {Color.BLACK, Color.Blue, Color.white};
LinearGradientPaint lp = new LinearGradientPaint (new Point (50,50), (float) 25, x, c);

Dipingere un gradiente

È possibile creare sfumature personalizzate più elaborati in Java per l'elaborazione di una sfumatura attraverso cicli annidati. Ad ogni fase del ciclo, creare un nuovo colore in base alla posizione nel ciclo. Nel ciclo più interno, disegnare un quadrato in una posizione definita da vostra posizione nel ciclo nel colore corrente. Il codice nell'esempio che segue crea un rettangolo sfumatura che inizia nel punto (0,0) ed è largo 400 pixel e alto 500 pixel. Il galleggiante valori r1, g1 e b1 definire R, G e B valori del colore iniziale. I valori r2, g2 e b2 definiscono R, G e B valori per il secondo colore. La prima esecuzione del ciclo delle x iniziali coordinano alla larghezza del rettangolo. Le piste ciclo interno dalla y iniziale coordinate all'altezza del rettangolo. Così, nel ciclo interno, il punto (i, j) corrisponde sempre ad un punto diverso nel rettangolo gradiente. Ogni volta che il programma cicli attraverso il ciclo annidato, modifica i valori R e B come una frazione delle x attuali coordinate; quanto più il punto è al valore iniziale x, più il r e valori di b saranno ai valori iniziali. Il programma modifica il valore b rispetto alla y coordinate attuale, creando lo stesso effetto su un asse diverso. Si crea quindi un nuovo colore dalla R, G e B valori modificati, e disegna un rettangolo di esattamente un pixel in larghezza e altezza alla corrente di coordinate nel nuovo colore.

int x = 0; int y = 0;
int width = 400; int height = 500;
float r1 = 0; float g1 = 0; float b1 = 1;
float r2 = 1; float g2 = 1; float b2 = 0;
float Rs = Math.abs (r2-r1);
float GF = Math.abs (g2-g1);
float bs = Math.abs (b2-b1);
for (int i = x; i <larghezza; i ++) {

for(int j = y; j &lt; height;j++){
float r,g,b;
if(r1&lt;r2){ r = (((rS)/width)*i)+r1;}
else{r = (r1-((rS)/width)*i);}
if(g1&lt;g2){g = (((gS)/width)*i)+g1;}
else{g = (g1-((gS)/width)*i);}
if(b1&lt;r2){b = (((bS)/width)*i)+b1;}
else{b = (b1-((bS)/width)*i);}
Color c = new Color(r,g,b,(float)0.5);
g2d.setColor(c);
g2d.fillRect(i, j, 1, 1);
}

}