Skip to content

O
opencv
Commit cd62f9f7 authored by Andrey Pavlenko's avatar Andrey Pavlenko Committed by OpenCV Buildbot
Browse files
Options

Merge pull request #1164 from bitwangyaoyao:master_fixHaar

parents c5e569d1 3d3e9ab6
Expand all Show whitespace changes
Inline Side-by-side
Showing with 36 additions and 167 deletions
modules/ocl/doc/object_detection.rst
View file @ cd62f9f7
......@@ -12,23 +12,20 @@ Cascade classifier class used for object detection. Supports HAAR cascade classi
class CV_EXPORTS OclCascadeClassifier : public CascadeClassifier
{
public:
OclCascadeClassifier() {};
~OclCascadeClassifier() {};
CvSeq *oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage,
double scaleFactor,int minNeighbors,
int flags, CvSize minSize = cvSize(0, 0),
CvSize maxSize = cvSize(0, 0));
void detectMultiScale(oclMat &image, CV_OUT std::vector<cv::Rect>& faces,
double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0,
Size minSize = Size(), Size maxSize = Size());
};
ocl::OclCascadeClassifier::oclHaarDetectObjects
------------------------------------------------------
Returns the detected objects by a list of rectangles
Detects objects of different sizes in the input image.
.. ocv:function:: CvSeq* ocl::OclCascadeClassifier::oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage, double scaleFactor,int minNeighbors, int flags, CvSize minSize = cvSize(0, 0), CvSize maxSize = cvSize(0, 0))
.. ocv:function:: void ocl::OclCascadeClassifier::detectMultiScale(oclMat &image, std::vector<cv::Rect>& faces, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size())
:param image: Matrix of type CV_8U containing an image where objects should be detected.
:param imageobjectsBuff: Buffer to store detected objects (rectangles). If it is empty, it is allocated with the defaultsize. If not empty, the function searches not more than N objects, where N = sizeof(objectsBufers data)/sizeof(cv::Rect).
:param faces: Vector of rectangles where each rectangle contains the detected object.
:param scaleFactor: Parameter specifying how much the image size is reduced at each image scale.
......@@ -36,7 +33,9 @@ Returns the detected objects by a list of rectangles
:param minSize: Minimum possible object size. Objects smaller than that are ignored.
Detects objects of different sizes in the input image,only tested for face detection now. The function returns the number of detected objects.
:param maxSize: Maximum possible object size. Objects larger than that are ignored.
The function provides a very similar interface with that in CascadeClassifier class, except using oclMat as input image.
ocl::MatchTemplateBuf
---------------------
......
modules/ocl/include/opencv2/ocl.hpp
View file @ cd62f9f7
......@@ -869,59 +869,13 @@ namespace cv
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////CascadeClassifier//////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if 0
class CV_EXPORTS OclCascadeClassifier : public cv::CascadeClassifier
{
public:
OclCascadeClassifier() {};
~OclCascadeClassifier() {};
CvSeq* oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage, double scaleFactor,
int minNeighbors, int flags, CvSize minSize = cvSize(0, 0), CvSize maxSize = cvSize(0, 0));
};
#endif
#if 0
class CV_EXPORTS OclCascadeClassifierBuf : public cv::CascadeClassifier
{
public:
OclCascadeClassifierBuf() :
m_flags(0), initialized(false), m_scaleFactor(0), buffers(NULL) {}
~OclCascadeClassifierBuf() { release(); }
void detectMultiScale(oclMat &image, CV_OUT std::vector<cv::Rect>& faces,
double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0,
Size minSize = Size(), Size maxSize = Size());
void release();
private:
void Init(const int rows, const int cols, double scaleFactor, int flags,
const int outputsz, const size_t localThreads[],
Size minSize, Size maxSize);
void CreateBaseBufs(const int datasize, const int totalclassifier, const int flags, const int outputsz);
void CreateFactorRelatedBufs(const int rows, const int cols, const int flags,
const double scaleFactor, const size_t localThreads[],
Size minSize, Size maxSize);
void GenResult(CV_OUT std::vector<cv::Rect>& faces, const std::vector<cv::Rect> &rectList, const std::vector<int> &rweights);
int m_rows;
int m_cols;
int m_flags;
int m_loopcount;
int m_nodenum;
bool findBiggestObject;
bool initialized;
double m_scaleFactor;
Size m_minSize;
Size m_maxSize;
std::vector<Size> sizev;
std::vector<float> scalev;
oclMat gimg1, gsum, gsqsum;
void * buffers;
};
#endif
/////////////////////////////// Pyramid /////////////////////////////////////
CV_EXPORTS void pyrDown(const oclMat &src, oclMat &dst);
......
modules/ocl/perf/perf_haar.cpp
View file @ cd62f9f7
......@@ -44,47 +44,8 @@
//
//M*/
#include "precomp.hpp"
#if 0
///////////// Haar ////////////////////////
namespace cv
{
namespace ocl
{
struct getRect
{
Rect operator()(const CvAvgComp &e) const
{
return e.rect;
}
};
class CascadeClassifier_GPU : public OclCascadeClassifier
{
public:
void detectMultiScale(oclMat &image,
CV_OUT std::vector<cv::Rect>& faces,
double scaleFactor = 1.1,
int minNeighbors = 3, int flags = 0,
Size minSize = Size(),
Size maxSize = Size())
{
(void)maxSize;
MemStorage storage(cvCreateMemStorage(0));
//CvMat img=image;
CvSeq *objs = oclHaarDetectObjects(image, storage, scaleFactor, minNeighbors, flags, minSize);
vector<CvAvgComp> vecAvgComp;
Seq<CvAvgComp>(objs).copyTo(vecAvgComp);
faces.resize(vecAvgComp.size());
std::transform(vecAvgComp.begin(), vecAvgComp.end(), faces.begin(), getRect());
}
};
}
}
PERFTEST(Haar)
{
Mat img = imread(abspath("basketball1.png"), IMREAD_GRAYSCALE);
......@@ -106,12 +67,12 @@ PERFTEST(Haar)
SUBTEST << img.cols << "x" << img.rows << "; scale image";
CPU_ON;
faceCascadeCPU.detectMultiScale(img, faces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
CPU_OFF;
vector<Rect> oclfaces;
ocl::CascadeClassifier_GPU faceCascade;
ocl::OclCascadeClassifier faceCascade;
if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml")))
{
......@@ -122,7 +83,7 @@ PERFTEST(Haar)
WARMUP_ON;
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
WARMUP_OFF;
if(faces.size() == oclfaces.size())
......@@ -134,14 +95,12 @@ PERFTEST(Haar)
GPU_ON;
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
GPU_OFF;
GPU_FULL_ON;
d_img.upload(img);
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
GPU_FULL_OFF;
}
\ No newline at end of file
#endif
modules/ocl/src/haar.cpp
View file @ cd62f9f7
This diff is collapsed.
modules/ocl/src/precomp.hpp
View file @ cd62f9f7
......@@ -64,7 +64,7 @@
#undef OPENCV_NOSTL
#include "opencv2/imgproc.hpp"
#include "opencv2/objdetect.hpp"
#include "opencv2/objdetect/objdetect_c.h"
#include "opencv2/ocl.hpp"
#include "opencv2/core/utility.hpp"
......
modules/ocl/test/test_objdetect.cpp
View file @ cd62f9f7
......@@ -44,9 +44,7 @@
//M*/
#include "precomp.hpp"
#include "opencv2/objdetect.hpp"
#include "opencv2/objdetect/objdetect_c.h"
using namespace std;
using namespace cv;
......@@ -185,18 +183,11 @@ INSTANTIATE_TEST_CASE_P(OCL_ObjDetect, HOG, testing::Combine(
testing::Values(Size(64, 128), Size(48, 96)),
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
#if 0
///////////////////////////// Haar //////////////////////////////
IMPLEMENT_PARAM_CLASS(CascadeName, std::string);
CascadeName cascade_frontalface_alt(std::string("haarcascade_frontalface_alt.xml"));
CascadeName cascade_frontalface_alt2(std::string("haarcascade_frontalface_alt2.xml"));
struct getRect
{
Rect operator ()(const CvAvgComp &e) const
{
return e.rect;
}
};
PARAM_TEST_CASE(Haar, int, CascadeName)
{
......@@ -224,49 +215,18 @@ PARAM_TEST_CASE(Haar, int, CascadeName)
TEST_P(Haar, FaceDetect)
{
MemStorage storage(cvCreateMemStorage(0));
CvSeq *_objects;
_objects = cascade.oclHaarDetectObjects(d_img, storage, 1.1, 3,
flags, Size(30, 30), Size(0, 0));
vector<CvAvgComp> vecAvgComp;
Seq<CvAvgComp>(_objects).copyTo(vecAvgComp);
oclfaces.resize(vecAvgComp.size());
std::transform(vecAvgComp.begin(), vecAvgComp.end(), oclfaces.begin(), getRect());
cpucascade.detectMultiScale(img, faces, 1.1, 3,
flags,
Size(30, 30), Size(0, 0));
cascade.detectMultiScale(d_img, oclfaces, 1.1, 3,
flags, Size(30, 30));
EXPECT_LT(checkRectSimilarity(img.size(), faces, oclfaces), 1.0);
}
TEST_P(Haar, FaceDetectUseBuf)
{
ocl::OclCascadeClassifierBuf cascadebuf;
if(!cascadebuf.load(cascadeName))
{
std::cout << "ERROR: Could not load classifier cascade for FaceDetectUseBuf!" << std::endl;
return;
}
cascadebuf.detectMultiScale(d_img, oclfaces, 1.1, 3,
flags,
Size(30, 30), Size(0, 0));
cpucascade.detectMultiScale(img, faces, 1.1, 3,
flags,
Size(30, 30), Size(0, 0));
// intentionally run ocl facedetect again and check if it still works after the first run
cascadebuf.detectMultiScale(d_img, oclfaces, 1.1, 3,
flags,
Size(30, 30));
cascadebuf.release();
flags, Size(30, 30));
EXPECT_LT(checkRectSimilarity(img.size(), faces, oclfaces), 1.0);
}
INSTANTIATE_TEST_CASE_P(OCL_ObjDetect, Haar,
Combine(Values(CV_HAAR_SCALE_IMAGE, 0),
Values(cascade_frontalface_alt/*, cascade_frontalface_alt2*/)));
#endif
Combine(Values((int)CASCADE_SCALE_IMAGE, 0),
Values(cascade_frontalface_alt, cascade_frontalface_alt2)));
#endif //HAVE_OPENCL
samples/ocl/facedetect.cpp
View file @ cd62f9f7
......@@ -8,9 +8,6 @@
#include <iostream>
#include <stdio.h>
int main( int, const char** ) { return 0; }
#if 0
using namespace std;
using namespace cv;
......@@ -46,7 +43,7 @@ static double getTime()
}
void detect( Mat& img, vector<Rect>& faces,
ocl::OclCascadeClassifierBuf& cascade,
ocl::OclCascadeClassifier& cascade,
double scale, bool calTime);
......@@ -66,20 +63,19 @@ double checkRectSimilarity(Size sz, vector<Rect>& cpu_rst, vector<Rect>& gpu_rst
int main( int argc, const char** argv )
{
const char* keys =
"{ h | help | false | print help message }"
"{ i | input | | specify input image }"
"{ t | template | haarcascade_frontalface_alt.xml |"
"{ h help | false | print help message }"
"{ i input | | specify input image }"
"{ t template | haarcascade_frontalface_alt.xml |"
" specify template file path }"
"{ c | scale | 1.0 | scale image }"
"{ s | use_cpu | false | use cpu or gpu to process the image }"
"{ o | output | facedetect_output.jpg |"
"{ c scale | 1.0 | scale image }"
"{ s use_cpu | false | use cpu or gpu to process the image }"
"{ o output | facedetect_output.jpg |"
" specify output image save path(only works when input is images) }";
CommandLineParser cmd(argc, argv, keys);
if (cmd.get<bool>("help"))
{
cout << "Avaible options:" << endl;
cmd.printParams();
return 0;
}
CvCapture* capture = 0;
......@@ -90,7 +86,7 @@ int main( int argc, const char** argv )
outputName = cmd.get<string>("o");
string cascadeName = cmd.get<string>("t");
double scale = cmd.get<double>("c");
ocl::OclCascadeClassifierBuf cascade;
ocl::OclCascadeClassifier cascade;
CascadeClassifier cpu_cascade;
if( !cascade.load( cascadeName ) || !cpu_cascade.load(cascadeName) )
......@@ -211,7 +207,7 @@ _cleanup_:
}
void detect( Mat& img, vector<Rect>& faces,
ocl::OclCascadeClassifierBuf& cascade,
ocl::OclCascadeClassifier& cascade,
double scale, bool calTime)
{
ocl::oclMat image(img);
......@@ -223,7 +219,7 @@ void detect( Mat& img, vector<Rect>& faces,
cascade.detectMultiScale( smallImg, faces, 1.1,
3, 0
|CV_HAAR_SCALE_IMAGE
|CASCADE_SCALE_IMAGE
, Size(30,30), Size(0, 0) );
if(calTime) workEnd();
}
......@@ -234,11 +230,11 @@ void detectCPU( Mat& img, vector<Rect>& faces,
{
if(calTime) workBegin();
Mat cpu_gray, cpu_smallImg( cvRound (img.rows/scale), cvRound(img.cols/scale), CV_8UC1 );
cvtColor(img, cpu_gray, CV_BGR2GRAY);
cvtColor(img, cpu_gray, COLOR_BGR2GRAY);
resize(cpu_gray, cpu_smallImg, cpu_smallImg.size(), 0, 0, INTER_LINEAR);
equalizeHist(cpu_smallImg, cpu_smallImg);
cascade.detectMultiScale(cpu_smallImg, faces, 1.1,
3, 0 | CV_HAAR_SCALE_IMAGE,
3, 0 | CASCADE_SCALE_IMAGE,
Size(30, 30), Size(0, 0));
if(calTime) workEnd();
}
......@@ -312,4 +308,3 @@ double checkRectSimilarity(Size sz, vector<Rect>& ob1, vector<Rect>& ob2)
}
return final_test_result;
}
\ No newline at end of file
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment