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