[Image] Filtre de Laplace

Version imprimable

Bonjour a tout le monde.
J'ai realise un filtre de Laplace en utilisant la classe BufferedImageOp. Et ca marche parfaitement le seul probleme que j'ai c'est que jobtiens une image qui est assez sombre en fait il n'y a presque d'autre couleur que le noir :(
J'ai vu sur ce site :
http://www.incx.nec.co.jp/imap-visio.../laplace3.html
que on peut ajouter une valeur de 128 afin d'obtenir une image bien visible. Malheureusement j'ai pas reussi le faire. Comment je peux le faire ?
Quelqu'un peut m'aider ?

Voila une partie de mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 float[] filterX = { -1, -1, -1, -1, 8, -1, -1, -1, -1 }; BufferedImage bufferedImage = new BufferedImage(320,200,BufferedImage.TYPE_BYTE_GRAY); bufferedImage.getGraphics().drawImage(image, 0, 0, null); BufferedImageOp imageOp = new ConvolveOp(new Kernel(3,3,filterX)); imageOp.filter(bufferedImage, resultImage);

Au choix :

- effectivement rajouter 128 a tous les pixels presents sur l'image :

Code:

1
2
3
4
5
6
7
8
9
 
  int dx = ( (128 & 0xFF) << 16) | ( (128 & 0xFF) << 8) | ( (128 & 0xFF) << 0);
  for (int j = 0; j < height; j++) {
    for (int i = 0; i < width; i++) {
      int rgb = resultImage.getRGB(i, j);
      rgb |= dx;
      resultImage.setRGB(i, j, rgb);
    }
  }

- multiplier la valeur des pixels par n pour les rendre plus clairs (ici n = 4).

Code:

1
2
3
4
5
6
7
8
9
10
11
 
 // on recopie le resultat dans l'image temporaire
 bufferedImage.getGraphics().drawImage(resultImage, 0, 0, null);    
  // Peut-etre vaut'il mieux utiliser un kernel 1x1 a la place.
 filterX = new float[] {
       0, 0, 0, 
       0, 4, 0, 
       0, 0, 0
  };
  imageOp = new ConvolveOp(new Kernel(3, 3, filterX));
  imageOp.filter(bufferedImage, resultImage);

Peut-etre peux-ton melanger les 2 filtres/kernels (j'ai pas teste):

Code:

1
2
3
4
5
6
 
  float[] filterX = new float[] {
       -1,    -1,  -1, 
       -1, 8+4,  -1, 
       -1,    -1,  -1
  };

Apres tests utiliser un filtre/kernel de ce genre peut produire des resultats interressants :
Code:

1 2 3 4 5 6 float[] filterX = { -1*n, -1*n, -1*n, -1*n, 8*n, -1*n, -1*n, -1*n, -1*n };

De retour chez moi j'ai pu remettre la main sur mon exemplaire de Java 2D Graphics (O'Reilly, ISBN 1-56592-484-3), où sont montré qq exemples des différents filtres (page 207 de l'édition US) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
// blur.
float ninth = 1.f/9.0f;
float blurKernel = {
  ninth, ninth, ninth,
  ninth, ninth, ninth,
  ninth, ninth, ninth
};
ConvolOp blurOp = new ConvoleOp( new Kernel(3, 3, blurKernel), ConvoleOp.EDGE_NO_OP, null);
 
// Edge detect.
float edgeKernel = {
   0f, -1f,  0f,
  -1f,  4f, -1f,
   0f, -1f,  0f
};
ConvoleOp edgeOp = new ConvoleOp(new Kernet(3, 3, edgeKernel), ConvoleOp.EDGE_NO_OP, null);
 
// Sharpen.
float sharpKernel = {
   0f, -1f,  0f,
  -1f,  5f, -1f,
   0f, -1f,  0f
};
ConvoleOp edgeOp = new ConvoleOp(new Kernet(3, 3, sharpKernel));
 
short brightenTable = new short[256];
short betterBrightenTable = new short[256];
short posterizeTable = new short[256];
short invertTable = new short[256];
short straightTable = new short[256];
short zeroTable = new short[256];
for (in i = 0; i < 256 ; i++) {
  brightenTable[i] = (short) (128 + i/2);
  betterBrightenTable[i] = (short) (Math.sqrt((double) i / 255.0) * 255.0);
  posterizeTable[i] =  (short) (i- (i % 32)); 
  invertTable[i] = (short) (255 - i);
  straightTable[i] = (short) i;
  zeroTable[i] = (short) 0;
}
 
// Toutes couleurs.
LookupOp brightenOp = new LookupOp(new ShortLookupTable(0, brightenTable), null);
LookupOp betterBrightenOp = new LookupOp(new ShortLookupTable(0, betterBrightenTable), null);
LookupOp posterizeOp = new LookupOp(new ShortLookupTable(0, posterizeTable), null);
LookupOp invertOp = new LookupOp(new ShortLookupTable(0, invertTable), null);
 
// Uniquement sur certaines channels.
short[][] redOnlyInvertTable = {invertTable, straightTable, straightTable};
short[][] greenOnlyInvertTable = {straightTable, invertTable, straightTable};
short[][] greeOnlyInvertTable = {straightTable, straightTable, invertTable};
 
LookupOp redOnlyInvertOp = new LookupOp(new ShortLookupTable(0, redOnlyInvertTable), null);
LookupOp greenOnlyInvertOp = new LookupOp(new ShortLookupTable(0, greenOnlyInvertTable), null);
LookupOp blueOnlyInvertOp = new LookupOp(new ShortLookupTable(0, blueOnlyInvertTable), null);
 
short[][] redOnlyRemoveTable = {zeroTable, straightTable, straightTable};
short[][] greenOnlyRemoveTable = {straightTable, zeroTable, straightTable};
short[][] greeOnlyRemoveTable = {straightTable, straightTable, zeroTable};
 
LookupOp redOnlyRemoveOp = new LookupOp(new ShortLookupTable(0, redOnlyRemoveTable), null);
LookupOp greenOnlyRemoveOp = new LookupOp(new ShortLookupTable(0, greenOnlyRemoveTable), null);
LookupOp blueOnlyRemoveOp = new LookupOp(new ShortLookupTable(0, blueOnlyRemoveTable), null);
 
RescaleOp rescale_0_5 = new RescaleOp(.5f, 0, null);
 
....

Voilà (sauf erreur de frappe) les principales susceptibles de t'interresser ; les autres décrites sont des transformation affines (AffineTransform) et des convertion d'un espace de couleur à un autre (ColorConvertOp).

21/10/2005, 09h42
jcarre

<HORS-SUJET on>

pour info les exemples des bouquins OReilly sont dispo sur leur site :
http://examples.oreilly.com/java2d/
Ca évite les fautes de frappe.

<HORS-SUJET off>
21/10/2005, 17h15
scifire

Merci
Ca marche nickel :)

A+