Détection de cercle

Version imprimable

4 pièce(s) jointe(s)

Détection de cercle

Bonjour,

Ayant fini mon premier programme java, je me lance dans une autre application qui serai complémentaire de la première ( voir même ajoute la fonctionnalité).

Mais la je suis dans un domaine ou je n'y connais pas grand chose...

J'arrive a détecter un cercle mais j'aimerai pouvoir tous les détecter et récupérer les distances entre chaque cercle (en pixels) .

Voici l'image de départ : Pièce jointe 502800

Avec ce code que j'ai trouvé sur internet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.RescaleOp;
import java.io.File;
 
public class CircleDetection {
    private static BufferedImage grey;
    private static int[][] sobelX;
    private static int[][] sobelY;
    private static double[][] sobelTotal;
    private static String path = System.getProperty("user.dir");
    private static int maxX = 0;
    private static int maxY = 0;
    private static int maxR = 0;
    private static int threshold = 300;
 
    public static void main(String[] args) throws Exception{
        //ensures all the file systems required are in order
        File originalFile = new File("test5.png");
        File originalDirectory = new File(path+"\\result");
        if(!(originalDirectory.exists() && originalDirectory.isDirectory())){
            try{
                originalDirectory.mkdir();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
 
        //runs the required processes for circle detection, ie sobel edge detection
        toGrayScale(originalFile);
        edgeDetection();
 
        //creates and outputs images for the sobel sweep in x and y direction, and the combined sobel output
        BufferedImage img = new BufferedImage(grey.getWidth(), grey.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
        for(int i = 0; i< grey.getWidth(); i++){
            for(int j = 0; j<grey.getHeight(); j++){
                img.setRGB(i, j, sobelX[i][j]);
            }
        }
        File outX = new File(path+"\\result\\sobelX.png");
        ImageIO.write(img, "png", outX);
 
        BufferedImage ing = new BufferedImage(grey.getWidth(), grey.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
        for(int i = 0; i< grey.getWidth(); i++){
            for(int j = 0; j<grey.getHeight(); j++){
                ing.setRGB(i, j, sobelY[i][j]);
            }
        }
        File outY = new File(path+"\\result\\sobelY.png");
        ImageIO.write(ing, "png", outY);
 
        BufferedImage total = new BufferedImage(grey.getWidth(), grey.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
        double max = 0;
        for(int i = 0; i< grey.getWidth(); i++){
            for(int j = 0; j<grey.getHeight(); j++){
                if(sobelTotal[i][j]>max){
                    max = sobelTotal[i][j];
                }
            }
        }
        for(int i = 0; i< grey.getWidth(); i++){
            for(int j = 0; j<grey.getHeight(); j++){
                //maps every pixel to a grayscale value between 0 and 255 from between 0 and the max value in sobelTotal
                int rgb = new Color((int)map(sobelTotal[i][j], 0,max,0,255),
                        (int)map(sobelTotal[i][j], 0,max,0,255),
                        (int)map(sobelTotal[i][j], 0,max,0,255), 255).getRGB();
                total.setRGB(i,j,rgb);
            }
        }
        total = changeBrightness(20.0f, total);
        File out2 = new File(path+"\\result\\sobelTotal.png");
        ImageIO.write(total, "png", out2);
 
        //outputs an image showing every pixel that is above the threshold
        BufferedImage totalColour = new BufferedImage(grey.getWidth(), grey.getHeight(), BufferedImage.TYPE_INT_ARGB);
        for(int i = 0; i < grey.getWidth(); i++) {
            for(int j = 0; j < grey.getHeight(); j++) {
                Color c1 = new Color(0,255,0);
                if(sobelTotal[i][j] > threshold) {
                    totalColour.setRGB(i, j, c1.getRGB());
                }
            }
        }
        File outThreshold = new File(path+"\\result\\totalGreen.png");
        ImageIO.write(totalColour, "png", outThreshold);
 
        //runs circle detection and outputs an image of the original with the circle detected superimposed in red
        BufferedImage totalCircles = new BufferedImage(grey.getWidth(), grey.getHeight(), BufferedImage.TYPE_INT_ARGB);
        circleDetection(total);
        total = changeBrightness(0.5f, total);
        totalCircles.getGraphics().drawImage(total, 0, 0, null);
        Graphics2D g = totalCircles.createGraphics();
        g.setColor(Color.RED);
        double a =  maxX - maxR * Math.cos(0 * Math.PI / 180);
        double b =  maxY - maxR * Math.sin(90 * Math.PI / 180);
        g.drawOval((int)a,(int)b,2*maxR,2*maxR);
        File outfinal = new File(path+"\\result\\totalCircles.png");
        ImageIO.write(totalCircles, "png", outfinal);
    }
 
    //maps the given value between startCoord1 and endCoord1 to a value between startCoord2 and endCoord2
    private static double map(double valueCoord1,
                              double startCoord1, double endCoord1,
                              double startCoord2, double endCoord2) {
 
 
        double ratio = (endCoord2 - startCoord2) / (endCoord1 - startCoord1);
        return ratio * (valueCoord1 - startCoord1) + startCoord2;
    }
 
    //converts given file into a grayscale image
    private static void toGrayScale(File f) throws Exception{
        BufferedImage img = ImageIO.read(f);
        grey = new BufferedImage(img.getWidth(), img.getHeight(), img.TYPE_BYTE_GRAY);
        grey.getGraphics().drawImage(img, 0 , 0, null);
    }
 
    //runs all the functions required to complete edge detection
    private static void edgeDetection(){
        calcSobelX();
        calcSobelY();
        combineSobel();
    }
 
    //performs the horizontal sobel sweep, sets up the matrix using a 3x3 array and runs through
    //every pixel to calculate the sobel result
    private static void calcSobelX(){
        sobelX = new int[grey.getWidth()][grey.getHeight()];
        int[][] base = new int[3][3];
        base[0][0] = -1;
        base[1][0] = -2;
        base[2][0] = -1;
        base[0][1] = 0;
        base[1][1] = 0;
        base[2][1] = 0;
        base[0][2] = 1;
        base[1][2] = 2;
        base[2][2] = 1;
 
 
        for(int i = 0; i<grey.getWidth(); i++){
            for(int j = 0; j<grey.getHeight();j++){
                sobelX[i][j] = getSobelResult(i,j,base);
            }
        }
    }
 
    //performs the vertical sobel sweep, sets up the matrix using a 3x3 array and runs through
    //every pixel to calculate the sobel result
    private static void calcSobelY(){
        sobelY = new int[grey.getWidth()][grey.getHeight()];
        int[][] base = new int[3][3];
        base[0][0] = -1;
        base[0][1] = -2;
        base[0][2] = -1;
        base[1][0] = 0;
        base[1][1] = 0;
        base[1][2] = 0;
        base[2][0] = 1;
        base[2][1] = 2;
        base[2][2] = 1;
 
 
        for(int i = 0; i<grey.getWidth(); i++){
            for(int j = 0; j<grey.getHeight();j++){
                sobelY[i][j] = getSobelResult(i,j,base);
            }
        }
    }
 
    //a series of if statements to account for any edge cases to ensure no errors, calculates
    //the sobel result for any pixel and kernel
    private static int getSobelResult(int x, int y, int[][] base){
        int result = 0;
        if(x==0 && y ==0){
            for(int i = 0; i <= 1; i++){
                for(int j = 0; j <= 1; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }else if(x==0 && y==grey.getHeight()-1){
            for(int i = 0; i <= 1; i++){
                for(int j = -1; j <= 0; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }else if(x==0 && y !=0){
            for (int i = 0; i <= 1; i++) {
                for (int j = -1; j <= 1; j++) {
                    result += new Color(grey.getRGB(x + i, y + j)).getRed()* base[j + 1][i + 1];
                }
            }
 
        }else if(x==grey.getWidth()-1 && y ==0){
            for(int i = -1; i <= 0; i++){
                for(int j = 0; j <= 1; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }else if(x!=0 && y ==0){
            for(int i = -1; i <= 1; i++){
                for(int j = 0; j <= 1; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }else if(x==grey.getWidth()-1 && y==grey.getHeight()-1){
            for(int i = -1; i <= 0; i++){
                for(int j = -1; j <= 0; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }else if(x==grey.getWidth()-1 && y!=grey.getHeight()-1){
            for(int i = -1; i <= 0; i++){
                for(int j = -1; j <= 1; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }else if(x!=grey.getWidth()-1 && y==grey.getHeight()-1){
            for(int i = -1; i <= 1; i++){
                for(int j = -1; j <= 0; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }else{
            for(int i = -1; i <= 1; i++){
                for(int j = -1; j <= 1; j++){
                    result += new Color(grey.getRGB(x+i,y+j)).getRed()*base[j+1][i+1];
                }
            }
        }
 
        return result;
    }
 
    //performs the algorithm to combine the horizontal sweep and vertical sweep
    private static void combineSobel(){
        sobelTotal = new double[grey.getWidth()][grey.getHeight()];
        for(int i = 0; i <grey.getWidth(); i++){
            for(int j = 0; j<grey.getHeight(); j++){
                sobelTotal[i][j] = Math.round(Math.sqrt(Math.pow((double)sobelX[i][j],2) + Math.pow((double)sobelY[i][j],2)));
            }
        }
    }
 
    private static void circleDetection(BufferedImage image) throws Exception {
        //sets the radius relative to 1/6 of the smallest side of the image, helps reduce space taken in memory during
        //runtime
        int radius;
        if (image.getHeight() < image.getWidth()) {
            radius = image.getHeight() / 6;
        } else {
            radius = image.getWidth() / 6;
        }
        //sets a 3D space array of ints to hold 'hits' in x, y, and r planes
        int[][][] A = new int[image.getWidth()][image.getHeight()][radius];
 
        BufferedImage newImage = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB);
        for (int rad = 0; rad < radius; rad++) {
            for (int x = 0; x < newImage.getWidth(); x++) {
                for (int y = 0; y < newImage.getHeight(); y++) {
                    //if the given pixel is above the threshold, a circle will be drawn at radius rad around it and if it
                    //is a valid coordinate it will be accumulated in the A array and plotted in the pointSpace image
                    if (sobelTotal[x][y] > threshold) {
                        for (int t = 0; t <= 360; t++) {
                            Integer a = (int) Math.floor(x - rad * Math.cos(t * Math.PI / 180));
                            Integer b = (int) Math.floor(y - rad * Math.sin(t * Math.PI / 180));
                            if (!((0 > a || a > newImage.getWidth() - 1) || (0 > b || b > newImage.getHeight() - 1))) {
                                Color c = new Color(newImage.getRGB(a, b));
                                Color c1;
                                if (c.getBlue() == 255) {
                                    c1 = new Color(c.getRed(), c.getGreen() + 1, 0);
                                } else if (c.getGreen() == 255) {
                                    c1 = new Color(c.getRed() + 1, 0, c.getBlue());
                                } else {
                                    c1 = new Color(c.getRed(), c.getGreen(), c.getBlue() + 1);
                                }
                                newImage.setRGB(a, b, c1.getRGB());
                                if (!(a.equals(x) && b.equals(y))) {
                                    A[a][b][rad] += 1;
                                }
                            }
                        }
                    }
                }
            }
        }
        //iterates to find the max value in the A array
        int max = 0;
        for (int x = 0; x < image.getWidth(); x++) {
            for (int y = 0; y < image.getHeight(); y++) {
                for (int r = 5; r < radius; r++) {
                    if (A[x][y][r] > max) {
                        max = A[x][y][r];
                        maxX = x;
                        maxY = y;
                        maxR = r;
                    }
                }
            }
        }
        //outputs the pointSpace image
        System.out.println(maxX + " " + maxY + " " + maxR);
        File newfile = new File(path + "\\result\\pointSpace.png");
        ImageIO.write(newImage, "png", newfile);
    }
 
    //changes the brightness of an image by the factor given
    private static BufferedImage changeBrightness(float brightenFactor, BufferedImage image){
        RescaleOp op = new RescaleOp(brightenFactor, 0, null);
        image = op.filter(image, image);
        return image;
    }
}

J'arrive a avoir ceci :

Pièce jointe 502801

[ATTACH=CONFIG]502803[/ATTACH

Pièce jointe 502806

J'ai essayé de comprendre le code mais sans trop de succès.

J'aimerai avoir des petite explication pour pouvoir réaliser mon projet

Cordialement

Fred

Bonjour,

Ayant eu un peu de temps aujourd'hui, j'ai essayé de comprendre le code.

Je le comprend en grande partie. D’après ce que j'ai compris, je doit rajouter une boucle "for".

Si je ne dit pas de bêtise, je doit la rajouter dans cet partie du code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
private static void circleDetection(BufferedImage image) throws Exception {
        //sets the radius relative to 1/6 of the smallest side of the image, helps reduce space taken in memory during
        //runtime
        int radius;
        if (image.getHeight() < image.getWidth()) {
            radius = image.getHeight() / 6;
        } else {
            radius = image.getWidth() / 6;
        }
        //sets a 3D space array of ints to hold 'hits' in x, y, and r planes
        int[][][] A = new int[image.getWidth()][image.getHeight()][radius];
 
        BufferedImage newImage = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB);
        for (int rad = 0; rad < radius; rad++) {
            for (int x = 0; x < newImage.getWidth(); x++) {
                for (int y = 0; y < newImage.getHeight(); y++) {
                    //if the given pixel is above the threshold, a circle will be drawn at radius rad around it and if it
                    //is a valid coordinate it will be accumulated in the A array and plotted in the pointSpace image
                    if (sobelTotal[x][y] > threshold) {
                        for (int t = 0; t <= 360; t++) {
                            Integer a = (int) Math.floor(x - rad * Math.cos(t * Math.PI / 180));
                            Integer b = (int) Math.floor(y - rad * Math.sin(t * Math.PI / 180));
                            if (!((0 > a || a > newImage.getWidth() - 1) || (0 > b || b > newImage.getHeight() - 1))) {
                                Color c = new Color(newImage.getRGB(a, b));
                                Color c1;
                                if (c.getBlue() == 255) {
                                    c1 = new Color(c.getRed(), c.getGreen() + 1, 0);
                                } else if (c.getGreen() == 255) {
                                    c1 = new Color(c.getRed() + 1, 0, c.getBlue());
                                } else {
                                    c1 = new Color(c.getRed(), c.getGreen(), c.getBlue() + 1);
                                }
                                newImage.setRGB(a, b, c1.getRGB());
                                if (!(a.equals(x) && b.equals(y))) {
                                    A[a][b][rad] += 1;
                                }
                            }
                        }
                    }
                }
            }
        }

Mais je ne vois pas du tout ou....

J'ai essayé quelque essaie mais sans succès.

Je vous remercie du coup de pouce par avance.

Cordialement

Fred

15/09/2019, 23h58
bouye

A noter qu'un petit tour dans le forum algorithmie/image peut s’avérer utile vu que ce code n'utilise pas vraiment d'API particulière propre a Java (a part pour faire le seuillage)

1 pièce(s) jointe(s)

Bonjour,

J'ai réussi a détecter l'ensemble des cercle le calcul est beaucoup trop long... plus de 10 minutes.

Alors je suis partie sur quelque chose de beaucoup plus simple et ca marche pas trop mal.

Je suis bloqué par un problème que je pensais résoudre mais je tourne en rond alors que je suis certain que j'ai la réponse sous les yeux;

Alors de mon image de base je fais ce traitement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * Convertir une image en nuance de gris
 * @author Axel - ® fobec.com 2010
 */
public class ImageGrayScale {
 
 
 
    static int test = 1;
 
 
   private static int y = 0;
    private static int x = 0;
 
    /**
     * Image d'entrée en couleur
     */
    private static String inFilename = "test10.png";
    /**
     * Image de sortie en nuance de gris
     */
    private static String outFilename = "TEST.png";
 
    public static void main(String args[]) {
 
 
 
 
        try {
            System.out.println("Début de conversion....");
            //Ouverture du fichier
            File inputFile = new File(inFilename);
            BufferedImage imagesrc = ImageIO.read(inputFile);
            //Convertion en grisé
            BufferedImage imagedst = new BufferedImage(imagesrc.getWidth(), imagesrc.getHeight(), BufferedImage.TYPE_INT_RGB);
 
 
 
 
 
 
       //     BufferedImage.TYPE_INT_RGB);
            for (x = 0; x < imagesrc.getWidth(); x++) {
                    for (y = 0; y < imagesrc.getHeight(); y++) {
 
                        // recuperer couleur de chaque pixel
                        Color pixelcolor = new Color(imagesrc.getRGB(x, y));
 
                        // recuperer les valeur rgb (rouge ,vert ,bleu) de cette couleur
                        int r = pixelcolor.getRed();
                        int g = pixelcolor.getGreen();
                        int b = pixelcolor.getBlue();
 
                        if (r < 10 && g < 10 && b < 10) {
                            r = 0;
                            g = 255;
                            b = 0;
 
                            System.out.println  ( "position y " + y);
                            System.out.println  ( "position x " + x);
 
                        } else {
                            // faire l'inversion
                            r = 0;
                            g = 0;
                            b = 0;
                        }
 
                        int rgb = new Color(r, g, b).getRGB();
                        // changer la couleur de pixel avec la nouvelle couleur inversée
                        imagesrc.setRGB(x, y, rgb);
                    }
                 }
 
            Graphics g = imagedst.getGraphics();
            g.drawImage(imagesrc, 0, 0, null);
            g.dispose();
            //Enregistrer l'image au format PNG
            File outFile = new File(outFilename);
            ImageIO.write(imagedst, "PNG", outFile);
            System.out.println("Fin de conversion....");
        } catch (IOException ex) {
            Logger.getLogger(ImageGrayScale.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

ca me donne ceci Pièce jointe 503729

une image assez propre mais je bloque.

J'arrive a détermine la position de chaque pixel vert mais j'aimerai trouve le centre de chaque "groupe de pixel", je ne vois pas comment faire.

Je cherche a trouver le centre de chaque groupe de pixel pour déterminer les distances entre chaque point.

Merci

Fred

Salut,

Il y a moyen très simple: détecter les rectangles qui englobent les cercles (ce qu'on appelle les bounds).

Pour détecter les rectangles, il suffit de parcourir les lignes de haut en bas et pour chaque ligne :

on prend la couleur du premier point et on parcourt les points suivants, de gauche à droite, en comparant leur couleur à ce premier point
on prend la couleur du dernier point et on parcourt les points suivants, de droite à gauche, en comparant leur couleur à ce dernier point
Si on trouve un point de couleur différente, on mémorise la position, ce qui nous donne une "largeur" entre le point détecté par la gauche et celui par la droite, le maximum de toutes ces largeurs étant la largeur du rectangle entre deux lignes vides, la hauteur étant la distance entre la première non vide et la dernière non vide...

Démo :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.RescaleOp;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
 
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class DistanceEntreCentresDesCercles {
 
	private static Path IMAGE_PATH = Paths.get("TEST.png");
 
	public static void main(String[] args) throws IOException {
 
		BufferedImage image = ImageIO.read(IMAGE_PATH.toFile()); 
 
		List<Ellipse2D> ellipses = getEllipses(image);
 
		for(int i=1; i<ellipses.size(); i++) {
			System.out.printf("Distance entre centre entre %d et %d: %dpx%n", i-1, i, 
					(int)(ellipses.get(i).getCenterY()-ellipses.get(i-1).getCenterY()) );
 		}
 
		JFrame frame = new JFrame("Affichage images");
 
		JPanel images = new JPanel(new GridBagLayout());
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.insets = new Insets(5,5,5,5);
		gbc.gridy=0;
		gbc.gridx=GridBagConstraints.RELATIVE;
 
		frame.add(images);
 
		images.add(new JLabel(new ImageIcon(image))); 
		images.add(new JLabel(new ImageIcon(createImage(image.getWidth(), image.getHeight(),ellipses,
				(g,e)->g.draw(e.getBounds2D())))));
		images.add(new JLabel(new ImageIcon(createImage(image.getWidth(), image.getHeight(),ellipses,
				(g,e)->g.draw(e)))));
 
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static BufferedImage createImage(int width, int height, List<Ellipse2D> ellipses, BiConsumer<Graphics2D, Ellipse2D> consumer) {
		BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
		Graphics2D g = image.createGraphics();
		g.setColor(Color.WHITE);
		ellipses.forEach(e-> consumer.accept(g, e));
		g.dispose();
		return image;
	}
 
	private static List<Ellipse2D> getEllipses(BufferedImage image) {
		return getRectangles(image).stream()
				.map(rect-> new Ellipse2D.Double(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()))
				.collect(Collectors.toList());
	}
 
	private static List<Rectangle2D> getRectangles(BufferedImage image) {
 
		List<Rectangle2D> rectangles = new ArrayList<>();
 
		int height = image.getHeight();
		int width = image.getWidth();
 
		int ym=-1;
		int minl=width-1;
		int maxr=0;
		for(int y=0; y<height; y++) {
			int xl= getPointDifferent(image.getRGB(0, y),image,y,
					IntStream.iterate(1, x-> x<width, x-> x+1)); 
			if (xl>=0 ) {
				if ( ym==-1) ym=y;
				int xr= getPointDifferent(image.getRGB(width-1, y),image,y,
						IntStream.iterate(width-1, x-> x>=xl, x-> x-1)); 
				minl = Math.min(xl, minl);
				maxr = Math.max(xr, maxr);
			}
			else {
				// ligne vide
				if( ym!=-1) {
					// on a un rectangle
					rectangles.add(new Rectangle2D.Double(minl,ym,maxr-minl,y-ym));
					minl=width-1;
					maxr=0;
					ym=-1;
				}
			}
		}
 
		return rectangles;
 
	}
 
	private static int getPointDifferent(int rgb, 
			BufferedImage image, int y, IntStream iterate) {
		return iterate
				.filter(x-> rgb!=image.getRGB(x, y))
				.findFirst().orElse(-1);
	} 
 
}

Dans ton image, il y a quelques défauts qu'on peut éliminer en filtrant les rectangles "petits".

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.RescaleOp;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
 
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class DistanceEntreCentresDesCercles {
 
	private static Path IMAGE_PATH = Paths.get("TEST.png");
 
	private static int MIN_SIZE = 5;
 
	public static void main(String[] args) throws IOException {
 
		BufferedImage image = ImageIO.read(IMAGE_PATH.toFile()); 
 
		List<Ellipse2D> ellipses = getEllipses(image);
 
		for(int i=1; i<ellipses.size(); i++) {
			System.out.printf("Distance entre centre entre %d et %d: %dpx%n", i-1, i, 
					(int)(ellipses.get(i).getCenterY()-ellipses.get(i-1).getCenterY()) );
 		}
 
		JFrame frame = new JFrame("Affichage images");
 
		JPanel images = new JPanel(new GridBagLayout());
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.insets = new Insets(5,5,5,5);
		gbc.gridy=0;
		gbc.gridx=GridBagConstraints.RELATIVE;
 
		frame.add(images);
 
		images.add(new JLabel(new ImageIcon(image))); 
		images.add(new JLabel(new ImageIcon(createImage(image.getWidth(), image.getHeight(),ellipses,
				(g,e)->g.draw(e.getBounds2D())))));
		images.add(new JLabel(new ImageIcon(createImage(image.getWidth(), image.getHeight(),ellipses,
				(g,e)->g.draw(e)))));
 
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static BufferedImage createImage(int width, int height, List<Ellipse2D> ellipses, BiConsumer<Graphics2D, Ellipse2D> consumer) {
		BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
		Graphics2D g = image.createGraphics();
		g.setColor(Color.WHITE);
		ellipses.forEach(e-> consumer.accept(g, e));
		g.dispose();
		return image;
	}
 
	private static List<Ellipse2D> getEllipses(BufferedImage image) {
		return getRectangles(image).stream()
				.filter(rect->rect.getWidth()>MIN_SIZE&&rect.getHeight()>MIN_SIZE)
				.map(rect-> new Ellipse2D.Double(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()))
				.collect(Collectors.toList());
	}
 
	private static List<Rectangle2D> getRectangles(BufferedImage image) {
 
		List<Rectangle2D> rectangles = new ArrayList<>();
 
		int height = image.getHeight();
		int width = image.getWidth();
 
		int ym=-1;
		int minl=width-1;
		int maxr=0;
		for(int y=0; y<height; y++) {
			int xl= getPointDifferent(image.getRGB(0, y),image,y,
					IntStream.iterate(1, x-> x<width, x-> x+1)); 
			if (xl>=0 ) {
				if ( ym==-1) ym=y;
				int xr= getPointDifferent(image.getRGB(width-1, y),image,y,
						IntStream.iterate(width-1, x-> x>=xl, x-> x-1)); 
				minl = Math.min(xl, minl);
				maxr = Math.max(xr, maxr);
			}
			else {
				// ligne vide
				if( ym!=-1) {
					// on a un rectangle
					rectangles.add(new Rectangle2D.Double(minl,ym,maxr-minl,y-ym));
					minl=width-1;
					maxr=0;
					ym=-1;
				}
			}
		}
 
		return rectangles;
 
	}
 
	private static int getPointDifferent(int rgb, 
			BufferedImage image, int y, IntStream iterate) {
		return iterate
				.filter(x-> rgb!=image.getRGB(x, y))
				.findFirst().orElse(-1);
	} 
 
}

Bonjour et merci joel.drigo.

Je fais des test avec la démo qui vous m'avez proposé pour essayé de comprendre le code.

C'est super intéressant mais dur a la fois XD.

Je me demandais d’ailleurs pour simplifié si ont peu récupérer simplement les centres des rectangles du coup qui reviens a avoir les même centre que les cercles?

Ont pourrai gagné quelque ligne de code.

Quand vous parle de filtrer les "petit rectangle", vous faite references a la deuxieme ligne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Distance entre centre entre 2 et 3: 59px Distance entre centre entre 3 et 4: 6px Distance entre centre entre 4 et 5: 58px Distance entre centre entre 5 et 6: 61px Distance entre centre entre 6 et 7: 49px Distance entre centre entre 7 et 8: 59px Distance entre centre entre 8 et 9: 49px Distance entre centre entre 9 et 10: 51px Distance entre centre entre 10 et 11: 56px Distance entre centre entre 11 et 12: 45px Distance entre centre entre 12 et 13: 48px Distance entre centre entre 13 et 14: 48px Distance entre centre entre 14 et 15: 36px Distance entre centre entre 15 et 16: 43px Distance entre centre entre 16 et 17: 44px Distance entre centre entre 17 et 18: 36px Distance entre centre entre 18 et 19: 28px Distance entre centre entre 19 et 20: 27px Distance entre centre entre 20 et 21: 32px Distance entre centre entre 21 et 22: 39px
qui m'affiche le rectangle de 6PX.

Doit je filtre via une simple condition "if"?

Merci

Fred

Citation:

Envoyé par R1beLlu2B

Je me demandais d’ailleurs pour simplifié si ont peu récupérer simplement les centres des rectangles du coup qui reviens a avoir les même centre que les cercles?

Oui, oui, je transforme en Ellipse2D dans mon code juste pour les dessiner pour voir ce que ça donne. Il y a d'ailleurs peut-être quelques ajustements à faire, j'ai tapé ça vite, y'a peut-être une différence d'un pixels sur la largeur ou la hauteur. Mais tu peux créer des Point2D au lieu des Ellipses, ou calculer récupérer directement les centres des Rectangle2D lors de leur construction :
Code:

1 2 3 4 5 6 7 8 9 // ligne vide if (ym != -1) { // on a un rectangle Rectangle2D rect = new Rectangle2D.Double(minl, ym, maxr - minl, y - ym); points.add(new Point2D.Double(rect.getCenterX(),rect.getCenterY()); minl = width - 1; maxr = 0; ym = -1; }
(on peut même se passer de Rectangle2D en utilisant directement des calculs)

En adaptant le reste bien sûr.

Citation:

Envoyé par R1beLlu2B

Quand vous parle de filtrer les "petit rectangle", vous faite references a la deuxieme ligne :

Oui c'est dû à l'imperfection des "points" verts, y'a des pixels qui dépassent quoi.

Citation:

Envoyé par R1beLlu2B

Doit je filtre via une simple condition "if"?

On peut, ou alors on filtre lors du stream comme j'ai mis dans mon second code. ou directement au moment de la création du point.
Code:

1 2 3 4 5 6 7 8 9 10 11 // ligne vide if (ym != -1) { // on a un rectangle Rectangle2D rect = new Rectangle2D.Double(minl, ym, maxr - minl, y - ym); if ( rect.getWidth()>MIN_SIZE && rect.getHeight()>MIN_SIZE ) { points.add(new Point2D.Double(rect.getCenterX(),rect.getCenterY()); } minl = width - 1; maxr = 0; ym = -1; }

17/09/2019, 19h36
R1beLlu2B

D'accord,

je vais essayer de m'amusé avec tous ca et voir ce que je peu faire.

Je ferai un retour.

Merci joel.drigo

Cordialement

Fred

Bonjour,

J'arrive petit a petit a adapter une partie du code dans mon projet.

Je bloque sur quelque chose que je ne comprend pas du tout :
Code:

1 2 3 4 5 for(int i=1; i<ellipses.size(); i++) { System.out.printf("Distance entre centre entre %d et %d: %dpx%n", i-1, i, (int)(ellipses.get(i).getCenterY()-ellipses.get(i-1).getCenterY()) ); }
J'ai essayé de récupérer les valeurs pour les rentrer dans un tableau mais je bloque, surtout avec :

Code:

"....%d et %d: %dpx%n"

J'ai compris que c'est les distances entre chaque point mais comment les utiliser?

Merci

Fred

Citation:
Envoyé par R1beLlu2B
Je bloque sur quelque chose que je ne comprend pas du tout :
Code:

1 2 3 4 5 for(int i=1; i<ellipses.size(); i++) { System.out.printf("Distance entre centre entre %d et %d: %dpx%n", i-1, i, (int)(ellipses.get(i).getCenterY()-ellipses.get(i-1).getCenterY()) ); }
J'ai essayé de récupérer les valeurs pour les rentrer dans un tableau mais je bloque, surtout avec :

Code:

"....%d et %d: %dpx%n"
Cette partie c'est un formatage pour l'affichage
Code:

1 2 3 4 for(int i=1; i<ellipses.size(); i++) { double distance = ellipses.get(i).getCenterY()-ellipses.get(i-1).getCenterY(); // calcul de la distance entre le centre de l'ellipse courante et la précédente // là tu en fais ce que tu en veux, avec la variable distance }

Bonsoir,

Merci beaucoup pour les précieuses aide apporte :)

Voila ce que j'ai fais :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
public class ImageGrayScale {
 
 
    public final static String IMAGE_TYPE_JPEG = "jpeg";
    public final static String IMAGE_TYPE_GIF = "gif";
    public final static String IMAGE_TYPE_PNG = "png";
 
    static JFrame frame = new JFrame("Affichage images");
 
   private static int y = 0;
    private static int x = 0;
    static int distance = 0;
    /**
     * Image d'entrée en couleur
     */
    private static String inFilename = "test2.png";
    /**
     * Image de sortie en nuance de gris
     */
    private static String outFilename = "TEST.png";
 
    ImageGrayScale() {
        testsceen.screenShot(
 
                //Les Dimensions de l'ecran que tu veux
                new Rectangle(1140, 130, 280, 1180),
 
                //Les Dimensions de l'image de l'ecran
                new Dimension(280, 1180)
 
                //format de l'image resultante
 
        );
 
        try {
            System.out.println("Début de conversion....");
            //Ouverture du fichier
            File inputFile = new File(inFilename);
            BufferedImage imagesrc = ImageIO.read(inputFile);
            //Convertion en grisé
            BufferedImage imagedst = new BufferedImage(imagesrc.getWidth(), imagesrc.getHeight(), BufferedImage.TYPE_INT_RGB);
 
            //     BufferedImage.TYPE_INT_RGB);
            for (x = 0; x < imagesrc.getWidth(); x++) {
                    for (y = 0; y < imagesrc.getHeight(); y++) {
 
                        // recuperer couleur de chaque pixel
                        Color pixelcolor = new Color(imagesrc.getRGB(x, y));
 
                        // recuperer les valeur rgb (rouge ,vert ,bleu) de cette couleur
                        int r = pixelcolor.getRed();
                        int g = pixelcolor.getGreen();
                        int b = pixelcolor.getBlue();
 
                        if (r < 10 && g < 10 && b < 10) {
                            r = 255;
                            g = 0;
                            b = 0;
                        } else {
                            // faire l'inversion
                            r = 0;
                            g = 0;
                            b = 0;
                        }
 
                        int rgb = new Color(r, g, b).getRGB();
                        // changer la couleur de pixel avec la nouvelle couleur inversée
                        imagesrc.setRGB(x, y, rgb);
                    }
                 }
            Graphics g2 = imagedst.getGraphics();
            g2.drawImage(imagesrc, 0, 0, null);
            g2.dispose();
 
 
            List<Ellipse2D> ellipses = getEllipses(imagesrc);
            String[] listeStrings = new String[ellipses.size()];
            for(int i=1; i<ellipses.size(); i++) {
                distance = (int) (ellipses.get(i).getCenterY() - ellipses.get(i - 1).getCenterY()); // calcul de la distance entre le centre de l'ellipse courante et la précédente
                // là tu en fais ce que tu en veux, avec la variable distance
                listeStrings[i] = String.valueOf(distance);
          //      System.out.print((distance + ","));
 
            }
 
 
 
 
 
            Collections.reverse(Arrays.asList(listeStrings));
 
 
 
 
            Config.setText(Arrays.toString(listeStrings).replace("[", "").replace("null", "").replace("]", "").replace("\"", ""));
 
 
            JPanel images = new JPanel(new GridBagLayout());
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.insets = new Insets(5,5,5,5);
            gbc.gridy=0;
            gbc.gridx=GridBagConstraints.RELATIVE;
            frame.add(images);
            images.add(new JLabel(new ImageIcon(imagesrc)));
            images.add(new JLabel(new ImageIcon(createImage(imagesrc.getWidth(), imagesrc.getHeight(),ellipses,
                    (g,e)->g.draw(e.getBounds2D())))));
            Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
            frame.setLocation(screen.width/12,screen.height/13);
            frame.getRootPane().setBorder(BorderFactory.createMatteBorder(2, 2, 2, 2, Color.WHITE));
            frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            frame.pack();
            frame.setVisible(true);
            frame.setAlwaysOnTop(true);
 
            //Enregistrer l'image au format PNG
            File outFile = new File(outFilename);
            ImageIO.write(imagedst, "PNG", outFile);
            System.out.println("Fin de conversion....");
        } catch (IOException ex) {
            Logger.getLogger(ImageGrayScale.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
 
 
    private static BufferedImage createImage(int width, int height, java.util.List<Ellipse2D> ellipses, BiConsumer<Graphics2D, Ellipse2D> consumer) {
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = image.createGraphics();
        g.setColor(Color.WHITE);
        ellipses.forEach(e-> consumer.accept(g, e));
        g.dispose();
        return image;
    }
 
    private static java.util.List<Ellipse2D> getEllipses(BufferedImage image) {
        return getRectangles(image).stream()
                .map(rect-> new Ellipse2D.Double(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()))
                .collect(Collectors.toList());
    }
 
    private static java.util.List<Rectangle2D> getRectangles(BufferedImage image) {
 
        List<Rectangle2D> rectangles = new ArrayList<>();
 
        int MIN_SIZE = 0;
 
        int height = image.getHeight();
        int width = image.getWidth();
 
        int ym=-1;
        int minl=width-1;
        int maxr=0;
        for(int y=0; y<height; y++) {
            int xl= getPointDifferent(image.getRGB(0, y),image,y,
                    IntStream.iterate(1, x-> x<width, x-> x+1));
            if (xl>=0 ) {
                if ( ym==-1) ym=y;
                int xr= getPointDifferent(image.getRGB(width-1, y),image,y,
                        IntStream.iterate(width-1, x-> x>=xl, x-> x-1));
                minl = Math.min(xl, minl);
                maxr = Math.max(xr, maxr);
            }
            else {
                if (ym != -1) {
                    // on a un rectangle
                    Rectangle2D rect = new Rectangle2D.Double(minl, ym, maxr - minl, y - ym);
                    if ( rect.getWidth()>MIN_SIZE && rect.getHeight()>MIN_SIZE ) {
                        rectangles.add(new Rectangle2D.Double(minl,ym,maxr-minl,y-ym));
                    }
                    minl = width - 1;
                    maxr = 0;
                    ym = -1;
                }
            }
        }
 
        return rectangles;
 
    }
 
    private static int getPointDifferent(int rgb,
                                         BufferedImage image, int y, IntStream iterate) {
        return iterate
                .filter(x-> rgb!=image.getRGB(x, y))
                .findFirst().orElse(-1);
    }
    public static void screenShot(
 
            Rectangle screenArea,
            Dimension screenshotFinalDimension,
            String pictureName,
            String compressionType) {
 
 
        // la capture d'écran originale
        BufferedImage buf = null;
 
        // la capture d'écran redimensionnée
        BufferedImage bufFinal = null;
 
        try {
 
            // Création de notre capture d'écran
            buf = new Robot().createScreenCapture(screenArea);
        } catch (AWTException e) {
            e.printStackTrace();
        }
        // Création de la capture finale
        bufFinal = new BufferedImage(
                screenshotFinalDimension.width,
                screenshotFinalDimension.height,
                //      BufferedImage.TYPE_BYTE_GRAY);
                BufferedImage.TYPE_INT_RGB);
 
        // Redimensionnement de la capture originale
        Graphics2D g = (Graphics2D) bufFinal.getGraphics();
        g.setRenderingHint(
                RenderingHints.KEY_INTERPOLATION,
                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g.drawImage(
                buf,
                0,
                0,
                screenshotFinalDimension.width,
                screenshotFinalDimension.height,
                null);
        g.dispose();
 
        // Ecriture de la capture d'écran redimensionnée
        try {
            ImageIO.write(bufFinal, compressionType, new File(pictureName));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
class testsceen {
 
 
 
    private final static String IMAGE_TYPE_PNG = "png";
 
 
     static void screenShot(
 
             Rectangle screenArea,
             Dimension screenshotFinalDimension) {
 
 
        // la capture d'écran originale
        BufferedImage buf = null;
 
        // la capture d'écran redimensionnée
        BufferedImage bufFinal = null;
 
        try {
 
            // Création de notre capture d'écran
            buf = new Robot().createScreenCapture(screenArea);
        } catch (AWTException e) {
            e.printStackTrace();
        }
        // Création de la capture finale
        bufFinal = new BufferedImage(
                screenshotFinalDimension.width,
                screenshotFinalDimension.height,
                //      BufferedImage.TYPE_BYTE_GRAY);
                BufferedImage.TYPE_INT_RGB);
 
        // Redimensionnement de la capture originale
        Graphics2D g = (Graphics2D) bufFinal.getGraphics();
        g.setRenderingHint(
                RenderingHints.KEY_INTERPOLATION,
                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g.drawImage(
                buf,
                0,
                0,
                screenshotFinalDimension.width,
                screenshotFinalDimension.height,
                null);
        g.dispose();
 
        // Ecriture de la capture d'écran redimensionnée
        try {
            ImageIO.write(bufFinal, testsceen.IMAGE_TYPE_PNG, new File("test2.png"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
}

Je prend un screnshoot, je convertis les couleurs et je scan.

Ça a l'air de relativement bien fonctionner.

Je pense que le code peu etre récrit plus proprement, par exemple j'ai fais uen class pour prendre le screen mais je pense que c'est possible de faire tout dans la même class et moins lourd (ne pas sauvegarde le screen pour le relire)

En tout cas merci.

Fred