Formule pour hexagone régulier

Résolu
fatalerror Messages postés 17 Date d'inscription dimanche 24 mars 2013 Statut Membre Dernière intervention 12 novembre 2017 - 3 sept. 2015 à 07:19
fatalerror Messages postés 17 Date d'inscription dimanche 24 mars 2013 Statut Membre Dernière intervention 12 novembre 2017 - 3 sept. 2015 à 13:48
Bonjour,
N'y aurais t-il pas un moyen plus simple de dessiner un hexagone régulier dont les dimensions sont passées en paramètres (dans le constructeur par exemple)?

En fait, je le fait juste à tâtons (j'entre les valeurs et je teste) et je ne suis même pas sûr que ce soit un hexagone régulier. Et pourtant je voudrais en faire plusieurs de dimensions différentes.
import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JPanel;

public class Hexagone extends JPanel {

public Color couleurHexagone;
//public Sommet sommet;

public Hexagone(Color c){
couleurHexagone = c;
}

public void paint(Graphics g){
g.setColor(couleurHexagone);
int x[] = {0, 80, 220, 300, 220, 80};
int y[] = {100, 20, 20, 100, 180, 180};
g.fillPolygon(x, y, 6);

}

}


import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Fenetre extends JFrame {

private static int largeurFenetre = 700,
hauteurFenetre = 500;

public Fenetre(String titre) {
super(titre);
Hexagone hex = new Hexagone(Color.gray);
hex.setBounds(100, 100, 300, 250);
add(hex);


setSize(largeurFenetre, hauteurFenetre);
setLocationRelativeTo(null);
setLayout(null);
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

public static void main(String args[]) {
new Fenetre("Test").setVisible(true);
}
}
A voir également:

1 réponse

KX Messages postés 16733 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 31 janvier 2024 127
Modifié par KX le 3/09/2015 à 10:06
Bonjour,

Mathématiquement, un polygone régulier doit avoir tous ses côtés de même longueur. En testant ton code on voit tout de suite que ce n'est pas le cas.


Les sommets d'un polygone régulier sont tous sur un même cercle.
Soit (x0,y0) le centre de ce cercle de rayon R, les sommets du polygone régulier à N côtés peuvent être calculés par :

x[i] = x0+R.cos(2i.pi/N+a)
y[i] = y0+R.sin(2i.pi/N+a)

Où a est un angle de rotation du polygone autour de son centre.

Exemple :

import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;

public class Polygone extends Component {
    private static final long serialVersionUID = 1L;

    private final Color color;

    private final int[] x;
    private final int[] y;

    public Polygone(int[] x, int[] y, Color color) {
        this.x = x;
        this.y = y;
        this.color = color;
    }

    public void paint(Graphics g) {
        g.setColor(color);
        g.fillPolygon(x, y, x.length);
    }
}

import java.awt.Color;
import java.awt.geom.Point2D;
import java.util.function.Function;

public class PolygoneRegulier extends Polygone {
    private static final long serialVersionUID = 1L;

    private static final int[] compute(double coord0, double rayon, int nbCotes, double rotation, Function<Double, Double> trigo) {
        int[] coord = new int[nbCotes];
        for (int i = 0; i < nbCotes; i++)
            coord[i] = (int) (coord0 + rayon * trigo.apply(2 * i * Math.PI / nbCotes + rotation));
        return coord;
    }

    public PolygoneRegulier(Point2D centre, double rayon, int nbCotes, double rotation, Color color) {
        super(compute(centre.getX(), rayon, nbCotes, rotation, Math::cos),
              compute(centre.getY(), rayon, nbCotes, rotation, Math::sin),
              color);
    }
}

import java.awt.Color;
import java.awt.geom.Point2D;

public class Hexagone extends PolygoneRegulier {
    private static final long serialVersionUID = 1L;

    public Hexagone(Point2D.Double centre, double rayon, double rotation, Color color) {
        super(centre, rayon, 6, rotation, color);
    }
}

Et dans ta classe Fenetre :

Hexagone hex = new Hexagone(new Point2D.Double(100, 100), 100, 0, Color.GRAY);

Ce qui donne un bel hexagone régulier (aux arrondis double → int près).
La confiance n'exclut pas le contrôle
3
fatalerror Messages postés 17 Date d'inscription dimanche 24 mars 2013 Statut Membre Dernière intervention 12 novembre 2017
3 sept. 2015 à 11:17
Merci déjà pour cette proposition de réponse.
Cependant ces petits bouts de codes me génèrent des erreurs.
Classe polygoneRegulier:
import java.util.function.Function;

L'erreur pour cette ligne est donc la suivante:
"The import java.util.function cannot be resolved"
Du coup, cela engendre des erreurs sur les bouts de codes suivants:
Function<Double, Double> trigo

et
Math::cos

Dans la classe Fenetre
Hexagone hex = new Hexagone(new Point2D.Double(100, 100), 100, 0, Color.GRAY);

Cette erreur stipule que ce constructeur n'est pas défini. Pourtant il est bel et bien defini.
0
KX Messages postés 16733 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 31 janvier 2024 127 > fatalerror Messages postés 17 Date d'inscription dimanche 24 mars 2013 Statut Membre Dernière intervention 12 novembre 2017
Modifié par KX le 3/09/2015 à 11:24
Je m'y attendais un peu... c'est du code Java 8, donc si tu développes avec une version antérieure c'est normal que tu ais ces erreurs.

Voici une alternative :

import java.awt.Color;
import java.awt.geom.Point2D;

public class PolygoneRegulier extends Polygone {
    private static final long serialVersionUID = 1L;

    private static final int[] computeX(double x0, double rayon, int nbCotes, double rotation) {
        int[] coord = new int[nbCotes];
        for (int i = 0; i < nbCotes; i++)
            coord[i] = (int) (x0 + rayon * Math.cos(2 * i * Math.PI / nbCotes + rotation));
        return coord;
    }
    
    private static final int[] computeY(double y0, double rayon, int nbCotes, double rotation) {
        int[] coord = new int[nbCotes];
        for (int i = 0; i < nbCotes; i++)
            coord[i] = (int) (y0 + rayon * Math.sin(2 * i * Math.PI / nbCotes + rotation));
        return coord;
    }

    public PolygoneRegulier(Point2D centre, double rayon, int nbCotes, double rotation, Color color) {
        super(computeX(centre.getX(), rayon, nbCotes, rotation),
              computeY(centre.getY(), rayon, nbCotes, rotation),
              color);
    }
}
0
fatalerror Messages postés 17 Date d'inscription dimanche 24 mars 2013 Statut Membre Dernière intervention 12 novembre 2017 > KX Messages postés 16733 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 31 janvier 2024
Modifié par fatalerror le 3/09/2015 à 13:23
Cette fois c'est ok! Du moins pour la classe PolygloneRegulier.
Mais seulement l'erreur de la classe Fenetre persiste:
Hexagone hex = new Hexagone(new Point2D.Double(100, 100), 100, 0, Color.GRAY);

Et la suggestion qui m'est faite est de:
- soit modifier le constructeur en ceci...
public Hexagone(Double double1, double rayon, double rotation, Color color)

- soit de créer plutôt le constructeur...
public Hexagone(Double double1, int rayon, int rotation, Color gray)
0
KX Messages postés 16733 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 31 janvier 2024 127 > fatalerror Messages postés 17 Date d'inscription dimanche 24 mars 2013 Statut Membre Dernière intervention 12 novembre 2017
3 sept. 2015 à 13:41
Il n'y a pas de raison...
Est-ce que tu as bien les import java.awt.geom.Point2D ?
Parce que Point2D.Double c'est super standard (depuis Java 2 !)

En alternative, tu peux faire new Point(100, 100) avec un java.awt.Point, mais le centre du cercle sera du coup de coordonnées de type int (au lieu de double avec Point2D.Double)

import java.awt.Point;
// ...
Hexagone hex = new Hexagone(new Point(100, 100), 100, 0, Color.GRAY);


Sinon, tu peux aussi décomposer l'objet Point, en deux paramètres x et y, comme ceci :

public PolygoneRegulier(double centreX, double centreY, double rayon, int nbCotes, double rotation, Color color) {
    super(computeX(centreX, rayon, nbCotes, rotation),
          computeY(centreY, rayon, nbCotes, rotation),
          color);
}

public Hexagone(double centreX, double centreY, double rayon, double rotation, Color color) {
    super(centreX, centreY, rayon, 6, rotation, color);
}

Hexagone hex = new Hexagone(100, 100, 100, 0, Color.GRAY);

Mais bon, tout ça c'est du détail, la vraie réponse à ta question est là :

x[i] = x0+R.cos(2i.pi/N+a)
y[i] = y0+R.sin(2i.pi/N+a)
0
fatalerror Messages postés 17 Date d'inscription dimanche 24 mars 2013 Statut Membre Dernière intervention 12 novembre 2017 > KX Messages postés 16733 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 31 janvier 2024
3 sept. 2015 à 13:48
OK, Merci bien KX!
Je pense pouvoir m'en sortir maintenant!!!
0
Rejoignez-nous