Peter M. Groen / openbr

Commit 0239196ada49e19f60023aecd32b1ff6607233ea

Authored by Josh Klontz
1 parent a301132a

removed cascade classifier

Inline Side-by-side
Showing 1 changed file with 0 additions and 327 deletions
openbr/plugins/classification/cascade_classifier.cpp deleted
View file @a301132
1 -#include <opencv2/imgproc/imgproc.hpp>  
2 -#include <opencv2/highgui/highgui.hpp>  
3 -  
4 -#include <openbr/plugins/openbr_internal.h>  
5 -#include <openbr/core/common.h>  
6 -#include "openbr/core/opencvutils.h"  
7 -  
8 -#include <QtConcurrent>  
9 -  
10 -using namespace cv;  
11 -  
12 -namespace br  
13 -{  
14 -  
15 -struct Miner  
16 -{  
17 - Template src;  
18 - Template scaledSrc;  
19 - Size windowSize;  
20 - Point offset, point;  
21 - float scale, scaleFactor, stepFactor;  
22 -  
23 - Miner(const Template &t, const Size &windowSize, const Point &offset) :  
24 - src(t),  
25 - windowSize(windowSize),  
26 - offset(offset),  
27 - point(offset)  
28 - {  
29 - scale = 1.0F;  
30 - scaleFactor = 1.4142135623730950488016887242097F;  
31 - stepFactor = 0.5F;  
32 -  
33 - scale = max(((float)windowSize.width + point.x) / ((float)src.m().cols),  
34 - ((float)windowSize.height + point.y) / ((float)src.m().rows));  
35 - Size size((int)(scale*src.m().cols + 0.5F), (int)(scale*src.m().rows + 0.5F));  
36 - scaledSrc = resize(src, size);  
37 - }  
38 -  
39 - Template resize(const Template &src, const Size &size)  
40 - {  
41 - Template dst(src.file);  
42 - for (int i=0; i<src.size(); i++) {  
43 - Mat buffer;  
44 - cv::resize(src[i], buffer, size);  
45 - dst.append(buffer);  
46 - }  
47 - return dst;  
48 - }  
49 -  
50 - Template mine(bool *newImg)  
51 - {  
52 - Template dst(src.file);  
53 - // Copy region of winSize region of img into m  
54 - for (int i=0; i<scaledSrc.size(); i++) {  
55 - Mat window(windowSize.height, windowSize.width, CV_8U,  
56 - (void*)(scaledSrc[i].data + point.y * scaledSrc[i].step + point.x * scaledSrc[i].elemSize()),  
57 - scaledSrc[i].step);  
58 - Mat sample;  
59 - window.copyTo(sample);  
60 - dst.append(sample);  
61 - }  
62 -  
63 - if ((int)(point.x + (1.0F + stepFactor) * windowSize.width) < scaledSrc.m().cols)  
64 - point.x += (int)(stepFactor * windowSize.width);  
65 - else {  
66 - point.x = offset.x;  
67 - if ((int)(point.y + (1.0F + stepFactor) * windowSize.height) < scaledSrc.m().rows)  
68 - point.y += (int)(stepFactor * windowSize.height);  
69 - else {  
70 - point.y = offset.y;  
71 - scale *= scaleFactor;  
72 - if (scale <= 1.0F) {  
73 - Size size((int)(scale*src.m().cols), (int)(scale*src.m().rows));  
74 - scaledSrc = resize(src, size);  
75 - } else {  
76 - *newImg = true;  
77 - return dst;  
78 - }  
79 - }  
80 - }  
81 -  
82 - *newImg = false;  
83 - return dst;  
84 - }  
85 -};  
86 -  
87 -/*!  
88 - * \brief A meta Classifier that creates a cascade of another Classifier. The cascade is a series of stages, each with its own instance of a given classifier. A sample can only reach the next stage if it is classified as positive by the previous stage.  
89 - * \author Jordan Cheney \cite jcheney  
90 - * \author Scott Klum \cite sklum  
91 - * \br_property int numStages The number of stages in the cascade  
92 - * \br_property int numPos The number of positives to feed each stage during training  
93 - * \br_property int numNegs The number of negatives to feed each stage during training. A negative sample must have been classified by the previous stages in the cascade as positive to be fed to the next stage during training.  
94 - * \br_property float maxFAR A termination parameter. Calculated as (number of passed negatives) / (total number of checked negatives) for a given stage during training. If that number is below the given maxFAR cascade training is terminated early. This can help prevent overfitting.  
95 - * \br_property bool requireAllStages If true, the cascade will train until it has the number of stages specified by numStages even if the FAR at a given is lower than maxFAR.  
96 - * \br_property int maxStage Parameter to limit the stages used at test time. If -1 (default), all numStages stages will be used.  
97 - * \br_paper Paul Viola, Michael Jones  
98 - * Rapid Object Detection using a Boosted Cascade of Simple Features  
99 - * CVPR, 2001  
100 - * \br_link Rapid Object Detection using a Boosted Cascade of Simple Features https://www.cs.cmu.edu/~efros/courses/LBMV07/Papers/viola-cvpr-01.pdf  
101 - */  
102 -class CascadeClassifier : public Classifier  
103 -{  
104 - Q_OBJECT  
105 -  
106 - Q_PROPERTY(QString stageDescription READ get_stageDescription WRITE set_stageDescription RESET reset_stageDescription STORED false)  
107 - Q_PROPERTY(int numStages READ get_numStages WRITE set_numStages RESET reset_numStages STORED false)  
108 - Q_PROPERTY(int numPos READ get_numPos WRITE set_numPos RESET reset_numPos STORED false)  
109 - Q_PROPERTY(int numNegs READ get_numNegs WRITE set_numNegs RESET reset_numNegs STORED false)  
110 - Q_PROPERTY(float maxFAR READ get_maxFAR WRITE set_maxFAR RESET reset_maxFAR STORED false)  
111 - Q_PROPERTY(bool requireAllStages READ get_requireAllStages WRITE set_requireAllStages RESET reset_requireAllStages STORED false)  
112 - Q_PROPERTY(int maxStage READ get_maxStage WRITE set_maxStage RESET reset_maxStage STORED false)  
113 - Q_PROPERTY(QList<br::Classifier*> stages READ get_stages WRITE set_stages RESET reset_stages STORED false)  
114 -  
115 - BR_PROPERTY(QString, stageDescription, "")  
116 - BR_PROPERTY(int, numStages, 20)  
117 - BR_PROPERTY(int, numPos, 1000)  
118 - BR_PROPERTY(int, numNegs, 1000)  
119 - BR_PROPERTY(float, maxFAR, pow(0.5, numStages))  
120 - BR_PROPERTY(bool, requireAllStages, false)  
121 - BR_PROPERTY(int, maxStage, -1)  
122 - BR_PROPERTY(QList<br::Classifier*>, stages, QList<br::Classifier*>())  
123 -  
124 - TemplateList posImages, negImages;  
125 - TemplateList posSamples, negSamples;  
126 -  
127 - QList<int> negIndices, posIndices;  
128 - int negIndex, posIndex, samplingRound;  
129 -  
130 - QMutex samplingMutex, miningMutex;  
131 -  
132 - void init()  
133 - {  
134 - negIndex = posIndex = samplingRound = 0;  
135 - }  
136 -  
137 - bool getPositive(Template &img)  
138 - {  
139 - if (posIndex >= posImages.size())  
140 - return false;  
141 - img = posImages[posIndices[posIndex++]];  
142 - return true;  
143 - }  
144 -  
145 - Template getNegative(Point &offset)  
146 - {  
147 - Template negative;  
148 -  
149 - const Size size = windowSize();  
150 - // Grab negative from list  
151 - int count = negImages.size();  
152 - for (int i = 0; i < count; i++) {  
153 - negative = negImages[negIndices[negIndex++]];  
154 -  
155 - samplingRound += negIndex / count;  
156 - samplingRound = samplingRound % (size.width * size.height);  
157 - negIndex %= count;  
158 -  
159 - offset.x = qMin( (int)samplingRound % size.width, negative.m().cols - size.width);  
160 - offset.y = qMin( (int)samplingRound / size.width, negative.m().rows - size.height);  
161 - if (!negative.m().empty() && negative.m().type() == CV_8U  
162 - && offset.x >= 0 && offset.y >= 0)  
163 - break;  
164 - }  
165 -  
166 - return negative;  
167 - }  
168 -  
169 - uint64 mine()  
170 - {  
171 - uint64 passedNegatives = 0;  
172 - forever {  
173 - Template negative;  
174 - Point offset;  
175 - QMutexLocker samplingLocker(&samplingMutex);  
176 - negative = getNegative(offset);  
177 - samplingLocker.unlock();  
178 -  
179 - Miner miner(negative, windowSize(), offset);  
180 - forever {  
181 - bool newImg;  
182 - Template sample = miner.mine(&newImg);  
183 - if (!newImg) {  
184 - if (negSamples.size() >= numNegs)  
185 - return passedNegatives;  
186 -  
187 - float confidence;  
188 - if (classify(sample, true, &confidence) != 0) {  
189 - QMutexLocker miningLocker(&miningMutex);  
190 - if (negSamples.size() >= numNegs)  
191 - return passedNegatives;  
192 - negSamples.append(sample);  
193 - printf("Negative samples: %d\r", negSamples.size());  
194 - }  
195 -  
196 - passedNegatives++;  
197 - } else  
198 - break;  
199 - }  
200 - }  
201 - }  
202 -  
203 - void train(const TemplateList &data)  
204 - {  
205 - foreach (const Template &t, data)  
206 - t.file.get<float>("Label") == 1.0f ? posImages.append(t) : negImages.append(t);  
207 -  
208 - qDebug() << "Total images:" << data.size()  
209 - << "\nTotal positive images:" << posImages.size()  
210 - << "\nTotal negative images:" << negImages.size();  
211 -  
212 - posIndices = Common::RandSample(posImages.size(), posImages.size(), true);  
213 - negIndices = Common::RandSample(negImages.size(), negImages.size(), true);  
214 -  
215 - stages.reserve(numStages);  
216 - for (int i = 0; i < numStages; i++) {  
217 - qDebug() << "===== TRAINING" << i << "stage =====";  
218 - qDebug() << "<BEGIN";  
219 -  
220 - Classifier *next_stage = Classifier::make(stageDescription, NULL);  
221 - stages.append(next_stage);  
222 -  
223 - float currFAR = getSamples();  
224 -  
225 - if (currFAR < maxFAR && !requireAllStages) {  
226 - qDebug() << "FAR is below required level! Terminating early";  
227 - return;  
228 - }  
229 -  
230 - stages.last()->train(posSamples + negSamples);  
231 -  
232 - qDebug() << "END>";  
233 - }  
234 - }  
235 -  
236 - float classify(const Template &src, bool process, float *confidence) const  
237 - {  
238 - float stageConf = 0.0f;  
239 - const int stopStage = maxStage == -1 ? numStages : maxStage;  
240 - int stageIndex = 0;  
241 - foreach (const Classifier *stage, stages) {  
242 - if (stageIndex++ == stopStage)  
243 - break;  
244 - float result = stage->classify(src, process, &stageConf);  
245 - if (confidence)  
246 - *confidence += stageConf;  
247 - if (result == 0.0f)  
248 - return 0.0f;  
249 - }  
250 - return 1.0f;  
251 - }  
252 -  
253 - int numFeatures() const  
254 - {  
255 - return stages.first()->numFeatures();  
256 - }  
257 -  
258 - Template preprocess(const Template &src) const  
259 - {  
260 - return stages.first()->preprocess(src);  
261 - }  
262 -  
263 - Size windowSize(int *dx = NULL, int *dy = NULL) const  
264 - {  
265 - return stages.first()->windowSize(dx, dy);  
266 - }  
267 -  
268 - void load(QDataStream &stream)  
269 - {  
270 - int numStages; stream >> numStages;  
271 - for (int i = 0; i < numStages; i++) {  
272 - Classifier *nextStage = Classifier::make(stageDescription, NULL);  
273 - nextStage->load(stream);  
274 - stages.append(nextStage);  
275 - }  
276 - }  
277 -  
278 - void store(QDataStream &stream) const  
279 - {  
280 - stream << stages.size();  
281 - foreach (const Classifier *stage, stages)  
282 - stage->store(stream);  
283 - }  
284 -  
285 -private:  
286 - float getSamples()  
287 - {  
288 - posSamples.clear(); posSamples.reserve(numPos);  
289 - negSamples.clear(); negSamples.reserve(numNegs);  
290 - posIndex = 0;  
291 -  
292 - float confidence;  
293 - while (posSamples.size() < numPos) {  
294 - Template pos;  
295 - if (!getPositive(pos))  
296 - qFatal("Cannot get another positive sample!");  
297 -  
298 - if (classify(pos, true, &confidence) > 0.0f) {  
299 - printf("POS current samples: %d\r", posSamples.size());  
300 - posSamples.append(pos);  
301 - }  
302 - }  
303 -  
304 - qDebug() << "POS count : consumed " << posSamples.size() << ":" << posIndex;  
305 -  
306 - QFutureSynchronizer<uint64> futures;  
307 - for (int i=0; i<QThread::idealThreadCount(); i++)  
308 - futures.addFuture(QtConcurrent::run(this, &CascadeClassifier::mine));  
309 - futures.waitForFinished();  
310 -  
311 - uint64 passedNegs = 0;  
312 - QList<QFuture<uint64> > results = futures.futures();  
313 - for (int i=0; i<results.size(); i++)  
314 - passedNegs += results[i].result();  
315 -  
316 - double acceptanceRatio = negSamples.size() / (double)passedNegs;  
317 - qDebug() << "NEG count : acceptanceRatio " << negSamples.size() << ":" << acceptanceRatio;  
318 -  
319 - return acceptanceRatio;  
320 - }  
321 -};  
322 -  
323 -BR_REGISTER(Classifier, CascadeClassifier)  
324 -  
325 -} // namespace br  
326 -  
327 -#include "classification/cascade_classifier.moc"