Help! Graphis class

> [code]

> super.paintComponent(g);

>

> m=ImageIO.read(new File(s));

I seriously doubt that you really want to read this image file *every* time paint() is called.

>

> Rectangle2D anc = new

> new

> Rectangle2D.Double(0,0,m.getWidth(),m.getHeight());

> Paint pTexture =new TexturePaint(m,anc);

I seriously doubt that you really want to create this TexturePaint *every* time paint() is called.

>

> g.setPaint(pTexture)// i have some problems in this

> method

What problems? Errors? Unexpected behavior? Why not submit an SSCCE?

http://homepage1.nifty.com/algafield/sscce.html

Jim S.

Niceguy1a at 2007-7-10 1:17:56 >

lut:

for(int i=0; i<100; i++)

{

tabella[RED]=(byte)i;

tabella[GREEN]=(byte)255;

tabella[BLUE]=(byte)(255-i);

}

for(int i=100; i<256; i++)

{

tabella[RED]=(byte)0;

tabella[GREEN]=(byte)0;

tabella[BLUE]=(byte)(255-i);

}

kllrtoskya at 2007-7-10 1:17:57 >

filtro "quadri gialli"

si consenta all'utente la selezione di una immagine RGB e l'inserimento tramite dialogo delle coordinate di un pixel (A,B) della immagine, si trasformino i suoi pixel come segue:

Per ciascun pixel (X,Y) si calcoli la funzione R(x,y)=Max(|X-A|,|Y-B|)

Per ciascun pixel con valore (Red,Green,Blue) si assegnino i nuovi colori:

( (Red+R)%256 , (Green+R)%256 , (Blue-R)%256 )

visualizzare l'immagine risultante

filtro lut

si crei un filtro puntuale che applichi sui canali R, G, B la seguente lut applicata canale per canale:

i valori tra 0 e 128 vengono invertiti, i valori tra 129 e 255 sono decrementati di 129

filtro convolutivio "media delle diagonali"

si crei un filtro convolutivo descritto da un kernel di convoluzione (2k+1)x(2k+1) che sostituisca il valore del pixel centrale con la media dei pixel che si trovano sulle diagonali del kernel. Anche qui k viene fornito dall'utente

etienn3a at 2007-7-10 1:17:57 >

lut:

public BufferedImage otherLUT(BufferedImage I)

{

byte [][] tabella = new byte [4][256];

for(int i=0; i<129; i++) //for per invertire

{

tabella[ALPHA]=(byte)255;//alfa non varia

tabella[RED]=(byte)(255-i);//faccio l'inversione

tabella[GREEN]=(byte)(255-i);

tabella[BLUE]=(byte)(255-i);

}

for(int i=129; i<256; i++) //for per decrementare i valodi d 129

{

tabella[ALPHA]=(byte)255;//alfa non varia

tabella[RED]=(byte)(i-129);

tabella[GREEN]=(byte)(i-129);

tabella[BLUE]=(byte)(i-129);

}

////////////////////////////////////////////////////////////////////////

// creo la tabella LUT necessaria

// PROBLEMA: la corrispondenza indici colori 猫

// un po' "da scoprire". inverto tutti e tre i canali

// tranne alfa

// l'inversione di alfa mi 猫 al momento incomprensibile...

// dalla tabello ottengo la LUT corrispondente

ByteLookupTable inversione=new ByteLookupTable(0,tabella);

// costruisco l'operatore che mi serve

LookupOp iR=new LookupOp(inversione,null);

// lo applico

BufferedImage temp=iR.filter(I, null);

return temp;

////////////////////////////////////////////////////////////////////////////////////////////////

}

willjuniora at 2007-7-10 1:17:57 >

kernel: penso k sia giusto

public static Kernel otherFilter()

{

int k = Integer.parseInt(JOptionPane.showInputDialog("immetti il range:"));

k = 2*k+1;

float [] c =new float [k*k];

float media=0F;

for(int i= 0; i<k;i++)

{

media+= i*k+i; // sommo tutti i valori del diagonale;

}

media = media/k;//faccio la media

for(int i= 0; i><k;i++)

{

c[i*k+i]+= media; // assegno la media al diagonale

}

return new Kernel(k,k,c);

}>

willjuniora at 2007-7-21 17:57:04 >

RASTER:

int b=0;

int a=0;

/////////////// se uno dei due valori sfora mi faccio dare un altro valore

do{

a=Integer.parseInt(JOptionPane.showInputDialog("coordinata a"));

}while(a<0&&a>=src.getWidth());

do{

b=Integer.parseInt(JOptionPane.showInputDialog("coordinata b"));

}while(b<0&&b>=src.getHeight());

for(int i=0;i< src.getWidth();i++)

{

for(int j=0;j<src.getHeight();j++)

{

/////////// scorro l'immagine pixel per pixel

float[] val=in.getPixel(i,j,(float[])null);

///////////////// calcolo la distanza del pixel da quello dato

int primo=(int)(Math.abs(i-a));

int secondo=(int)(Math.abs(j-b));

int r;

if(primo>secondo) r=primo;

else r=secondo;

///////////// imposto i colori

val[RED]=(val[RED]+r)%256;

val[GREEN]=(val[GREEN]+r)%256;

val[BLUE]=(val[BLUE]-r)%256;

//////////// scrivo il pixel

out.setPixel(i,j,val);

}

}

kllrtoskya at 2007-7-21 17:57:04 >

KERNEL:

public static Kernel otherFilter() {

int k=Integer.parseInt(JOptionPane.showInputDialog("Dimensione del c?"));

k=2*k+1;//Lato del c

float[] c = new float[k*k];

for(int i=0;i<k*k;i=i+1+k)/////////////questo rappresenta la prima diagonale

c[i]=1F/(2k-1);

for(int i=k-1;i<=k*k-k;i=i-1+k)////////////////questo rappresenta la seconda diagonale

c[i]=1F/(2k-1);

return new Kernel(k,k,c);

}

>

kllrtoskya at 2007-7-21 17:57:04 >

public BufferedImage filter(BufferedImage src, BufferedImage dest)

{

dest=null;//Se tolgo sto null lavoro sull'originale...

if (dest==null)

dest=createCompatibleDestImage(src,null);

WritableRaster out=dest.getRaster();

Raster in=src.getRaster();

//////////////////////////////////////////////////////////////////

int A = Integer.parseInt(JOptionPane.showInputDialog("immetti A"));

int B = Integer.parseInt(JOptionPane.showInputDialog("immetti B"));

for(int i = 0; i < src.getWidth(); i++)//scorro per righe

{

for(int j = 0; j< src.getHeight(); j++)//scorro per colonne

{

float val[] = in.getPixel(i,j,(float[])null);

float r = Math.max(Math.abs(i-A),Math.abs(j-B));//la formula multimediale

val[RED] = 1F*((int)(val[RED]+r)%256);

val[GREEN] = 1F*((int)(val[GREEN]+r)%256);

val[GREEN] = 1F*((int)(val[GREEN]-r)%256);

out.setPixel(i,j,val);//scrivo sul pixel

}

}

return dest;

}

willjuniora at 2007-7-21 17:57:04 >

a siti na carpata di bastaddi...soprattutto mi spiegate perch postate in inglese ca siti chi catanisi di mia!

PS: il kernel non compila mi va in panic che faccio?

help me

cmq scherzo prima che poi entrate in para

tutto giusto fidatevi della rondine

vi voglio bene

grazie di esistere tosky...

by

il tuo fuckclub

anatrosky85a at 2007-7-21 17:57:04 >

forse sto kernel ok:

public static Kernel otherFilter()

{

int k=Integer.parseInt(JOptionPane.showInputDialog("Dimensione del k?"));

k=2*k+1;//Lato del c

float[] c = new float[k*k];

for(int i= 0; i<k;i++)

{

c[i*k+i] = 1F/(2*k-1); // assegno la media al diagonale

}

for(int i= 1; i><=k;i++)

{

c[(k-1)] = 1F/(2*k-1); // assegno la media al diagonale

}

return new Kernel(k,k,c);

}

willjuniora at 2007-7-21 17:57:05 >

public static Kernel otherFilter()

{

int k=Integer.parseInt(JOptionPane.showInputDialog("Dimensione del k?"));

k=2*k+1;//Lato del c

float[] c = new float[k*k];

for(int i= 0; i<k;i++)

{

c[i*k+i] = 1F/(2*k-1); // assegno la media al diagonale

}

for(int i= 1; i><=k;i++)

{

c[(k-1)] = 1F/(2*k-1); // assegno la media al diagonale

}

return new Kernel(k,k,c);

}

kllrtoskya at 2007-7-21 17:57:09 >

public BufferedImage otherLUT(BufferedImage I)

{

byte []tabella = new byte [4] ; //[256];

for(int i=0; i<129; i++) //for per invertire

{

tabella[ALPHA]=(byte)255;//alfa non varia

tabella[RED]=(byte)(255-i);//faccio l'inversione

tabella[GREEN]=(byte)(255-i);

tabella[BLUE]=(byte)(255-i);

}

for(int i=129; i<256; i++) //for per decrementare i valodi d 129

{

tabella[ALPHA]=(byte)255;//alfa non varia

tabella[RED]=(byte)(i-129);

tabella[GREEN]=(byte)(i-129);

tabella[BLUE]=(byte)(i-129);

}

e' giusto?

janclodea at 2007-7-21 17:57:09 >