generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remove pow calculations

Browse Source
This commit is contained in:
marina.kolpakova 2012-09-28 16:32:33 +04:00
parent cc300a69b1
commit 0ff8a4633d
1 changed files with 48 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
modules/objdetect/src/softcascade.cpp
View File

@ -50,6 +50,11 @@
#include <cstdio> #include <cstdio>
#include <stdarg.h> #include <stdarg.h>
// use previous stored integrals for regression testing
// #define USE_REFERENCE_VALUES
#if defined USE_REFERENCE_VALUES
namespace { namespace {
char *itoa(long i, char* s, int /*dummy_radix*/) char *itoa(long i, char* s, int /*dummy_radix*/)
@ -58,6 +63,8 @@ char *itoa(long i, char* s, int /*dummy_radix*/)
return s; return s;
} }
#endif
// used for noisy printfs // used for noisy printfs
// #define WITH_DEBUG_OUT // #define WITH_DEBUG_OUT
@ -68,6 +75,8 @@ char *itoa(long i, char* s, int /*dummy_radix*/)
# define dprintf(format, ...) # define dprintf(format, ...)
#endif #endif
namespace {
struct Octave struct Octave
{ {
int index; int index;
@ -143,32 +152,6 @@ struct Object
Object(const cv::Rect& r, const float c, Class dt = PEDESTRIAN) : rect(r), confidence(c), detType(dt) {} Object(const cv::Rect& r, const float c, Class dt = PEDESTRIAN) : rect(r), confidence(c), detType(dt) {}
}; };
struct Level
{
const Octave* octave;
float origScale;
float relScale;
float shrScale; // used for marking detection
cv::Size workRect;
cv::Size objSize;
Level(const Octave& oct, const float scale, const int shrinkage, const int w, const int h)
: octave(&oct), origScale(scale), relScale(scale / oct.scale), shrScale (relScale / (float)shrinkage),
workRect(cv::Size(cvRound(w / (float)shrinkage),cvRound(h / (float)shrinkage))),
objSize(cv::Size(cvRound(oct.size.width * relScale), cvRound(oct.size.height * relScale)))
{}
void markDetection(const int x, const int y, float confidence, std::vector<Object>& detections) const
{
int shrinkage = (*octave).shrinkage;
cv::Rect rect(cvRound(x * shrinkage), cvRound(y * shrinkage), objSize.width, objSize.height);
detections.push_back(Object(rect, confidence));
}
};
struct CascadeIntrinsics struct CascadeIntrinsics
{ {
static const float lambda = 1.099f, a = 0.89f; static const float lambda = 1.099f, a = 0.89f;
@ -202,37 +185,36 @@ struct CascadeIntrinsics
} }
}; };
struct Level
int qangle6(float dfdx, float dfdy)
{ {
static const float vectors[6][2] = const Octave* octave;
float origScale;
float relScale;
float shrScale; // used for marking detection
cv::Size workRect;
cv::Size objSize;
float scaling[2];
Level(const Octave& oct, const float scale, const int shrinkage, const int w, const int h)
: octave(&oct), origScale(scale), relScale(scale / oct.scale), shrScale (relScale / (float)shrinkage),
workRect(cv::Size(cvRound(w / (float)shrinkage),cvRound(h / (float)shrinkage))),
objSize(cv::Size(cvRound(oct.size.width * relScale), cvRound(oct.size.height * relScale)))
{ {
{std::cos(0), std::sin(0) }, scaling[0] = CascadeIntrinsics::getFor(0, relScale);
{std::cos(M_PI / 6.f), std::sin(M_PI / 6.f) }, scaling[1] = CascadeIntrinsics::getFor(9, relScale);
{std::cos(M_PI / 3.f), std::sin(M_PI / 3.f) },
{std::cos(M_PI / 2.f), std::sin(M_PI / 2.f) },
{std::cos(2.f * M_PI / 3.f), std::sin(2.f * M_PI / 3.f)},
{std::cos(5.f * M_PI / 6.f), std::sin(5.f * M_PI / 6.f)}
};
int index = 0;
float dot = fabs(dfdx * vectors[0][0] + dfdy * vectors[0][1]);
for(int i = 1; i < 6; ++i)
{
const float curr = fabs(dfdx * vectors[i][0] + dfdy * vectors[i][1]);
if(curr > dot)
{
dot = curr;
index = i;
}
} }
return index; void markDetection(const int x, const int y, float confidence, std::vector<Object>& detections) const
} {
int shrinkage = (*octave).shrinkage;
cv::Rect rect(cvRound(x * shrinkage), cvRound(y * shrinkage), objSize.width, objSize.height);
detections.push_back(Object(rect, confidence));
}
};
template< typename T> template< typename T>
struct Decimate { struct Decimate {
@ -271,9 +253,6 @@ struct Decimate {
}; };
// use previous stored integrals for regression testing
// #define USE_REFERENCE_VALUES
struct ChannelStorage struct ChannelStorage
{ {
std::vector<cv::Mat> hog; std::vector<cv::Mat> hog;
@ -437,9 +416,10 @@ struct cv::SoftCascade::Filds
typedef std::vector<Octave>::iterator octIt_t; typedef std::vector<Octave>::iterator octIt_t;
float rescale(const Feature& feature, const float relScale, cv::Rect& scaledRect, const float threshold) const float rescale(const Feature& feature, const float scaling, const float relScale,
cv::Rect& scaledRect, const float threshold) const
{ {
float scaling = CascadeIntrinsics::getFor(feature.channel, relScale); // float scaling = CascadeIntrinsics::getFor(feature.channel, relScale);
scaledRect = feature.rect; scaledRect = feature.rect;
dprintf("feature %d box %d %d %d %d\n", feature.channel, scaledRect.x, scaledRect.y, dprintf("feature %d box %d %d %d %d\n", feature.channel, scaledRect.x, scaledRect.y,
@ -460,16 +440,16 @@ struct cv::SoftCascade::Filds
float sarea = (scaledRect.width - scaledRect.x) * (scaledRect.height - scaledRect.y); float sarea = (scaledRect.width - scaledRect.x) * (scaledRect.height - scaledRect.y);
float approx = 1.f; float approx = 1.f;
if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON) // if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
{ {
const float expected_new_area = farea * relScale * relScale; const float expected_new_area = farea * relScale * relScale;
approx = expected_new_area / sarea; approx = sarea / expected_new_area;
dprintf(" rel areas %f %f\n", expected_new_area, sarea); dprintf(" rel areas %f %f\n", expected_new_area, sarea);
} }
// compensation areas rounding // compensation areas rounding
float rootThreshold = threshold / approx; float rootThreshold = threshold * approx;
rootThreshold *= scaling; rootThreshold *= scaling;
dprintf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, scaling); dprintf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, scaling);
@ -504,7 +484,8 @@ struct cv::SoftCascade::Filds
const Node& node = nodes[nId]; const Node& node = nodes[nId];
const Feature& feature = features[node.feature]; const Feature& feature = features[node.feature];
cv::Rect scaledRect; cv::Rect scaledRect;
float threshold = rescale(feature, level.relScale, scaledRect, node.threshold); float threshold = rescale(feature, level.scaling[(int)(feature.channel > 6)],
level.relScale, scaledRect, node.threshold);
float sum = storage.get(dx, dy, feature.channel, scaledRect); float sum = storage.get(dx, dy, feature.channel, scaledRect);
@ -519,7 +500,8 @@ struct cv::SoftCascade::Filds
const Node& leaf = nodes[nId + next]; const Node& leaf = nodes[nId + next];
const Feature& fLeaf = features[leaf.feature]; const Feature& fLeaf = features[leaf.feature];
threshold = rescale(fLeaf, level.relScale, scaledRect, leaf.threshold); threshold = rescale(fLeaf, level.scaling[(int)(fLeaf.channel > 6)],
level.relScale, scaledRect, leaf.threshold);
sum = storage.get(dx, dy, fLeaf.channel, scaledRect); sum = storage.get(dx, dy, fLeaf.channel, scaledRect);
@ -546,7 +528,7 @@ struct cv::SoftCascade::Filds
if (st == stEnd) if (st == stEnd)
{ {
std::cout << " got " << st << std::endl; dprintf(" got %d\n", st);
level.markDetection(dx, dy, detectionScore, detections); level.markDetection(dx, dy, detectionScore, detections);
} }
} }
@ -701,25 +683,6 @@ struct cv::SoftCascade::Filds
} }
shrinkage = octaves[0].shrinkage; shrinkage = octaves[0].shrinkage;
//debug print
// std::cout << "collected " << stages.size() << " stages" << std::endl;
// for (int i = 0; i < (int)stages.size(); ++i)
// {
// std::cout << "stage " << i << ": " << stages[i].threshold << std::endl;
// }
// std::cout << "collected " << nodes.size() << " nodes" << std::endl;
// for (int i = 0; i < (int)nodes.size(); ++i)
// {
// std::cout << "node " << i << ": " << nodes[i].threshold << " " << nodes[i].feature << std::endl;
// }
// std::cout << "collected " << leaves.size() << " leaves" << std::endl;
// for (int i = 0; i < (int)leaves.size(); ++i)
// {
// std::cout << "leaf " << i << ": " << leaves[i] << std::endl;
// }
return true; return true;
} }
}; };
@ -752,8 +715,7 @@ bool cv::SoftCascade::load( const string& filename, const float minScale, const
return true; return true;
} }
// #define DEBUG_STORE_IMAGES // #define DEBUG_SHOW_RESULT
#define DEBUG_SHOW_RESULT
void cv::SoftCascade::detectMultiScale(const Mat& image, const std::vector<cv::Rect>& /*rois*/, void cv::SoftCascade::detectMultiScale(const Mat& image, const std::vector<cv::Rect>& /*rois*/,
std::vector<cv::Rect>& objects, const int /*rejectfactor*/) std::vector<cv::Rect>& objects, const int /*rejectfactor*/)
@ -772,26 +734,6 @@ void cv::SoftCascade::detectMultiScale(const Mat& image, const std::vector<cv::R
cv::Mat image1; cv::Mat image1;
cv::cvtColor(image, image1, CV_BGR2RGB); cv::cvtColor(image, image1, CV_BGR2RGB);
#if defined DEBUG_STORE_IMAGES
cv::FileStorage fs("/home/kellan/opencvInputImage.xml", cv::FileStorage::WRITE);
cv::imwrite("/home/kellan/opencvInputImage.jpg", image1);
fs << "opencvInputImage" << image1;
cv::Mat doppia;
cv::FileStorage fsr("/home/kellan/befireGause.xml", cv::FileStorage::READ);
fsr["input_gpu_mat"] >> doppia;
cv::Mat diff;
cv::absdiff(image1, doppia, diff);
fs << "absdiff" << diff;
fs.release();
#endif
cv::imshow("!!", image1);
cv::waitKey(0);
// create integrals // create integrals
ChannelStorage storage(image, fld.shrinkage); ChannelStorage storage(image, fld.shrinkage);
@ -831,9 +773,9 @@ void cv::SoftCascade::detectMultiScale(const Mat& image, const std::vector<cv::R
cv::imshow("out", out); cv::imshow("out", out);
cv::waitKey(0); cv::waitKey(0);
std::cout << "work rect: " << level.workRect.width << " " << level.workRect.height << std::endl;
#endif #endif
std::cout << "work rect: " << level.workRect.width << " " << level.workRect.height << std::endl;
detections.clear(); detections.clear();
} }