Tutoriel sur Java2D pour le développement d'une interface de gestion de maillage 2D

package plegatfem2d;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

/**
 * Classe définissant un JPanel personnalisé.
 * Ce JPanel permet l'affichage d'une grille 2D (axes X et Y, quadrillages horizontal et vertical)
 * ainsi que d'objets graphiques 2D définis par le programmeur.
 * L'affichage est interactif via la souris, l'utilisateur peut ainsi déplacer la vue, ainsi que zoomer
 * sur une zone particulière.
 * 
 * @author Jean-Michel BORLOT
 */
public class PFEM2DGuiPanel extends JPanel implements MouseListener, MouseMotionListener {

    /**
     * Constructeur.
     */
    public PFEM2DGuiPanel() {
        super();

        this.mode = VIEW;

        this.offsetX = 0;
        this.offsetY = 0;

        this.echelle = ECHELLE_BASE;

        this.addMouseListener(this);
        this.addMouseMotionListener(this);
    }
    
    private PFEM2DObjectManager pom;            // gestionnaire d'objets graphiques
    private int xold, yold;                     // coordonnées du point local précédent
    private int xstart, ystart;                 // coordonnées du point local initial
    private int mode;                           // mode d'interaction : VIEW, DRAG ou SCALE
    private double offsetX, offsetY;            // décalage de la vue
    private double echelle;                     // échelle de la vue
    private static int VIEW = 0;        
    private static int DRAG = 1;
    private static int SCALE = 2;
    private static double ECHELLE_BASE = 100.;  // échelle de base
    private static double stepX=100, stepY=100; // pas des quadrillages sens X et sens Y

    /**
     * Renvoie le gestionnaire d'objets graphiques
     * @return le gestionnaire d'objets graphiques
     */
    public PFEM2DObjectManager getPom() {
        return pom;
    }

    /**
     * Définit le gestionnaire d'objets graphiques
     * @param pom le gestionnaire d'objets graphiques
     */
    public void setPom(PFEM2DObjectManager pom) {
        this.pom = pom;
    }
}

     /**
     * Crée une capture d'écran de l'affichage courant.
     * Le fichier de sortie est défini par sélection du fichier via un JFileChooser.
     * Deux formats possibles en sortie: png ou jpg
     */
    public void takeScreenshot() {

        JFileChooser fc = new JFileChooser();

        int returnVal = fc.showOpenDialog(this);

        if (returnVal == JFileChooser.APPROVE_OPTION) {

            File fichier = fc.getSelectedFile();
            String nomFichier = fichier.getName().toLowerCase();

            if ((nomFichier.endsWith("png")) || (nomFichier.endsWith("jpg"))) {
                try {
                    BufferedImage bufImage = new BufferedImage(this.getSize().width, this.getSize().height, BufferedImage.TYPE_INT_RGB);
                    this.paint(bufImage.createGraphics());

                    String extension = "png";
                    if (nomFichier.endsWith("jpg")) {
                        extension = "jpg";
                    }

                    ImageIO.write(bufImage, extension, fichier);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            } else {
                JOptionPane.showMessageDialog(this, "Veuillez préciser l'extension du fichier image (png ou jpg)",
                        "Extension fichier manquante", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

     /**
     * Centre la vue sur les éléments à afficher. 
     * @param boundingBox tableau de 4 double: Xmin, Xmax, Ymin,Ymax, en coordonnées réelles
     */
    public void centreView(double[] boundingBox) {

        if ((boundingBox[1] - boundingBox[0] != Double.NEGATIVE_INFINITY) && (boundingBox[3] - boundingBox[2] != Double.NEGATIVE_INFINITY)) {

            double echelleX = (this.getWidth() - 50) * ECHELLE_BASE / (boundingBox[1] - boundingBox[0]);
            double echelleY = (this.getHeight() - 50) * ECHELLE_BASE / (boundingBox[3] - boundingBox[2]);

            this.echelle = Math.min(echelleX, echelleY);
            
            this.offsetX = -(this.getLocalCoordX((boundingBox[1] + boundingBox[0]) / 2) - this.getLocalCoordX(0));
            this.offsetY = -(this.getLocalCoordY((boundingBox[3] + boundingBox[2]) / 2) - this.getLocalCoordY(0));

            this.repaint();
        }
    }

package plegatfem2d.objects;

import java.awt.Graphics;
import plegatfem2d.PFEM2DGuiPanel;

/**
 * Interface définissant les objets graphiques
 * @author Jean-Michel BORLOT
 */
public interface IPFEM2DDrawableObject {

    /**
     * Dessine l'objet graphique
     * @param g l'objet Graphics sur lequel dessiner
     * @param panel l'objet PFEM2DGuiPanel sur lequel dessiner
     */
    public void draw(Graphics g, PFEM2DGuiPanel panel);

    /**
     * Définit la visibilité de l'objet graphique
     * @param flag true si l'objet est visible, false s'il ne l'est pas
     */
    public void setVisible(boolean flag);

    /**
     * Renvoie l'état de visibilité de l'objet graphique
     * @return true si l'objet est visible, false s'il ne l'est pas
     */
    public boolean isVisible();
    
    /**
     * Renvoie la liste des points définissant l'objet graphique
     * @return la liste des points
     */
    public PFEM2DPoint[] getPoints();
    
    /**
     * Renvoie l'identité de l'objet graphique
     * @return l'identité de l'objet graphique
     */
    public String getId();
    
    /**
     * Renvoie la boite englobante de l'objet graphique
     * @return un tableau de 4 double: Xmin, Xmax, Ymin, Ymax
     */
    public double[] getBoundingBox();
    
}

package plegatfem2d.objects;

/**
 * Interface de définition des objets de type "courbe"
 * @author Jean-Michel BORLOT
 */
public interface IPFEM2DCurve {
   
    /**
     * Renvoie le point de départ de la courbe
     * @return le point de départ de la courbe
     */
    public PFEM2DPoint getStartPoint();

    /**
     * Renvoie le point d'arrivée de la courbe
     * @return le point d'arrivée de la courbe
     */
    public PFEM2DPoint getEndPoint();    
}

package plegatfem2d.objects;

import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import plegatfem2d.PFEM2DGuiPanel;

/**
 * Classe définissant l'objet "racine", composé d'un assemblage d'objets
 * graphiques
 *
 * @author Jean-Michel BORLOT
 */
public class PFEM2DModel implements IPFEM2DDrawableObject {

    private List<IPFEM2DDrawableObject> objects = new ArrayList<>();   // liste des objets constituant l'objet "racine"
    private boolean visible = true;                                         // état de visibilité de l'objet

    /**
     * Constructeur
     */
    public PFEM2DModel() {
        this.objects.clear();
    }

    /**
     * Ajoute un objet graphique à l'objet racine
     *
     * @param obj l'objet graphique
     */
    public void addObject(IPFEM2DDrawableObject obj) {
        this.objects.add(obj);
    }

    /**
     * Supprime un objet graphique de l'objet racine
     *
     * @param obj l'objet graphique
     */
    public void removeObject(IPFEM2DDrawableObject obj) {
        this.objects.remove(obj);
    }

    /**
     * Dessine l'objet graphique
     *
     * @param g l'objet Graphics sur lequel dessiner
     * @param panel l'objet PFEM2DGuiPanel sur lequel dessiner
     */
    @Override
    public void draw(Graphics g, PFEM2DGuiPanel panel) {

        for (IPFEM2DDrawableObject current : this.objects) {
            if (current.isVisible()) {
                current.draw(g, panel);
            }
        }
    }

    /**
     * Définit la visibilité de l'objet graphique
     *
     * @param flag true si l'objet est visible, false s'il ne l'est pas
     */
    @Override
    public void setVisible(boolean flag) {
        this.visible = flag;
    }

    /**
     * Renvoie l'état de visibilité de l'objet graphique
     *
     * @return true si l'objet est visible, false s'il ne l'est pas
     */
    @Override
    public boolean isVisible() {
        return this.visible;
    }

    /**
     * Renvoie l'identité de l'objet graphique
     *
     * @return l'identité de l'objet graphique
     */
    @Override
    public String getId() {
        return "Root";
    }

    /**
     * Renvoie la boite englobante de l'objet graphique
     *
     * @return un tableau de 4 double: Xmin, Xmax, Ymin, Ymax
     */
    @Override
    public double[] getBoundingBox() {

        double data[] = new double[4];

        data[0] = Double.POSITIVE_INFINITY;
        data[1] = Double.NEGATIVE_INFINITY;
        data[2] = Double.POSITIVE_INFINITY;
        data[3] = Double.NEGATIVE_INFINITY;

        for (IPFEM2DDrawableObject current : this.objects) {

            double bb[] = current.getBoundingBox();

            if (bb[0] < data[0]) {
                data[0] = bb[0];
            }
            if (bb[1] > data[1]) {
                data[1] = bb[1];
            }
            if (bb[2] < data[2]) {
                data[2] = bb[2];
            }
            if (bb[3] > data[3]) {
                data[3] = bb[3];
            }
        }

        return data;
    }

    /**
     * Renvoie la liste des points définissant l'objet graphique
     *
     * @return la liste des points
     */
    @Override
    public PFEM2DPoint[] getPoints() {
        ArrayList<PFEM2DPoint> listPts = new ArrayList<>();

        for (IPFEM2DDrawableObject current : this.objects) {
            PFEM2DPoint[] pts = current.getPoints();
            listPts.addAll(Arrays.asList(pts));
        }

        return listPts.toArray(new PFEM2DPoint[listPts.size()]);
    }
}

package plegatfem2d.objects;

import java.awt.Color;
import java.awt.Graphics;
import plegatfem2d.PFEM2DGuiPanel;

/**
 * Classe définissant un objet graphique de type "point"
 * @author Jean-Michel BORLOT
 */
public class PFEM2DPoint implements IPFEM2DDrawableObject {

    private double x, y;
    private long id;
    private boolean visible;
    
    /**
     * Constructeur
     * @param id l'identité du point
     * @param x l'abscisse du point
     * @param y l'ordonnée du point
     */
    public PFEM2DPoint(long id, double x, double y) {
        this.id = id;
        this.x = x;
        this.y = y;
        this.visible = true;
    }

    /**
     * Constructeur par défaut
     */
    public PFEM2DPoint() {
        this.id = 0;
        this.x = 0;
        this.y = 0;
        this.visible = false;
    }

    /**
     * Définit l'identité du point
     * @param id l'identité du point
     */
    public void setId(long id) {
        this.id = id;
    }

    /**
     * Renvoie l'abscisse du point
     * @return l'abscisse du point
     */
    public double getX() {
        return x;
    }

    /**
     * Définit l'abscisse du point
     * @param x l'abscisse du point
     */
    public void setX(double x) {
        this.x = x;
    }

    /**
     * Renvoie l'ordonnée du point
     * @return l'ordonnée du point
     */
    public double getY() {
        return y;
    }

    /**
     * Définit l'ordonnée du point
     * @param y l'ordonnée du point
     */
    public void setY(double y) {
        this.y = y;
    }

    /**
     * Dessine l'objet graphique
     * @param g l'objet Graphics sur lequel dessiner
     * @param panel l'objet PFEM2DGuiPanel sur lequel dessiner
     */
    @Override
    public void draw(Graphics g, PFEM2DGuiPanel panel) {

        if (this.isVisible()) {
            int xloc = panel.getLocalCoordX(this.x);
            int yloc = panel.getLocalCoordY(this.y);

            int[] xPoints = {xloc + 5, xloc - 5, xloc - 5, xloc + 5, xloc + 5};
            int[] yPoints = {yloc + 5, yloc + 5, yloc - 5, yloc - 5, yloc + 5};

            g.setColor(Color.cyan);
            g.drawPolyline(xPoints, yPoints, 5);

            // dessin id
            
            g.drawString("P" + this.id, xloc + 10, yloc + 10);
        }

    }

    /**
     * Définit la visibilité de l'objet graphique
     * @param flag true si l'objet est visible, false s'il ne l'est pas
     */
    @Override
    public void setVisible(boolean flag) {
        this.visible = flag;
    }

    /**
     * Renvoie l'état de visibilité de l'objet graphique
     * @return true si l'objet est visible, false s'il ne l'est pas
     */
    @Override
    public boolean isVisible() {
        return this.visible;
    }

    /**
     * Renvoie l'identité de l'objet graphique
     * @return l'identité de l'objet graphique
     */
    @Override
    public String getId() {
        return "Point " + this.id;
    }

    /**
     * Renvoie l'identité sous format numérique de l'objet graphique
     * @return l'identité sous format numérique de l'objet graphique
     */
    public long getNumId() {
        return this.id;
    }

    /**
     * Renvoie la distance du point à un autre point
     * @param pt l'autre point
     * @return la distance
     */
    public double getDistanceTo(PFEM2DPoint pt) {
        return Math.sqrt(Math.pow(pt.getX() - this.getX(), 2) + Math.pow(pt.getY() - this.getY(), 2));
    }

    /**
     * Constructeur par rotation du point courant 
     * @param centre le centre de la rotation
     * @param angle l'angle de la rotation
     * @return le nouveau point créé
     */
    public PFEM2DPoint getRotated(PFEM2DPoint centre, double angle) {

        double dx = this.getX() - centre.getX();
        double dy = this.getY() - centre.getY();

        double angleBase = Math.atan2(dy, dx);
        double radius = centre.getDistanceTo(this);

        double xRot = centre.getX() + radius * Math.cos(angleBase + angle / 180. * Math.PI);
        double yRot = centre.getY() + radius * Math.sin(angleBase + angle / 180. * Math.PI);

        return new PFEM2DPoint(0, xRot, yRot);
    }

    // méthode toString
    @Override
    public String toString() {
        
        return "Point #"+this.id+", x/y="+this.x+"/"+this.y;
        
    }

    /**
     * Renvoie la boite englobante de l'objet graphique
     * @return un tableau de 4 double: Xmin, Xmax, Ymin, Ymax
     */
    @Override
    public double[] getBoundingBox() {
        return new double[]{this.x,this.x,this.y,this.y};
    }

    /**
     * Renvoie la liste des points définissant l'objet graphique
     * @return la liste des points
     */
    @Override
    public PFEM2DPoint[] getPoints() {
        return new PFEM2DPoint[]{this};
    }
    
}

package plegatfem2d.objects;

import java.awt.Color;
import java.awt.Graphics;
import plegatfem2d.PFEM2DGuiPanel;

/**
 * Classe définissant un objet graphique de type "ligne", reliant deux points.
 * @author Jean-Michel BORLOT
 */
public class PFEM2DLine implements IPFEM2DDrawableObject, IPFEM2DCurve {

    private PFEM2DPoint pt1, pt2;   // les deux points définissant la ligne 
    private int id;                 // l'identité de la ligne
    private boolean visible;        // l'état de visibilité de la ligne
    
    /**
     * Constructeur
     * @param id identité
     * @param pt1 point n°1
     * @param pt2 point n°2
     */
    public PFEM2DLine(int id, PFEM2DPoint pt1, PFEM2DPoint pt2) {
        this.pt1 = pt1;
        this.pt2 = pt2;
        this.id = id;
        this.visible = true;
    }

    /**
     * Définit l'identité de la ligne
     * @param id l'identité de la ligne
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * Renvoie le premier point
     * @return le premier point
     */
    public PFEM2DPoint getPt1() {
        return pt1;
    }

    /**
     * Définit le premier point
     * @param pt1 le premier point
     */
    public void setPt1(PFEM2DPoint pt1) {
        this.pt1 = pt1;
    }

    /**
     * Renvoie le second point
     * @return le second point
     */
    public PFEM2DPoint getPt2() {
        return pt2;
    }

    /**
     * Définit le second point
     * @param pt2 le second point
     */
    public void setPt2(PFEM2DPoint pt2) {
        this.pt2 = pt2;
    }

    /**
     * Dessine l'objet graphique
     * @param g l'objet Graphics sur lequel dessiner
     * @param panel l'objet PFEM2DGuiPanel sur lequel dessiner
     */
    @Override
    public void draw(Graphics g, PFEM2DGuiPanel panel) {

        if (this.isVisible()) {
            int xloc1 = panel.getLocalCoordX(this.pt1.getX());
            int yloc1 = panel.getLocalCoordY(this.pt1.getY());

            int xloc2 = panel.getLocalCoordX(this.pt2.getX());
            int yloc2 = panel.getLocalCoordY(this.pt2.getY());

            g.setColor(Color.yellow);
            g.drawLine(xloc1, yloc1, xloc2, yloc2);
        }
    }

    /**
     * Définit la visibilité de l'objet graphique
     * @param flag true si l'objet est visible, false s'il ne l'est pas
     */
    @Override
    public void setVisible(boolean flag) {
        this.visible = flag;
    }

    /**
     * Renvoie l'état de visibilité de l'objet graphique
     * @return true si l'objet est visible, false s'il ne l'est pas
     */
    @Override
    public boolean isVisible() {
        return this.visible;
    }

    /**
     * Renvoie l'identité de l'objet graphique
     * @return l'identité de l'objet graphique
     */
    @Override
    public String getId() {
        return "Line " + this.id;
    }

    /**
     * Renvoie le point de départ de la courbe
     * @return le point de départ de la courbe
     */
    @Override
    public PFEM2DPoint getStartPoint() {
        return this.pt1;
    }

    /**
     * Renvoie le point d'arrivée de la courbe
     * @return le point d'arrivée de la courbe
     */
    @Override
    public PFEM2DPoint getEndPoint() {
        return this.pt2;
    }

    /**
     * Renvoie la boite englobante de l'objet graphique
     * @return un tableau de 4 double: Xmin, Xmax, Ymin, Ymax
     */
    @Override
    public double[] getBoundingBox() {
        
        double data[]=new double[4];
        
        data[0]=Math.min(this.pt1.getX(),this.pt2.getX());
        data[1]=Math.max(this.pt1.getX(),this.pt2.getX());
        data[2]=Math.min(this.pt1.getY(),this.pt2.getY());
        data[3]=Math.max(this.pt1.getY(),this.pt2.getY());
        
        return data;
    }

    /**
     * Renvoie la liste des points définissant l'objet graphique
     * @return la liste des points
     */
    @Override
    public PFEM2DPoint[] getPoints() {
        return new PFEM2DPoint[]{this.pt1,this.pt2};
    }
}