cloudFPGA (cF) API  1.0
The documentation of the source code of cloudFPGA (cF)
xf_ocv_ref.hpp
Go to the documentation of this file.
1 /*
2  * Copyright 2019 Xilinx, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 
29 #ifndef _XF_OCV_REF_HPP_
30 #define _XF_OCV_REF_HPP_
31 #include "xf_config_params.h"
32 
33 using namespace cv;
34 using namespace std;
35 
36 typedef float NMSTYPE;
37 
38 bool OCVFindMaximum2(NMSTYPE* t1, NMSTYPE* t2, NMSTYPE* m1, NMSTYPE* b1, NMSTYPE* b2) {
39  bool Max = false;
40  NMSTYPE maxval = m1[2];
41  if ((maxval > t1[2]) && (maxval > t2[1]) && (maxval > t2[2]) && (maxval > t2[3]) && (maxval > m1[0]) &&
42  (maxval > m1[1]) && (maxval > m1[3]) && (maxval > m1[4]) && (maxval > b1[1]) && (maxval > b1[2]) &&
43  (maxval > b1[3]) && (maxval > b2[2]))
44  Max = true;
45  return Max;
46 }
47 
48 void OCVMaxSuppression2(cv::Mat& src, cv::Mat& dst) {
49  int i, j, k;
50  int ii, jj;
51  NMSTYPE t1[5], t2[5];
52  NMSTYPE m1[5];
53  NMSTYPE b1[5], b2[5];
54  bool result;
55 
56  /* Process zeroth row */
57  i = 0;
58  for (j = 0; j < src.cols; j++) {
59  if (j < 2) {
60  for (k = 0; k < 5; k++) {
61  t1[k] = 0;
62  }
63  for (k = 0; k < 5; k++) {
64  t2[k] = 0;
65  }
66  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
67  if (jj >= 0)
68  m1[k] = src.at<NMSTYPE>(ii, jj);
69  else
70  m1[k] = 0;
71  }
72  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
73  if (jj >= 0)
74  b1[k] = src.at<NMSTYPE>(ii, jj);
75  else
76  b1[k] = 0;
77  }
78  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
79  if (jj >= 0)
80  b2[k] = src.at<NMSTYPE>(ii, jj);
81  else
82  b2[k] = 0;
83  }
84  } else if ((j >= 2) && (j < src.cols - 2)) {
85  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
86  t1[k] = 0;
87  }
88  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
89  t2[k] = 0;
90  }
91  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
92  m1[k] = src.at<NMSTYPE>(ii, jj);
93  }
94  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
95  b1[k] = src.at<NMSTYPE>(ii, jj);
96  }
97  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
98  b2[k] = src.at<NMSTYPE>(ii, jj);
99  }
100  } else if (j >= src.cols - 2) {
101  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
102  t1[k] = 0;
103  }
104  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
105  t2[k] = 0;
106  }
107  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
108  if (jj < src.cols)
109  m1[k] = src.at<NMSTYPE>(ii, jj);
110  else
111  m1[k] = 0;
112  }
113  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
114  if (jj < src.cols)
115  b1[k] = src.at<NMSTYPE>(ii, jj);
116  else
117  b1[k] = 0;
118  }
119  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
120  if (jj < src.cols)
121  b2[k] = src.at<NMSTYPE>(ii, jj);
122  else
123  b2[k] = 0;
124  }
125  }
126  result = OCVFindMaximum2(t1, t2, m1, b1, b2);
127  dst.at<uchar>(i, j) = result ? 255 : 0;
128  }
129  /* Process second row */
130  i = 1;
131  for (j = 0; j < src.cols; j++) {
132  if (j < 2) {
133  for (k = 0; k < 5; k++) {
134  t1[k] = 0;
135  }
136  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
137  if (jj >= 0)
138  t2[k] = src.at<NMSTYPE>(ii, jj);
139  else
140  t2[k] = 0;
141  }
142  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
143  if (jj >= 0)
144  m1[k] = src.at<NMSTYPE>(ii, jj);
145  else
146  m1[k] = 0;
147  }
148  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
149  if (jj >= 0)
150  b1[k] = src.at<NMSTYPE>(ii, jj);
151  else
152  b1[k] = 0;
153  }
154  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
155  if (jj >= 0)
156  b2[k] = src.at<NMSTYPE>(ii, jj);
157  else
158  b2[k] = 0;
159  }
160  } else if ((j >= 2) && (j < src.cols - 2)) {
161  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
162  t1[k] = 0;
163  }
164  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
165  t2[k] = src.at<NMSTYPE>(ii, jj);
166  }
167  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
168  m1[k] = src.at<NMSTYPE>(ii, jj);
169  }
170  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
171  b1[k] = src.at<NMSTYPE>(ii, jj);
172  }
173  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
174  b2[k] = src.at<NMSTYPE>(ii, jj);
175  }
176  } else if (j >= src.cols - 2) {
177  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
178  t1[k] = 0;
179  }
180  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
181  t2[k] = 0;
182  }
183  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
184  if (jj < src.cols)
185  m1[k] = src.at<NMSTYPE>(ii, jj);
186  else
187  m1[k] = 0;
188  }
189  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
190  if (jj < src.cols)
191  b1[k] = src.at<NMSTYPE>(ii, jj);
192  else
193  b1[k] = 0;
194  }
195  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
196  if (jj < src.cols)
197  b2[k] = src.at<NMSTYPE>(ii, jj);
198  else
199  b2[k] = 0;
200  }
201  }
202  result = OCVFindMaximum2(t1, t2, m1, b1, b2);
203  dst.at<uchar>(i, j) = result ? 255 : 0;
204  }
205 
206  for (i = 2; i < src.rows - 2; i++) {
207  for (j = 0; j < src.cols; j++) {
208  if (j < 2) {
209  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
210  if (jj >= 0)
211  t1[k] = src.at<NMSTYPE>(ii, jj);
212  else
213  t1[k] = 0;
214  }
215  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
216  if (jj >= 0)
217  t2[k] = src.at<NMSTYPE>(ii, jj);
218  else
219  t2[k] = 0;
220  }
221  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
222  if (jj >= 0)
223  m1[k] = src.at<NMSTYPE>(ii, jj);
224  else
225  m1[k] = 0;
226  }
227  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
228  if (jj >= 0)
229  b1[k] = src.at<NMSTYPE>(ii, jj);
230  else
231  b1[k] = 0;
232  }
233  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
234  if (jj >= 0)
235  b2[k] = src.at<NMSTYPE>(ii, jj);
236  else
237  b2[k] = 0;
238  }
239  } else if ((j >= 2) && (j < src.cols - 2)) {
240  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
241  t1[k] = src.at<NMSTYPE>(ii, jj);
242  }
243  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
244  t2[k] = src.at<NMSTYPE>(ii, jj);
245  }
246  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
247  m1[k] = src.at<NMSTYPE>(ii, jj);
248  }
249  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
250  b1[k] = src.at<NMSTYPE>(ii, jj);
251  }
252  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
253  b2[k] = src.at<NMSTYPE>(ii, jj);
254  }
255  } else if (j >= src.cols - 2) {
256  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
257  if (jj < src.cols)
258  t1[k] = src.at<NMSTYPE>(ii, jj);
259  else
260  t1[k] = 0;
261  }
262  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
263  if (jj < src.cols)
264  t2[k] = src.at<NMSTYPE>(ii, jj);
265  else
266  t2[k] = 0;
267  }
268  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
269  if (jj < src.cols)
270  m1[k] = src.at<NMSTYPE>(ii, jj);
271  else
272  m1[k] = 0;
273  }
274  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
275  if (jj < src.cols)
276  b1[k] = src.at<NMSTYPE>(ii, jj);
277  else
278  b1[k] = 0;
279  }
280  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
281  if (jj < src.cols)
282  b2[k] = src.at<NMSTYPE>(ii, jj);
283  else
284  b2[k] = 0;
285  }
286  }
287 
288  result = OCVFindMaximum2(t1, t2, m1, b1, b2);
289  dst.at<uchar>(i, j) = result ? 255 : 0;
290  }
291  }
292  /* Process zeroth row */
293  i = src.rows - 2;
294  for (j = 0; j < src.cols; j++) {
295  if (j < 2) {
296  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
297  if (jj >= 0)
298  t1[k] = src.at<NMSTYPE>(ii, jj);
299  else
300  t1[k] = 0;
301  }
302  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
303  if (jj >= 0)
304  t2[k] = src.at<NMSTYPE>(ii, jj);
305  else
306  t2[k] = 0;
307  }
308  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
309  if (jj >= 0)
310  m1[k] = src.at<NMSTYPE>(ii, jj);
311  else
312  m1[k] = 0;
313  }
314  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
315  if (jj >= 0)
316  b1[k] = src.at<NMSTYPE>(ii, jj);
317  else
318  b1[k] = 0;
319  }
320  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
321  b2[k] = 0;
322  }
323  } else if ((j >= 2) && (j < src.cols - 2)) {
324  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
325  t1[k] = src.at<NMSTYPE>(ii, jj);
326  }
327  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
328  t2[k] = src.at<NMSTYPE>(ii, jj);
329  }
330  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
331  m1[k] = src.at<NMSTYPE>(ii, jj);
332  }
333  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
334  b1[k] = src.at<NMSTYPE>(ii, jj);
335  }
336  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
337  b2[k] = 0;
338  }
339  } else if (j >= src.cols - 2) {
340  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
341  if (jj < src.cols)
342  t1[k] = src.at<NMSTYPE>(ii, jj);
343  else
344  t1[k] = 0;
345  }
346  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
347  if (jj < src.cols)
348  t2[k] = src.at<NMSTYPE>(ii, jj);
349  else
350  t2[k] = 0;
351  }
352  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
353  if (jj < src.cols)
354  m1[k] = src.at<NMSTYPE>(ii, jj);
355  else
356  m1[k] = 0;
357  }
358  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
359  if (jj < src.cols)
360  b1[k] = src.at<NMSTYPE>(ii, jj);
361  else
362  b1[k] = 0;
363  }
364  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
365  b2[k] = 0;
366  }
367  }
368  result = OCVFindMaximum2(t1, t2, m1, b1, b2);
369  dst.at<uchar>(i, j) = result ? 255 : 0;
370  }
371  /* Process second row */
372  i = src.rows - 1;
373  for (j = 0; j < src.cols; j++) {
374  if (j < 2) {
375  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
376  if (jj >= 0)
377  t1[k] = src.at<NMSTYPE>(ii, jj);
378  else
379  t1[k] = 0;
380  }
381  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
382  if (jj >= 0)
383  t2[k] = src.at<NMSTYPE>(ii, jj);
384  else
385  t2[k] = 0;
386  }
387  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
388  if (jj >= 0)
389  m1[k] = src.at<NMSTYPE>(ii, jj);
390  else
391  m1[k] = 0;
392  }
393  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
394  b1[k] = 0;
395  }
396  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
397  b2[k] = 0;
398  }
399  } else if ((j >= 2) && (j < src.cols - 2)) {
400  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
401  t1[k] = src.at<NMSTYPE>(ii, jj);
402  }
403  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
404  t2[k] = src.at<NMSTYPE>(ii, jj);
405  }
406  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
407  m1[k] = src.at<NMSTYPE>(ii, jj);
408  }
409  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
410  b1[k] = 0;
411  }
412  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
413  b2[k] = 0;
414  }
415  } else if (j >= src.cols - 2) {
416  for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
417  if (jj < src.cols)
418  t1[k] = src.at<NMSTYPE>(ii, jj);
419  else
420  t1[k] = 0;
421  }
422  for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
423  if (jj < src.cols)
424  t2[k] = src.at<NMSTYPE>(ii, jj);
425  else
426  t2[k] = 0;
427  }
428  for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
429  if (jj < src.cols)
430  m1[k] = src.at<NMSTYPE>(ii, jj);
431  else
432  m1[k] = 0;
433  }
434  for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
435  b1[k] = 0;
436  }
437  for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
438  b2[k] = 0;
439  }
440  }
441  result = OCVFindMaximum2(t1, t2, m1, b1, b2);
442  dst.at<uchar>(i, j) = result ? 255 : 0;
443  }
444 }
445 
446 bool OCVFindMaximum1(
447  NMSTYPE t0, NMSTYPE t1, NMSTYPE t2, NMSTYPE m0, NMSTYPE m1, NMSTYPE m2, NMSTYPE b0, NMSTYPE b1, NMSTYPE b2) {
448  bool Max = false;
449  if (m1 > t1 && m1 > m0 && m1 > m2 && m1 > b1) Max = true;
450  return Max;
451 }
452 
453 /* Non maximum suppression */
454 void OCVMaxSuppression1(cv::Mat& src, cv::Mat& dst) {
455  int i, j;
456  NMSTYPE t0, t1, t2;
457  NMSTYPE m0, m1, m2;
458  NMSTYPE b0, b1, b2;
459  bool result;
460 
461  /* First row */
462  i = 0;
463  for (j = 0; j < src.cols; j++) {
464  if (j == 0) {
465  t0 = 0;
466  t1 = 0;
467  t2 = 0;
468  m0 = 0;
469  m1 = src.at<NMSTYPE>(i, j);
470  m2 = src.at<NMSTYPE>(i, j + 1);
471  b0 = 0;
472  b1 = src.at<NMSTYPE>(i + 1, j);
473  b2 = src.at<NMSTYPE>(i + 1, j + 1);
474  } else if ((j > 0) && (j < src.cols - 1)) {
475  t0 = 0;
476  t1 = 0;
477  t2 = 0;
478  m0 = src.at<NMSTYPE>(i, j - 1);
479  m1 = src.at<NMSTYPE>(i, j);
480  m2 = src.at<NMSTYPE>(i, j + 1);
481  b0 = src.at<NMSTYPE>(i + 1, j - 1);
482  b1 = src.at<NMSTYPE>(i + 1, j);
483  b2 = src.at<NMSTYPE>(i + 1, j + 1);
484  } else if (j == src.cols - 1) {
485  t0 = 0;
486  t1 = 0;
487  t2 = 0;
488  m0 = src.at<NMSTYPE>(i, j - 1);
489  m1 = src.at<NMSTYPE>(i, j);
490  m2 = 0;
491  b0 = src.at<NMSTYPE>(i + 1, j - 1);
492  b1 = src.at<NMSTYPE>(i + 1, j);
493  b2 = 0;
494  }
495  result = OCVFindMaximum1(t0, t1, t2, m0, m1, m2, b0, b1, b2);
496  dst.at<uchar>(i, j) = result ? 255 : 0;
497  }
498  for (i = 1; i < src.rows - 1; i++) {
499  for (j = 0; j < src.cols; j++) {
500  if (j == 0) {
501  t0 = 0;
502  t1 = src.at<NMSTYPE>(i - 1, j);
503  t2 = src.at<NMSTYPE>(i - 1, j + 1);
504  m0 = 0;
505  m1 = src.at<NMSTYPE>(i, j);
506  m2 = src.at<NMSTYPE>(i, j + 1);
507  b0 = 0;
508  b1 = src.at<NMSTYPE>(i + 1, j);
509  b2 = src.at<NMSTYPE>(i + 1, j + 1);
510  } else if ((j > 0) && (j < src.cols - 1)) {
511  t0 = src.at<NMSTYPE>(i - 1, j - 1);
512  t1 = src.at<NMSTYPE>(i - 1, j);
513  t2 = src.at<NMSTYPE>(i - 1, j + 1);
514  m0 = src.at<NMSTYPE>(i, j - 1);
515  m1 = src.at<NMSTYPE>(i, j);
516  m2 = src.at<NMSTYPE>(i, j + 1);
517  b0 = src.at<NMSTYPE>(i + 1, j - 1);
518  b1 = src.at<NMSTYPE>(i + 1, j);
519  b2 = src.at<NMSTYPE>(i + 1, j + 1);
520  } else if (j == src.cols - 1) {
521  t0 = src.at<NMSTYPE>(i - 1, j - 1);
522  t1 = src.at<NMSTYPE>(i - 1, j);
523  t2 = 0;
524  m0 = src.at<NMSTYPE>(i, j - 1);
525  m1 = src.at<NMSTYPE>(i, j);
526  m2 = 0;
527  b0 = src.at<NMSTYPE>(i + 1, j - 1);
528  b1 = src.at<NMSTYPE>(i + 1, j);
529  b2 = 0;
530  }
531  result = OCVFindMaximum1(t0, t1, t2, m0, m1, m2, b0, b1, b2);
532  dst.at<uchar>(i, j) = result ? 255 : 0;
533  }
534  }
535  /* Last row */
536  i = src.rows - 1;
537  for (j = 1; j < src.cols - 1; j++) {
538  t0 = src.at<NMSTYPE>(i - 1, j - 1);
539  t1 = src.at<NMSTYPE>(i - 1, j);
540  t2 = src.at<NMSTYPE>(i - 1, j + 1);
541  m0 = src.at<NMSTYPE>(i, j - 1);
542  m1 = src.at<NMSTYPE>(i, j);
543  m2 = src.at<NMSTYPE>(i, j + 1);
544  b0 = 0;
545  b1 = 0;
546  b2 = 0;
547  result = OCVFindMaximum1(t0, t1, t2, m0, m1, m2, b0, b1, b2);
548  dst.at<uchar>(i, j) = result ? 255 : 0;
549  }
550 }
551 
552 void ocv_ref(cv::Mat img_gray, cv::Mat& ocv_out_img, float Th) {
553  cv::Mat gradx, grady;
554  cv::Mat gradx2, grady2, gradxy;
555  cv::Mat gradx2g, grady2g, gradxyg;
556  cv::Mat x2y2, xy, mtrace;
557  cv::Mat dst, ocvthresh_img;
558 
559 
560  // Step one: Apply gradient
561  cv::Sobel(img_gray, gradx, CV_32FC1, 1, 0, FILTER_WIDTH, 1, 0, cv::BORDER_CONSTANT);
562  cv::Sobel(img_gray, grady, CV_32FC1, 0, 1, FILTER_WIDTH, 1, 0, cv::BORDER_CONSTANT);
563  // Step Two: Calculate gx^2, gy^2, gx*gy
564  pow(gradx, 2.0, gradx2);
565  pow(grady, 2.0, grady2);
566  multiply(gradx, grady, gradxy);
567  // Step Three: Apply boxfilter
568  cv::boxFilter(gradx2, gradx2g, -1, cv::Size(BLOCK_WIDTH, BLOCK_WIDTH));
569  cv::boxFilter(grady2, grady2g, -1, cv::Size(BLOCK_WIDTH, BLOCK_WIDTH));
570  cv::boxFilter(gradxy, gradxyg, -1, cv::Size(BLOCK_WIDTH, BLOCK_WIDTH));
571 
572  multiply(gradx2g, grady2g, x2y2);
573  multiply(gradxyg, gradxyg, xy);
574  pow((gradx2g + grady2g), 2.0, mtrace);
575 
576  // Step Four: Compute score
577  dst.create(img_gray.rows, img_gray.cols, CV_32FC1);
578  ocvthresh_img.create(img_gray.rows, img_gray.cols, dst.depth());
579 
580  float sum = 0;
581  for (int j = 0; j < img_gray.rows; j++) {
582  for (int i = 0; i < img_gray.cols; i++) {
583  float v1 = x2y2.at<float>(j, i);
584  float v2 = xy.at<float>(j, i);
585  float v3 = mtrace.at<float>(j, i);
586  float temp1 = (v1 - v2) - (0.04 * v3);
587  dst.at<float>(j, i) = temp1;
588 
589  if (temp1 > 0.0) sum += temp1;
590  }
591  }
592  //float meanval = sum / (img_gray.rows * img_gray.cols);
593 
594  // Step five: Apply Threshold
595  for (int i = 0; i < img_gray.rows; i++) {
596  for (int j = 0; j < img_gray.cols; j++) {
597  float pix = dst.at<NMSTYPE>(i, j);
598  if (pix > Th) {
599  ocvthresh_img.at<NMSTYPE>(i, j) = pix;
600  } else {
601  ocvthresh_img.at<NMSTYPE>(i, j) = 0;
602  }
603  }
604  }
605 
606  // Step six: Find Non maxima supppression
607  if (NMS_RADIUS == 1) {
608  OCVMaxSuppression1(ocvthresh_img, ocv_out_img);
609  } else if (NMS_RADIUS == 2) {
610  OCVMaxSuppression2(ocvthresh_img, ocv_out_img);
611  }
612 
613  gradx.~Mat();
614  grady.~Mat();
615  gradx2.~Mat();
616  grady2.~Mat();
617  gradxy.~Mat();
618  gradx2g.~Mat();
619  grady2g.~Mat();
620  gradxyg.~Mat();
621  x2y2.~Mat();
622  xy.~Mat();
623  mtrace.~Mat();
624  dst.~Mat();
625  ocvthresh_img.~Mat();
626 
627 }
628 
629 #endif
630 
631 
FILTER_WIDTH
#define FILTER_WIDTH
Definition: xf_config_params.h:35
NMS_RADIUS
#define NMS_RADIUS
Definition: xf_config_params.h:37
BLOCK_WIDTH
#define BLOCK_WIDTH
Definition: xf_config_params.h:36
OCVFindMaximum2
bool OCVFindMaximum2(NMSTYPE *t1, NMSTYPE *t2, NMSTYPE *m1, NMSTYPE *b1, NMSTYPE *b2)
Definition: xf_ocv_ref.hpp:38
OCVMaxSuppression2
void OCVMaxSuppression2(cv::Mat &src, cv::Mat &dst)
Definition: xf_ocv_ref.hpp:48
ocv_ref
void ocv_ref(cv::Mat img_gray, cv::Mat &ocv_out_img, float Th)
Definition: xf_ocv_ref.hpp:552
OCVFindMaximum1
bool OCVFindMaximum1(NMSTYPE t0, NMSTYPE t1, NMSTYPE t2, NMSTYPE m0, NMSTYPE m1, NMSTYPE m2, NMSTYPE b0, NMSTYPE b1, NMSTYPE b2)
Definition: xf_ocv_ref.hpp:446
NMSTYPE
float NMSTYPE
Definition: xf_ocv_ref.hpp:36
OCVMaxSuppression1
void OCVMaxSuppression1(cv::Mat &src, cv::Mat &dst)
Definition: xf_ocv_ref.hpp:454
test_lithops.result
result
Definition: test_lithops.py:38
xf_config_params.h
The WarpTransform IP configuration header.