Si l'image se trouve dans une archive, le plus simple est de laisser le ClassLoader trouver le fichier. Cette solution est valable que l'image se trouve ou non dans une archive, il est donc préférable de toujours utiliser le ClassLoader afin de limiter les problèmes lors du déploiement de l'application/applet.
Java ne permettait pas d'enregistrer une image au format GIF, PNG ou JPEG. Il va falloir faire appel à des classes extérieures permettant le codage de l'image.
L'ajout d'image en fond de composant n'est pas possible avec les classes de base de Swing. Heureusement, la réalisation d'une telle classe n'est pas compliquée, il suffit de créer un nouveau composant héritant de JComponent et de surcharger la méthode paintComponent.
La méthode paintComponent(Graphique g) est chargée de dessiner le composant ; les composants fils seront dessinés par dessus plus tard.
Exemple (Swing):
publicclass MonPanel extends JComponent<comment>variable de classe contennant l'image à afficher en fond</comment>private Image bg;<comment>Surcharge de la fonction paintComponent() pour afficher notre image</comment> publicvoid paintComponent(Graphics g)g.drawImage(bg,0,0,null);
Exemple (AWT):
publicclass MonPanel<comment>variable de classe contennant l'image à afficher en fond</comment>private Image bg;<comment>Surcharge de la fonction paint() pour afficher notre image</comment> publicvoid paint(Graphics g)g.drawImage(bg,0,0,null);
Note :
Vous pouvez placer le composant dans la JFrame en utilisant la méthode setComponentPane(moncomposant).
Fichier joint :
Vous trouvez, dans les liens ci-dessous, un exemple complet d'implémentation d'un tel objet, permettant d'afficher l'image en mosaïque ou centrée.
Beaucoup d'opérations de manipulation d'image ne travaillent que sur des <javaClass class="java.awt.image.BufferedImage"/>. La vie étant parfois mal faite, il est courant de trouver dans l'API des méthodes nous retournant des images, mais assez rarement des bufferedImages, il nous faut donc convertir ces images... Voici une méthode qui s'occupe de tout :
BufferedImage toBufferedImage(Image image) <comment>On test si l'image n'est pas déja une instance de BufferedImage</comment>if( image instanceof BufferedImage )<comment>cool, rien à faire</comment>return( (BufferedImage)image );else<comment>On s'assure que l'image est complètement chargée</comment>image = new ImageIcon(image).getImage();<comment>On crée la nouvelle image</comment>BufferedImage bufferedImage = new BufferedImage( image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB );Graphics g = bufferedImage.createGraphics();g.drawImage(image,0,0,null);g.dispose();return( bufferedImage );
Les modifications de couleur d'une image sont assurées par la classe <javaClass class="java.awt.image.ColorConvertOp"/> qui travaille à partir de <javaClass class="java.awt.image.BufferedImage"/>.
ColorConvertOp op = new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY),null);BufferedImage imageGrise = op.filter(bufferedImage,null);
L'algorithme permettant de rendre une image floue travaille très simplement : la couleur d'un pixel est calculée en faisant la moyenne pondérée de sa couleur et de celles de ses voisins. Il suffit de modifier les coefficients et le nombre de voisins pour intervenir sur le résultat, plus le poids des voisins est important, plus l'image sera floue. De plus, on peut choisir le poids d'un voisin en fonction de sa position, ce qui permet d'attribuer des poids différents et d'obtenir des résultats surprenants...
float[ ] matrice = {<br_l/>0.1, 0.1, 0.1,<br_l/>0.1, 0.2, 0.1,<br_l/>0.1, 0.1, 0.1<br_l/>};BufferedImageOp op = new ConvolveOp(new Kernel(3,3,matrice));BufferedImage nouvelleImage = op.filter(bufferedImage, null);
Il n'est pas possible d'effectuer de transformation directement sur une image mémoire, il faut créer un nouvelle image et dessiner la version transformée dans cette nouvelle image.
<comment>Création d'une nouvelle image</comment>BufferedImage nouvelleImage = new BufferedImage(imageSource.getWidth(),imageSource.getHeight(),imageSource.getType());Graphics2D g2d = nouvelleImage.createGraphics();<comment>préparation de la transformation</comment>AffineTransform at = new AffineTransform();at.rotate(angle,x,y);g2d.drawImage(imageSource,at,null);g2d.dispose();
C'est à mon avis une assez mauvaise idée. Les méthodes de la classe <javaClass class="java.awt.Graphics"/> sont généralement des appels directs des fonctions de la carte vidéo ou d'une bibliotheque graphique (DirectX ou autre), bref.
Lecture d'un pixel :
<comment>Lecture d'un seul pixel :</comment>int rgb = bufferedImage.getRGB(x,y);<comment>Lecture de tous les pixels :</comment>int w = bufferedImage.getWidth();int h = bufferedImage.getHeight();int[] rgbs = newint[w*h];<comment>on crée l'espace neccessaire</comment>bufferedImage.getRGB(0,0,w,h,rgbs,0,w);
Ecriture d'un pixel :
<comment>Ecriture d'un seul pixel :</comment>bufferedImage.setRGB(x,y,rgb);<comment>Ecriture de tous les pixels :</comment>int w = bufferedImage.getWidth();int h = bufferedImage.getHeight();int[] rgbs = newint[w*h];bufferedImage.setRGB(0,0,w,h,rgbs,0,w);
Pour des raisons de performance on utilise un seul entier pour coder les trois couleurs primaires (rouge, vert, bleu) et la composante alpha (le niveau de transparence). Chaque composante est codée sur 8 bits (bleu 0-7, vert 8-15, rouge 16-23, alpha 24-31).
<comment>Lecture manuelle des composantes :</comment>int rgb = bufferedImage.getRGB(x,y);int alpha = (rgb >>24 ) & 0xFF;int rouge = (rgb >>16 ) & 0xFF;int vert = (rgb >> 8 ) & 0xFF;int bleu = rgb & 0xFF;<comment>Construction d'un pixel :</comment>int rgb = (alpha<<24)+(rouge<<16)+(vert<<8)+bleu;<comment>Les composantes doivent obligatoirement être comprises dans l'intervalle 0-255</comment>
Utilser simplement la méthode <javaMethode class="java.awt.Image" methode="getScaledInstance(int, int , int)"/> de la classe <javaClass class="java.awt.Image"/>.
Redimensionnemant d'une BufferedImage :
<comment_javadoc>Effectue une homothétie de l'image.@param bi l'image.@param scaleValue la valeur de l'homothétie.@return une image réduite ou agrandie.</comment_javadoc>publicstatic BufferedImage scale(BufferedImage bi, double scaleValue) AffineTransform tx = new AffineTransform();tx.scale(scaleValue, scaleValue);AffineTransformOp op = new AffineTransformOp(tx,<br_l/>AffineTransformOp.TYPE_BILINEAR);BufferedImage biNew = new BufferedImage( (int) (bi.getWidth() * scaleValue),<br_l/>(int) (bi.getHeight() * scaleValue),<br_l/>bi.getType());return op.filter(bi, biNew);<br_l/>
Note :
Un coefficient supérieur à 1 correspond à un agrandissement, un coefficient inférieur à 1 correspond à une réduction.
L'icone d'une application apparait à divers endroits en fonction du système d'exploitation. Sous windows, on la retrouve en haut à gauche de la fenêtre, et dans la barre des taches. Par defaut il s'agit de la tasse de café de Java, il est très facile de la personnaliser en utilisant la méthode <javaMethode methode="setIconImage(java.awt.Image)" class="javax.swing.JFrame" /> des classes <javaClass class="javax.swing.JFrame" /> et <javaClass class="javax.swing.JDialog" />.
Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduit en français ici.
Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement.
