Formule pour hexagone régulier [Résolu]

fatalerror 18 Messages postés dimanche 24 mars 2013Date d'inscription 12 novembre 2017 Dernière intervention - 3 sept. 2015 à 07:19 - Dernière réponse : fatalerror 18 Messages postés dimanche 24 mars 2013Date d'inscription 12 novembre 2017 Dernière intervention
- 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);
}
}
Afficher la suite 

6 réponses

Répondre au sujet
KX 15359 Messages postés samedi 31 mai 2008Date d'inscriptionModérateurStatut 18 avril 2018 Dernière intervention - Modifié par KX le 3/09/2015 à 10:06
+1
Utile
5
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
Cette réponse vous a-t-elle aidé ?  
fatalerror 18 Messages postés dimanche 24 mars 2013Date d'inscription 12 novembre 2017 Dernière intervention - 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.
KX 15359 Messages postés samedi 31 mai 2008Date d'inscriptionModérateurStatut 18 avril 2018 Dernière intervention > fatalerror 18 Messages postés dimanche 24 mars 2013Date d'inscription 12 novembre 2017 Dernière intervention - 3 sept. 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);
    }
}
fatalerror 18 Messages postés dimanche 24 mars 2013Date d'inscription 12 novembre 2017 Dernière intervention > KX 15359 Messages postés samedi 31 mai 2008Date d'inscriptionModérateurStatut 18 avril 2018 Dernière intervention - 3 sept. 2015 à 13:22
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)
KX 15359 Messages postés samedi 31 mai 2008Date d'inscriptionModérateurStatut 18 avril 2018 Dernière intervention > fatalerror 18 Messages postés dimanche 24 mars 2013Date d'inscription 12 novembre 2017 Dernière intervention - 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)
fatalerror 18 Messages postés dimanche 24 mars 2013Date d'inscription 12 novembre 2017 Dernière intervention > KX 15359 Messages postés samedi 31 mai 2008Date d'inscriptionModérateurStatut 18 avril 2018 Dernière intervention - 3 sept. 2015 à 13:48
OK, Merci bien KX!
Je pense pouvoir m'en sortir maintenant!!!
Commenter la réponse de KX

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.