Comment afficher des points correctement dans un graphe ?

Bonjour à tous, très chers agrumes,

Contexte

Je souhaite afficher dans un graphe des points à deux coordonnées, lesquelles sont souvent (mais pas toujours) comprises entre -2 et 2 avec de nombreux chiffres après la virgule, et leur signe peut être négatif ou positif.

J’utilise donc un objet Graphics2D pour dessiner ces points (sous forme de rectangles 10x10). Voici ce que j’obtiens pour l’instant : Image utilisateur

Problème rencontré

Petit problème : la coordonnée Y semble inversée : les points les plus bas se retrouvent tout en haut, et les points les plus hauts, tout en bas.

Tentatives de résolution

Sur Stackoverflow, on m’a conseillé : 1. De récupérer le plus petit et le plus grand Y, et d’en faire la soustraction 2. D’utiliser un objet AffineTransform avec un setTranslate pour déplacer l’origine du graphe au plus petit Y 3. D’utiliser ce même objet avec un setScale en lui donnant la distance calculée au point 1, pour faire une mise à l’échelle correcte (actuellement, elle est issue d’une bidouille).

Or en appliquant cela, mes points sont beaucoup trop grands et mon graphe est tout rouge (ie. : rempli par au moins un point qui prend toute la place).

Bref je suis un peu perdu, et je ne sais pas quoi faire. Je voudrais juste que les points avec un grand Y soient en haut, et avec un petit Y en bas, comme sur n’importe quel graphique… !

Sources

Voici mon code (un extrait, j’ai sélectionné les lignes les plus pertinentes).

1. Récupération des plus petits X et Y (oui dans mon explication je m’étais limité à Y mais pour simplifier les choses) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

        x_min = Double.parseDouble((String) list_all_points.get(0).get(0));
        x_max = Double.parseDouble((String) list_all_points.get(0).get(0));
        y_min = Double.parseDouble((String) list_all_points.get(0).get(1));
        y_max = Double.parseDouble((String) list_all_points.get(0).get(1));
        for(StorableData s : list_all_points) {
            if(Double.parseDouble((String) s.get(0)) < x_min) {
                x_min = Double.parseDouble((String) s.get(0));
            }
            if(Double.parseDouble((String) s.get(0)) > x_max) {
                x_max = Double.parseDouble((String) s.get(0));
            }

            if(Double.parseDouble((String) s.get(1)) < y_min) {
                y_min = Double.parseDouble((String) s.get(1));
            }
            if(Double.parseDouble((String) s.get(1)) > y_max) {
                y_max = Double.parseDouble((String) s.get(1));
            }
        }

1. Utilisation de la soustraction y_max - y_min ET x_max - x_min dans une setAffineTransform :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@Override
            public void paint(Graphics graphics) {
                this.graphics = graphics;
                Graphics2D graphics_2d = ((Graphics2D) this.graphics);

                AffineTransform affine_transform = graphics_2d.getTransform();
                affine_transform.scale(getWidth()/(x_max - x_min), getHeight()/(y_max - y_min));
                affine_transform.translate(x_min, y_min);
                graphics_2d.transform(affine_transform);

                for(StorableData storable_data : list_all_points) { // Je dessine ici les points
                    graphics_2d.setColor(Color.WHITE);
                    this.drawPoint((Cupple) storable_data);
                }

1. Fonction qui dessine un point (et un label juste au-dessus) :

1
2
3
4
5
6
7
8
9

            int x, y;
            private void drawPoint(Cupple storable_data) {
                //x = (int) (storable_data.getNumber(0) * scaling_coef + move_x);
                //y = (int) (storable_data.getNumber(1) * scaling_coef + move_y);
                x = storable_data.getNumber(0).intValue();
                y = storable_data.getNumber(1).intValue();
                graphics.fillRect(x, y, 10, 10);
                graphics.drawString(storable_data.toString(), x - 5, y - 5);
            }

En fait il suffisait d’utiliser : y = -storable_data.getNumber(1).intValue(); (otez le "-" en fait) !

Le souci c’est que l’origine du repète est situé en haut à gauche, comme je l’ai dit. Donc si on va vers la droite, les x grandissent et si on va vers le bas, les y grandissent. D’où le "-" quoi !