Enregistrer JPanel comme image

Question

Je développe une application permettant à l'utilisateur de charger une image dans un calque. L'utilisateur peut dessiner une image sur une autre couche et enregistrer seulement l'image que l'utilisateur drawn.Here est mon code:

import java.awt.Dimension; 
import java.awt.Graphics; 
import javax.swing.ImageIcon; 
import javax.swing.JApplet; 
import javax.swing.JLabel; 
import javax.swing.JLayeredPane; 
import javax.swing.JPanel; 

public class LayerDemo extends JApplet { 

    private JLayeredPane mainLayer; 

    private JPanel layer1; 

    private JPanel layer2; 

    private JLabel label; 

    private ImageIcon imgIcon; 


    /** 
    * Create the applet. 
    */ 
    public LayerDemo() {  
    } 

    public void init() { 
     Dimension mainDemension = new Dimension(1024,768); 
     setSize(mainDemension); 

     mainLayer = new JLayeredPane(); 
     layer1 = new JPanel(); 
     layer1.setOpaque(false); 
     layer1.setBounds(0, 0, this.getWidth(), this.getHeight()); 
     imgIcon = new ImageIcon("bear.jpg"); 
     label = new JLabel(imgIcon); 
     label.setBounds(0, 0, imgIcon.getIconWidth(), imgIcon.getIconHeight()); 
     layer1.add(label); 

     layer2 = new PaintDemo(true); 
     layer2.setOpaque(false); 
     layer2.setBounds(0, 0, this.getWidth(), this.getHeight()); 

     mainLayer.add(layer1, 1); 
     mainLayer.add(layer2, 2); 
     this.setContentPane(mainLayer); 
    } 

    public void paint(Graphics g) {  
    } 

} 

C'est la classe de tirage utilisateur:

import java.awt.BasicStroke; 
import java.awt.Color; 
import java.awt.Font; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.Point; 
import java.awt.RenderingHints; 
import javax.imageio.ImageIO; 
import javax.swing.JPanel; 
import java.awt.event.MouseAdapter; 
import java.awt.event.MouseEvent; 
import java.awt.event.MouseMotionAdapter; 
import java.awt.event.MouseWheelListener; 
import java.awt.event.MouseWheelEvent; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 

public class PaintDemo extends JPanel { 
    /** 
    * field explanation 
    */ 
    private Point startPoint = new Point(); 

    private Point endPoint = new Point(); 

    private Graphics2D g2; 

    private int minX; 

    private int minY; 

    private int maxX; 

    private int maxY; 

    private int height; 

    private int width; 


    /** 
    * Create the panel. 
    */ 

    public PaintDemo(boolean isDoubleBuffer) { 

     addMouseWheelListener(new MouseWheelListener() { 
      public void mouseWheelMoved(MouseWheelEvent e) { 
      } 
     }); 
     this.setDoubleBuffered(isDoubleBuffer); 
     addMouseMotionListener(new MouseMotionAdapter() { 
      @Override 
      public void mouseDragged(MouseEvent e) { 
       endPoint = e.getPoint(); 
       Graphics g = PaintDemo.this.getGraphics(); 
       paintComponent(g); 
       minX = minX < endPoint.x ? minX : endPoint.x; 
       minY = minY < endPoint.y ? minY : endPoint.y; 
       maxX = maxX > endPoint.x ? maxX : endPoint.x; 
       maxY = maxY > endPoint.y ? maxY : endPoint.y; 
       startPoint = endPoint; 
      } 
     }); 
     addMouseListener(new MouseAdapter() { 
      @Override 
      public void mousePressed(MouseEvent e) { 
       startPoint = e.getPoint(); 
       minX = startPoint.x; 
       minY = startPoint.y; 
       maxX = startPoint.x; 
       maxY = startPoint.y; 
      } 

      @Override 
      public void mouseReleased(MouseEvent e) { 
       endPoint = e.getPoint(); 
       Graphics g = PaintDemo.this.getGraphics(); 
       paintComponent(g); 
       minX = minX < endPoint.x ? minX : endPoint.x; 
       minY = minY < endPoint.y ? minY : endPoint.y; 
       maxX = maxX > endPoint.x ? maxX : endPoint.x; 
       maxY = maxY > endPoint.y ? maxY : endPoint.y; 
       minX = minX > 0 ? minX : 0; 
       minY = minY > 0 ? minY : 0; 
       maxX = maxX < 1024 ? maxX : 1024; 
       maxY = maxY < 768 ? maxY : 768; 
       width = maxX - minX; 
       height = maxY - minY; 
       saveImage();  
       startPoint = new Point(); 
       endPoint = new Point(); 

      } 
     }); 
    } 

    /** 
    * Paint method 
    * 
    * {@inheritDoc} 
    */ 
    @Override 
    public void paintComponent(Graphics g) { 
     g2 = (Graphics2D)g; 
     g2.setStroke(new BasicStroke(2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); 
     g2.setFont(new Font("Serif", Font.BOLD, 18)); 
     g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); 
     g2.setColor(Color.red); 
     g2.drawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y); 
    } 

    public void saveImage() { 
     BufferedImage bi = new BufferedImage(PaintDemo.this.getWidth(), PaintDemo.this.getHeight(), BufferedImage.TYPE_INT_RGB); 
     Graphics2D g2 = bi.createGraphics(); 
     paintComponent(g2); 
     g2.dispose(); 
     try 
     { 
      ImageIO.write(bi, "jpg", new File("clip.jpg")); 
     } 
     catch(IOException ioe) 
     { 
      System.out.println("Clip write help: " + ioe.getMessage()); 
     } 
    } 
} 

Quand sauver l'image, il juste l'image vide. S'il vous plaît aidez-moi. Merci beaucoup. P/S: J'ai édité mon code comme idée mais ce n'est pas un travail. Le résultat n'est aucun arrière-plan d'image et enregistre toujours l'image vide. :(

Answer 1

peinture personnalisée est fait en redéfinissant la méthode du panneau. Ensuite, vous utilisez l'objet graphique pour vous faire la peinture.

Vous ne devriez pas avoir une méthode de peinture vide() paintComponent().

La méthode drawline() ne doit pas utiliser la méthode getGraphics(), mais doit plutôt être déplacée vers la méthode paintComponent(), puis utiliser l'objet Graphics transmis à la méthode. paint() méthode de l'applet Comme votre code est de peindre l'image à sa taille réelle, vous devriez simplement utiliser un JLab el pour afficher l'image en créant un ImageIcon. Ensuite, vous ajoutez l'étiquette au volet en couches à utiliser comme image d'arrière-plan.

Edit:

Pourquoi avez-vous encore la méthode de peinture() vide? Débarrassez-vous il n'y a pas besoin de surcharger la méthode paint(). Lorsque j'exécute le code, j'obtiens une exception de sécurité car les applets ne peuvent pas écrire dans un fichier, donc je ne peux pas tester cette partie du code. Mais au cas où vous êtes intéressé, j'utilise Screen Image pour créer des images d'un composant.

Cependant, votre problème principal est que le code de peinture est erroné. Oui, vous verrez des lignes tracées, mais elles ne sont pas permanentes. Vous ne devez jamais utiliser la méthode getGraphics() d'un composant lorsque vous souhaitez effectuer une peinture permanente. Essayez de dessiner quelques lignes, puis minimisez l'applet, puis restaurez l'applet et vous verrez ce que je veux dire.

La solution pour cela est de dessiner sur une image tamponnée. Voir l'exemple DrawOnImage de Custom Painting Approaches.

Answer 2

Voir ComponentImageCapture.java pour obtenir des conseils.