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
|
/* Copyright (c) 2012 Patrick Ruoff
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*/
#include "point_extractor.h"
#include <QDebug>
#ifdef DEBUG_EXTRACTION
# include "opentrack/timer.hpp"
#endif
PointExtractor::PointExtractor(){
//if (!AllocConsole()){}
//else SetConsoleTitle("debug");
//freopen("CON", "w", stdout);
//freopen("CON", "w", stderr);
}
// ----------------------------------------------------------------------------
std::vector<cv::Vec2f> PointExtractor::extract_points(cv::Mat& frame)
{
const int W = frame.cols;
const int H = frame.rows;
// convert to grayscale
cv::Mat frame_gray;
cv::cvtColor(frame, frame_gray, cv::COLOR_RGB2GRAY);
int min_size = s.min_point_size;
int max_size = s.max_point_size;
unsigned int region_size_min = 3.14*min_size*min_size/4.0;
unsigned int region_size_max = 3.14*max_size*max_size/4.0;
// testing indicates threshold difference of 45 from lowest to highest
// that's applicable to poor lighting conditions.
static constexpr int diff = 20;
static constexpr int steps = 5;
static constexpr int successes = 5;
int thres = s.threshold;
struct blob {
std::vector<cv::Vec2d> pos;
std::vector<double> confids;
std::vector<double> areas;
cv::Vec2d effective_pos() const
{
double x = 0;
double y = 0;
double norm = 0;
for (unsigned i = 0; i < pos.size(); i++)
{
const double w = confids[i] * areas[i];
x += pos[i][0] * w;
y += pos[i][1] * w;
norm += w;
}
cv::Vec2d ret(x, y);
ret *= 1./norm;
return ret;
}
};
struct simple_blob
{
double radius_2;
cv::Vec2d pos;
double confid;
bool taken;
double area;
simple_blob(double radius, const cv::Vec2d& pos, double confid, double area) : radius_2(radius*radius), pos(pos), confid(confid), taken(false), area(area)
{
//qDebug() << "radius" << radius << "pos" << pos[0] << pos[1] << "confid" << confid;
}
bool inside(const simple_blob& other)
{
cv::Vec2d tmp = pos - other.pos;
return tmp.dot(tmp) < radius_2;
}
static std::vector<blob> merge(std::vector<simple_blob>& blobs)
{
#ifdef DEBUG_EXTRACTION
static Timer t;
bool debug = t.elapsed_ms() > 100;
if (debug) t.start();
#endif
std::vector<blob> ret;
for (unsigned i = 0; i < blobs.size(); i++)
{
auto& b = blobs[i];
if (b.taken)
continue;
b.taken = true;
blob b_;
b_.pos.push_back(b.pos);
b_.confids.push_back(b.confid);
b_.areas.push_back(b.area);
for (unsigned j = i+1; j < blobs.size(); j++)
{
auto& b2 = blobs[j];
if (b2.taken)
continue;
if (b.inside(b2) || b2.inside(b))
{
b2.taken = true;
b_.pos.push_back(b2.pos);
b_.confids.push_back(b2.confid);
b_.areas.push_back(b2.area);
}
}
if (b_.pos.size() >= successes)
ret.push_back(b_);
}
#ifdef DEBUG_EXTRACTION
if (debug)
{
double diff = 0;
for (unsigned j = 0; j < ret.size(); j++)
{
auto& b = ret[j];
cv::Vec2d pos = b.effective_pos();
for (unsigned i = 0; i < b.pos.size(); i++)
{
auto tmp = pos - b.pos[i];
diff += std::abs(tmp.dot(tmp));
}
}
qDebug() << "diff" << diff;
}
#endif
return ret;
}
};
// mask for everything that passes the threshold (or: the upper threshold of the hysteresis)
cv::Mat frame_bin = cv::Mat::zeros(H, W, CV_8U);
const int min = std::max(0, thres - diff/2);
const int max = std::min(255, thres + diff/2);
const int step = std::max(1, diff / steps);
std::vector<simple_blob> blobs;
// this code is based on OpenCV SimpleBlobDetector
for (int i = min; i < max; i += step)
{
cv::Mat frame_bin_;
cv::threshold(frame_gray, frame_bin_, i, 255, cv::THRESH_BINARY);
frame_bin.setTo(170, frame_bin_);
std::vector<std::vector<cv::Point>> contours;
cv::findContours(frame_bin_, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
int cnt = 0;
for (auto& c : contours)
{
if (cnt++ > 30)
break;
auto m = cv::moments(cv::Mat(c));
const double area = m.m00;
if (area == 0.)
continue;
cv::Vec2d pos(m.m10 / m.m00, m.m01 / m.m00);
if (area < region_size_min || area > region_size_max)
continue;
double radius = 0;
for (auto& k : c)
{
cv::Vec2d pos_(k.x, k.y);
cv::Vec2d tmp = pos_ - pos;
radius = std::max(radius, sqrt(1e-2 + tmp.dot(tmp)));
}
double confid = 1;
{
double denominator = std::sqrt(std::pow(2 * m.mu11, 2) + std::pow(m.mu20 - m.mu02, 2));
const double eps = 1e-2;
if (denominator > eps)
{
double cosmin = (m.mu20 - m.mu02) / denominator;
double sinmin = 2 * m.mu11 / denominator;
double cosmax = -cosmin;
double sinmax = -sinmin;
double imin = 0.5 * (m.mu20 + m.mu02) - 0.5 * (m.mu20 - m.mu02) * cosmin - m.mu11 * sinmin;
double imax = 0.5 * (m.mu20 + m.mu02) - 0.5 * (m.mu20 - m.mu02) * cosmax - m.mu11 * sinmax;
confid = imin / imax;
}
}
blobs.push_back(simple_blob(radius, pos, confid, area));
}
}
// clear old points
points.clear();
for (auto& b : simple_blob::merge(blobs))
{
auto pos = b.effective_pos();
cv::Vec2f p((pos[0] - W/2)/W, -(pos[1] - H/2)/W);
points.push_back(p);
}
std::vector<cv::Mat> channels_;
cv::split(frame, channels_);
// draw output image
cv::Mat frame_bin_ = frame_bin * .5;
std::vector<cv::Mat> channels;
channels.push_back(channels_[0] + frame_bin_);
channels.push_back(channels_[1] - frame_bin_);
channels.push_back(channels_[2] - frame_bin_);
cv::merge(channels, frame);
return points;
}
|
