@@ -15,46 +15,51 @@ int main(int argc, char** argv)
15
15
else
16
16
filename = " billiard.jpg" ;
17
17
18
- Mat testImg = imread (filename, 0 );
19
- TickMeter tm ;
18
+ Mat testImg, ellipsImg0, ellipsImg1;
19
+ Mat colorImg = imread (filename);
20
+ cvtColor (colorImg, testImg, COLOR_BGR2GRAY);
21
+
22
+ Ptr <EdgeDrawing> ed = createEdgeDrawing ();
23
+ vector<Vec6d> ellipses;
24
+ vector<Vec4f> lines;
20
25
21
- for (int i = 1 ; i < 5 ; i++)
26
+ TickMeter tm ;
27
+ for (int i = 0 ; i < 3 ; i++)
22
28
{
23
29
cout << " \n #################################################" ;
24
30
cout << " \n ####### ( " << i << " ) ORIGINAL & OPENCV COMPARISON ######" ;
25
31
cout << " \n #################################################\n " ;
26
- Ptr <EdgeDrawing> ed = createEdgeDrawing ();
32
+
27
33
ed->params .EdgeDetectionOperator = EdgeDrawing::SOBEL;
28
34
ed->params .GradientThresholdValue = 36 ;
29
35
ed->params .AnchorThresholdValue = 8 ;
30
- vector<Vec6d> ellipses;
31
- vector<Vec4f> lines;
36
+ ed->params .Sigma = 1.0 ;
32
37
33
38
// Detection of edge segments from an input image
34
39
tm .start ();
35
40
// Call ED constructor
36
41
ED testED = ED (testImg, SOBEL_OPERATOR, 36 , 8 , 1 , 10 , 1.0 , true );
37
42
tm .stop ();
38
- std::cout << " \n testED .getEdgeImage() (Original) : " << tm .getTimeMilli () << endl;
43
+ std::cout << " testED .getEdgeImage() (Original) : " << tm .getTimeMilli () << " ms. " << endl;
39
44
40
45
tm .reset ();
41
46
tm .start ();
42
47
ed->detectEdges (testImg);
43
48
tm .stop ();
44
- std::cout << " detectEdges() (OpenCV) : " << tm .getTimeMilli () << endl;
49
+ std::cout << " detectEdges() (OpenCV) : " << tm .getTimeMilli () << " ms." << endl;
50
+
51
+ Mat anchImg = testED.getAnchorImage ();
52
+ Mat gradImg = testED.getGradImage ();
53
+ imwrite (" GradImage.png" , gradImg);
54
+ imwrite (" AnchorImage.png" , anchImg);
45
55
46
- Mat edgeImg0 = testED.getEdgeImage ();
47
- Mat anchImg0 = testED.getAnchorImage ();
48
- Mat gradImg0 = testED.getGradImage ();
49
56
Mat edgeImg1, diff;
57
+ Mat edgeImg0 = testED.getEdgeImage ();
50
58
ed->getEdgeImage (edgeImg1);
51
59
absdiff (edgeImg0, edgeImg1, diff);
52
60
cout << " different pixel count : " << countNonZero (diff) << endl;
53
- imwrite (" gradImg0.png" , gradImg0);
54
- imwrite (" anchImg0.png" , anchImg0);
55
- imwrite (" edgeImg0.png" , edgeImg0);
56
- imwrite (" edgeImg1.png" , edgeImg1);
57
- imwrite (" diff0.png" , diff);
61
+
62
+ imwrite (" EdgeImage.png" , edgeImg1);
58
63
59
64
// ***************************** EDLINES Line Segment Detection *****************************
60
65
// Detection of lines segments from edge segments instead of input image
@@ -64,15 +69,14 @@ int main(int argc, char** argv)
64
69
EDLines testEDLines = EDLines (testED);
65
70
tm .stop ();
66
71
cout << " -------------------------------------------------\n " ;
67
- cout << " testEDLines.getLineImage() : " << tm .getTimeMilli () << endl;
72
+ cout << " testEDLines.getLineImage() : " << tm .getTimeMilli () << " ms. " << endl;
68
73
Mat lineImg0 = testEDLines.getLineImage (); // draws on an empty image
69
- imwrite (" lineImg0.png" , lineImg0);
70
74
71
75
tm .reset ();
72
76
tm .start ();
73
77
ed->detectLines (lines);
74
78
tm .stop ();
75
- cout << " detectLines() (OpenCV) : " << tm .getTimeMilli () << endl;
79
+ cout << " detectLines() (OpenCV) : " << tm .getTimeMilli () << " ms. " << endl;
76
80
77
81
Mat lineImg1 = Mat (lineImg0.rows , lineImg0.cols , CV_8UC1, Scalar (255 ));
78
82
@@ -81,8 +85,7 @@ int main(int argc, char** argv)
81
85
82
86
absdiff (lineImg0, lineImg1, diff);
83
87
cout << " different pixel count : " << countNonZero (diff) << endl;
84
- imwrite (" lineImg1.png" , lineImg1);
85
- imwrite (" diff1.png" , diff);
88
+ imwrite (" LinesImage.png" , lineImg1);
86
89
87
90
// ***************************** EDCIRCLES Circle Segment Detection *****************************
88
91
// Detection of circles from already available EDPF or ED image
@@ -91,20 +94,21 @@ int main(int argc, char** argv)
91
94
EDCircles testEDCircles = EDCircles (testEDLines);
92
95
tm .stop ();
93
96
cout << " -------------------------------------------------\n " ;
94
- cout << " EDCircles(testEDLines) : " << tm .getTimeMilli () << endl;
97
+ cout << " EDCircles(testEDLines) : " << tm .getTimeMilli () << " ms. " << endl;
95
98
96
99
tm .reset ();
97
100
tm .start ();
98
101
ed->detectEllipses (ellipses);
99
102
tm .stop ();
100
- cout << " detectEllipses() (OpenCV) : " << tm .getTimeMilli () << endl;
103
+ cout << " detectEllipses() (OpenCV) : " << tm .getTimeMilli () << " ms. " << endl;
101
104
cout << " -------------------------------------------------\n " ;
102
105
103
106
vector<mCircle > found_circles = testEDCircles.getCircles ();
104
107
vector<mEllipse > found_ellipses = testEDCircles.getEllipses ();
105
- Mat ellipsImg0 = Mat (lineImg0.rows , lineImg0.cols , CV_8UC3, Scalar::all (0 ));
106
- Mat ellipsImg1 = Mat (lineImg0.rows , lineImg0.cols , CV_8UC3, Scalar::all (0 ));
107
108
109
+ cvtColor (testImg, ellipsImg0, COLOR_GRAY2BGR);
110
+ cvtColor (testImg, ellipsImg1, COLOR_GRAY2BGR);
111
+
108
112
for (int i = 0 ; i < found_circles.size (); i++)
109
113
{
110
114
Point center ((int )found_circles[i].center .x , (int )found_circles[i].center .y );
@@ -135,59 +139,132 @@ int main(int argc, char** argv)
135
139
ellipse (ellipsImg1, center, axes, angle, 0 , 360 , color, 1 , LINE_AA);
136
140
}
137
141
138
- imwrite (" ellipsImg0 .png" , ellipsImg0);
139
- imwrite (" ellipsImg1 .png" , ellipsImg1);
142
+ imwrite (" EllipsImage-Original .png" , ellipsImg0);
143
+ imwrite (" EllipsImage-OpenCV .png" , ellipsImg1);
140
144
141
145
// ************************** EDPF Parameter-free Edge Segment Detection **************************
142
146
// Detection of edge segments with parameter free ED (EDPF)
143
147
tm .reset ();
144
148
tm .start ();
145
149
EDPF testEDPF = EDPF (testImg);
146
150
tm .stop ();
147
- cout << " testEDPF.getEdgeImage() : " << tm .getTimeMilli () << endl;
151
+ cout << " testEDPF.getEdgeImage() : " << tm .getTimeMilli () << " ms. " << endl;
148
152
149
- Ptr <EdgeDrawing> ed1 = createEdgeDrawing ();
150
- ed1->params .EdgeDetectionOperator = EdgeDrawing::PREWITT;
151
- ed1->params .GradientThresholdValue = 11 ;
152
- ed1->params .AnchorThresholdValue = 3 ;
153
- ed1->params .PFmode = true ;
153
+ ed->params .EdgeDetectionOperator = EdgeDrawing::PREWITT;
154
+ ed->params .GradientThresholdValue = 11 ;
155
+ ed->params .AnchorThresholdValue = 3 ;
156
+ ed->params .PFmode = true ;
154
157
155
158
tm .reset ();
156
159
tm .start ();
157
- ed1 ->detectEdges (testImg);
160
+ ed ->detectEdges (testImg);
158
161
tm .stop ();
159
- std::cout << " detectEdges() PF (OpenCV) : " << tm .getTimeMilli () << endl;
162
+ std::cout << " detectEdges() PF (OpenCV) : " << tm .getTimeMilli () << " ms. " << endl;
160
163
161
164
edgeImg0 = testEDPF.getEdgeImage ();
162
165
ed->getEdgeImage (edgeImg1);
163
166
absdiff (edgeImg0, edgeImg1, diff);
164
167
cout << " different pixel count : " << countNonZero (diff) << endl;
165
- imwrite (" edgePFImage0.png" , edgeImg0);
166
- imwrite (" edgePFImage1.png" , edgeImg1);
167
- imwrite (" diff2.png" , diff);
168
+ imwrite (" EdgeImage-PF.png" , edgeImg1);
169
+
168
170
// *********************** EDCOLOR Edge Segment Detection from Color Images **********************
169
171
170
- Mat colorImg = imread (filename);
171
172
tm .reset ();
172
173
tm .start ();
173
174
EDColor testEDColor = EDColor (colorImg, 36 );
175
+ edgeImg0 = testEDColor.getEdgeImage ();
174
176
tm .stop ();
175
177
cout << " -------------------------------------------------\n " ;
176
- cout << " testEDColor : " << tm .getTimeMilli () << endl;
178
+ cout << " testEDColor.getEdgeImage() : " << tm .getTimeMilli () << " ms." << endl;
179
+
180
+ ed->params .EdgeDetectionOperator = EdgeDrawing::PREWITT;
181
+ ed->params .GradientThresholdValue = 36 ;
182
+ ed->params .AnchorThresholdValue = 4 ;
183
+ ed->params .Sigma = 1.5 ;
184
+ ed->params .PFmode = false ;
185
+ tm .reset ();
186
+ tm .start ();
187
+ ed->detectEdges (colorImg);
188
+ tm .stop ();
189
+ cout << " detectEdges() (OpenCV) : " << tm .getTimeMilli () << " ms." << endl;
190
+
191
+ ed->getEdgeImage (edgeImg1);
192
+ absdiff (edgeImg0, edgeImg1, diff);
193
+ cout << " different pixel count : " << countNonZero (diff) << endl;
194
+ imwrite (" EdgeImage-Color.png" , edgeImg0);
177
195
178
196
tm .reset ();
179
197
tm .start ();
180
198
// get lines from color image
181
199
EDLines colorLine = EDLines (testEDColor);
182
200
tm .stop ();
183
- cout << " get lines from color image : " << tm .getTimeMilli () << endl;
201
+ cout << " -------------------------------------------------\n " ;
202
+ cout << " get lines from color image : " << tm .getTimeMilli () << " ms." << endl;
203
+ lineImg0 = colorLine.getLineImage ();
204
+ imwrite (" LinesImage-Color.png" , lineImg0);
205
+ tm .reset ();
206
+ tm .start ();
207
+ ed->detectLines (lines);
208
+ tm .stop ();
209
+ cout << " detectLines() (OpenCV) : " << tm .getTimeMilli () << " ms." << endl;
184
210
211
+ lineImg1 = Mat (lineImg0.rows , lineImg0.cols , CV_8UC1, Scalar (255 ));
212
+
213
+ for (int i = 0 ; i < lines.size (); i++)
214
+ line (lineImg1, Point2d (lines[i][0 ], lines[i][1 ]), Point2d (lines[i][2 ], lines[i][3 ]), Scalar (0 ), 1 , LINE_AA);
215
+
216
+ absdiff (lineImg0, lineImg1, diff);
217
+ cout << " different pixel count : " << countNonZero (diff) << endl;
218
+ cout << " -------------------------------------------------\n " ;
185
219
tm .reset ();
186
220
tm .start ();
187
221
// get circles from color image
188
222
EDCircles colorCircle = EDCircles (testEDColor);
189
223
tm .stop ();
190
- cout << " get circles from color image : " << tm .getTimeMilli () << endl;
224
+ cout << " get circles from color image : " << tm .getTimeMilli () << " ms." << endl;
225
+ tm .reset ();
226
+ tm .start ();
227
+ ed->detectEllipses (ellipses);
228
+ tm .stop ();
229
+ cout << " detectEllipses() (OpenCV) : " << tm .getTimeMilli () << " ms." << endl;
230
+
231
+ found_circles = colorCircle.getCircles ();
232
+ found_ellipses = colorCircle.getEllipses ();
233
+
234
+ ellipsImg0 = colorImg.clone ();
235
+ ellipsImg1 = colorImg.clone ();
236
+ for (int i = 0 ; i < found_circles.size (); i++)
237
+ {
238
+ Point center ((int )found_circles[i].center .x , (int )found_circles[i].center .y );
239
+ Size axes ((int )found_circles[i].r , (int )found_circles[i].r );
240
+ double angle (0.0 );
241
+ Scalar color = Scalar (0 , 255 , 0 );
242
+
243
+ ellipse (ellipsImg0, center, axes, angle, 0 , 360 , color, 2 , LINE_AA);
244
+ }
245
+
246
+ for (int i = 0 ; i < found_ellipses.size (); i++)
247
+ {
248
+ Point center ((int )found_ellipses[i].center .x , (int )found_ellipses[i].center .y );
249
+ Size axes ((int )found_ellipses[i].axes .width , (int )found_ellipses[i].axes .height );
250
+ double angle = found_ellipses[i].theta * 180 / CV_PI;
251
+ Scalar color = Scalar (255 , 255 , 0 );
252
+
253
+ ellipse (ellipsImg0, center, axes, angle, 0 , 360 , color, 2 , LINE_AA);
254
+ }
255
+
256
+ for (size_t i = 0 ; i < ellipses.size (); i++)
257
+ {
258
+ Point center ((int )ellipses[i][0 ], (int )ellipses[i][1 ]);
259
+ Size axes ((int )ellipses[i][2 ] + (int )ellipses[i][3 ], (int )ellipses[i][2 ] + (int )ellipses[i][4 ]);
260
+ double angle (ellipses[i][5 ]);
261
+ Scalar color = ellipses[i][2 ] == 0 ? Scalar (255 , 255 , 0 ) : Scalar (0 , 255 , 0 );
262
+
263
+ ellipse (ellipsImg1, center, axes, angle, 0 , 360 , color, 2 , LINE_AA);
264
+ }
265
+
266
+ imwrite (" EllipsImageColor-Original.png" , ellipsImg0);
267
+ imwrite (" EllipsImageColor-OpenCV.png" , ellipsImg1);
191
268
}
192
269
return 0 ;
193
270
}
0 commit comments