FAQ Java GUIConsultez toutes les FAQ

1
2
Robot robot = new Robot(); 
BufferedImage image = robot.createScreenCapture(new Rectangle( 15, 15, 150, 150));

1
2
3
Robot robot = new Robot(); 
BufferedImage image = robot.createScreenCapture( 
         new Rectangle(java.awt.Toolkit.getDefaultToolkit().getScreenSize()) );

1
2
3
4
Robot robot = new Robot(); 
BufferedImage image = robot.createScreenCapture( 
        new Rectangle( frame.getX(), frame.getY(), frame.getWidth(), frame.getHeight() ) 
        );

1
2
Image java.applet.Applet.getImage(URL url); 
Image java.applet.Applet.getImage(URL url, String name);

1
2
3
4
5
/** Accès au toolkit : */ 
java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit(); 
/** lecture de l'image : */ 
Image image = toolkit.getImage("fichier"); 
Image image = toolkit.getImage(url);

BufferedImage image = ImageIO.read( /* File, URL ou InputStream */ );

java.net.URL url = getClass().getResource("chemin/nom.gif");

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
import javax.imageio.*; 
  
public class FormatsImages {  
	public static boolean canRead(String format) {  
	   boolean type = ImageIO.getImageReadersByFormatName(format).hasNext();  
	   boolean mime = ImageIO.getImageReadersByMIMEType(format).hasNext();  
	   boolean suffixe = ImageIO.getImageReadersBySuffix(format).hasNext();  
	   String infos = "Informations lecture "+format+" : ";  
	   infos+="Format image = "+type+", ";  
	   infos+="MIME = "+mime+", ";  
	   infos+="Suffixe fichier = "+suffixe;  
	   System.out.println(infos);  
	   return type||mime||suffixe;  
	}  
  
	public static boolean canWrite(String format) {  
	   boolean type = ImageIO.getImageWritersByFormatName(format).hasNext();  
	   boolean mime = ImageIO.getImageWritersByMIMEType(format).hasNext();  
	   boolean suffixe = ImageIO.getImageWritersBySuffix(format).hasNext();  
	   String infos = "Informations écriture "+format+" : ";  
	   infos+="Format image = "+type+", ";  
	   infos+="MIME = "+mime+", ";  
	   infos+="Suffixe fichier = "+suffixe;  
	   System.out.println(infos);  
	   return type||mime||suffixe;  
	}  
}

1
2
3
4
5
6
7
8
9
10
canRead("gif"); 
canRead("jpg"); 
canRead("bmp"); 
canRead("image/jpeg"); 
//quelques vérifications sur les possibilités de lecture 
canWrite("gif"); 
canWrite("jpg"); 
canWrite("bmp"); 
canWrite("image/jpeg"); 
//quelques vérifications sur les possibilités d'écriture

1
2
3
4
5
6
7
8
9
10
11
String[] formatsLecture = ImageIO.getReaderFormatNames();   
String[] formatsEcriture = ImageIO.getWriterFormatNames(); 
//affichage des formats d'images lisibles 
System.out.println("Formats d'images disponibles en lecture"); 
for(int i=0;i<formatsLecture.length;i++){ 
   System.out.println(formatsLecture[i]); 
}   
System.out.println("Formats d'images disponibles en écriture"); 
for(int i=0;i<formatsEcriture.length;i++){ 
   System.out.println(formatsEcriture[i]); 
}

1
2
3
4
5
6
7
8
9
10
public class MonPanel extends JComponent { 
  
        /** variable de classe contenant l'image à afficher en fond */ 
        private Image bg; 
  
        /** Surcharge de la fonction paintComponent() pour afficher notre image */ 
         public void paintComponent(Graphics g) { 
                g.drawImage(bg,0,0,null); 
        }  
}

1
2
3
4
5
6
7
8
9
10
public class MonPanel { 
  
        /** variable de classe contenant l'image à afficher en fond */ 
        private Image bg; 
  
        /** Surcharge de la fonction paint() pour afficher notre image */ 
         public void paint(Graphics g) { 
                g.drawImage(bg,0,0,null); 
        }  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
BufferedImage toBufferedImage(Image image) { 
        /** On test si l'image n'est pas déja une instance de BufferedImage */ 
        if( image instanceof BufferedImage ) { 
                return( (BufferedImage)image ); 
        } else { 
                /** On s'assure que l'image est complètement chargée */ 
                image = new ImageIcon(image).getImage(); 
  
                /** On crée la nouvelle image */ 
                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 ); 
        }  
}

1
2
	BufferedImage buf = ...; 
	Image image = buf;

1
2
3
4
ColorConvertOp op = new ColorConvertOp( 
                                             ColorSpace.getInstance(ColorSpace.CS_GRAY), 
                                             null); 
BufferedImage imageGrise = op.filter(bufferedImage,null);

1
2
3
4
5
6
7
float[ ] matrice = { 
    0.1f, 0.1f, 0.1f, 
    0.1f, 0.2f, 0.1f, 
    0.1f, 0.1f, 0.1f 
}; 
BufferedImageOp op = new ConvolveOp(new Kernel(3,3,matrice)); 
BufferedImage nouvelleImage = op.filter(bufferedImage, null);

1
2
3
4
5
6
7
8
9
10
11
12
/** Création d'une nouvelle image */ 
BufferedImage nouvelleImage = new BufferedImage( 
                                          imageSource.getWidth(), 
                                          imageSource.getHeight(), 
                                          imageSource.getType()); 
Graphics2D g2d = nouvelleImage.createGraphics(); 
/** préparation de la transformation */ 
AffineTransform at = new AffineTransform(); 
at.rotate(angle,x,y); 
  
g2d.drawImage(imageSource,at,null); 
g2d.dispose();

1
2
3
4
5
6
7
8
/** Lecture d'un seul pixel : */ 
int rgb = bufferedImage.getRGB(x,y); 
  
/** Lecture de tous les pixels : */ 
int w = bufferedImage.getWidth(); 
int h = bufferedImage.getHeight(); 
int[] rgbs = new int[w*h]; /** on crée l'espace neccessaire */ 
bufferedImage.getRGB(0,0,w,h,rgbs,0,w);

1
2
3
4
5
6
7
8
/** Écriture d'un seul pixel : */ 
bufferedImage.setRGB(x,y,rgb); 
  
/** Écriture de tous les pixels : */ 
int w = bufferedImage.getWidth(); 
int h = bufferedImage.getHeight(); 
int[] rgbs = new int[w*h]; 
bufferedImage.setRGB(0,0,w,h,rgbs,0,w);

1
2
3
4
5
6
7
8
9
10
/** Lecture manuelle des composantes : */ 
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; 
  
/** Construction d'un pixel : */ 
int rgb = (alpha<<24)+(rouge<<16)+(vert<<8)+bleu; 
/** Les composantes doivent obligatoirement être comprises dans l'intervalle 0-255 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**  
 * Redimensionne une image. 
 *  
 * @param source Image à redimensionner. 
 * @param width Largeur de l'image cible. 
 * @param height Hauteur de l'image cible. 
 * @return Image redimensionnée. 
 */ 
public static Image scale(Image source, int width, int height) { 
    /* On crée une nouvelle image aux bonnes dimensions. */ 
    BufferedImage buf = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); 
  
    /* On dessine sur le Graphics de l'image bufferisée. */ 
    Graphics2D g = buf.createGraphics(); 
    g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); 
    g.drawImage(source, 0, 0, width, height, null); 
    g.dispose(); 
  
    /* On retourne l'image bufferisée, qui est une image. */ 
    return buf; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/** 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. 
 *  
 */public static BufferedImage scale(BufferedImage bi, double scaleValue) { 
        AffineTransform tx = new AffineTransform(); 
        tx.scale(scaleValue, scaleValue); 
        AffineTransformOp op = new AffineTransformOp(tx, 
                AffineTransformOp.TYPE_BILINEAR); 
        BufferedImage biNew = new BufferedImage( (int) (bi.getWidth() * scaleValue), 
                (int) (bi.getHeight() * scaleValue), 
                bi.getType()); 
        return op.filter(bi, biNew); 
  
}

1
2
Image icone = Toolkit.getDefaultToolkit().getImage("./monImage.jpg"); 
maFenetre.setIconImage(icone);

1
2
3
4
5
6
7
8
9
10
11
public Image getImage(Component component){ 
   if(component==null){return null;} 
   int width = component.getWidth(); 
   int height = component.getHeight(); 
   BufferedImage image = new BufferedImage(width, height,  
                                             BufferedImage.TYPE_INT_RGB); 
   Graphics2D g = image.createGraphics(); 
   component.paintAll(g); 
   g.dispose(); 
   return image; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public boolean alphaLayer(Image image){ 
   ColorModel modele = null;  
   if(image instanceof BufferedImage){ 
      // si on a affaire à une BufferedImage, on regarde son ColorModel 
      BufferedImage bi = (BufferedImage)image; 
      modele = bi.getColorModel();  
   }else { 
     // on traite l'image pixel par pixel afin de récupérer un ColorModel 
      PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);  
      try{ 
       // on découpe donc l'image pixel par pixel 
         pg.grabPixels();  
      }catch (InterruptedException e) { 
         e.printStackTrace(); 
      }  
      modele = pg.getColorModel(); 
   } 
   return modele.hasAlpha();  
}

1
2
3
4
5
6
// on crée auparavant la BufferedImage avec le nom bi 
  
Graphics2D g2d = bi.createGraphics(); // on récupère le contexte graphique de la BufferedImage    
g2d.setColor( Color.red ); // on met l'état de couleur rouge à la BufferedImage 
g2d.fillOval( 30, 30, 100, 100 ); // on dessine un cercle de centre x=30 y=30 et de rayon=100 
g2d.dispose(); //on libère la mémoire utilisée pour le contexte graphique

1
2
3
4
5
6
7
8
9
10
11
12
13
public static BufferedImage addImage(BufferedImage image1, BufferedImage image2){ 
	Graphics2D g2d = image1.createGraphics(); 
	g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
	                RenderingHints.VALUE_ANTIALIAS_ON); 
	g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, 
	                RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY); 
  
	g2d.drawImage(image2, 0, 0, null); 
  
	g2d.dispose(); 
  
	return image1 ; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/** 
 * Create a compatible image. 
 * 
 * @param width  The width. 
 * @param height The height. 
 * @param type   The type of the image. 
 * @return A compatible image. 
 */ 
private static BufferedImage createCompatibleImage(int width, int height, int type) { 
    GraphicsConfiguration gc = GraphicsEnvironment. 
            getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration(); 
  
    return gc.createCompatibleImage(width, height, type); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/** 
 * Create a compatible image from an existing image. 
 * 
 * @param image The image to make compatible. 
 * @return A compatible image filled with the base image. 
 */ 
public static BufferedImage createCompatibleImage(BufferedImage image) { 
    GraphicsConfiguration gc = GraphicsEnvironment. 
            getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration(); 
  
    if (image.getColorModel().equals(gc.getColorModel())) { 
        return image; 
    } else { 
        BufferedImage compatibleImage = gc.createCompatibleImage(image.getWidth(), image.getHeight(), 
                image.getTransparency()); 
  
        Graphics g = compatibleImage.getGraphics(); 
        g.drawImage(image, 0, 0, null); 
        g.dispose(); 
  
        return compatibleImage; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
private void imodifier_image() { 
  BufferedImage image = new BufferedImage(largeur, hauteur, BufferedImage.TYPE_INT_ARGB); 
  WritableRaster trame = image.getRaster(); 
  int[] couleur  = {Cr, Cv, Cb, Ca}; 
  
  for (int x=0; x<largeur; x++) { 
    for (int y=0; y<hauteur; y++) { 
      trame.setPixel(x, y, couleur); 
    } 
  } 
}