#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/photo/photo_c.h"
#include "opencv2/video/tracking_c.h"
+#include "opencv2/objdetect/objdetect_c.h"
#include "opencv2/legacy.hpp"
#include "opencv2/legacy/compat.hpp"
-#include "opencv2/objdetect.hpp"
-
#if !defined(CV_IMPL)
#define CV_IMPL extern "C"
#endif //CV_IMPL
#include "opencv2/highgui.hpp"
#include "opencv2/features2d.hpp"
#include "opencv2/calib3d.hpp"
+#include "opencv2/objdetect.hpp"
#endif
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/photo/photo_c.h"
#include "opencv2/video/tracking_c.h"
+#include "opencv2/objdetect/objdetect_c.h"
#include "opencv2/legacy.hpp"
#include "opencv2/legacy/compat.hpp"
#include "opencv2/legacy/blobtrack.hpp"
-
-#include "opencv2/objdetect.hpp"
#include "opencv2/contrib.hpp"
#endif
#include "opencv2/features2d.hpp"
#include "opencv2/objdetect.hpp"
+#include "opencv2/core/core_c.h"
+
#include <ostream>
#ifdef __cplusplus
// copy or use the software.
//
//
-// License Agreement
+// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
#ifndef __OPENCV_OBJDETECT_HPP__
#define __OPENCV_OBJDETECT_HPP__
-#ifdef __cplusplus
-# include "opencv2/core.hpp"
-#endif
-#include "opencv2/core/core_c.h"
-
-#ifdef __cplusplus
-#include <map>
-#include <deque>
-
-extern "C" {
-#endif
-
-/****************************************************************************************\
-* Haar-like Object Detection functions *
-\****************************************************************************************/
-
-#define CV_HAAR_MAGIC_VAL 0x42500000
-#define CV_TYPE_NAME_HAAR "opencv-haar-classifier"
-
-#define CV_IS_HAAR_CLASSIFIER( haar ) \
- ((haar) != NULL && \
- (((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL)
-
-#define CV_HAAR_FEATURE_MAX 3
-
-typedef struct CvHaarFeature
-{
- int tilted;
- struct
- {
- CvRect r;
- float weight;
- } rect[CV_HAAR_FEATURE_MAX];
-} CvHaarFeature;
-
-typedef struct CvHaarClassifier
-{
- int count;
- CvHaarFeature* haar_feature;
- float* threshold;
- int* left;
- int* right;
- float* alpha;
-} CvHaarClassifier;
-
-typedef struct CvHaarStageClassifier
-{
- int count;
- float threshold;
- CvHaarClassifier* classifier;
-
- int next;
- int child;
- int parent;
-} CvHaarStageClassifier;
+#include "opencv2/core.hpp"
-typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade;
-
-typedef struct CvHaarClassifierCascade
-{
- int flags;
- int count;
- CvSize orig_window_size;
- CvSize real_window_size;
- double scale;
- CvHaarStageClassifier* stage_classifier;
- CvHidHaarClassifierCascade* hid_cascade;
-} CvHaarClassifierCascade;
-
-typedef struct CvAvgComp
-{
- CvRect rect;
- int neighbors;
-} CvAvgComp;
-
-/* Loads haar classifier cascade from a directory.
- It is obsolete: convert your cascade to xml and use cvLoad instead */
-CVAPI(CvHaarClassifierCascade*) cvLoadHaarClassifierCascade(
- const char* directory, CvSize orig_window_size);
-
-CVAPI(void) cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade );
-
-#define CV_HAAR_DO_CANNY_PRUNING 1
-#define CV_HAAR_SCALE_IMAGE 2
-#define CV_HAAR_FIND_BIGGEST_OBJECT 4
-#define CV_HAAR_DO_ROUGH_SEARCH 8
-
-//CVAPI(CvSeq*) cvHaarDetectObjectsForROC( const CvArr* image,
-// CvHaarClassifierCascade* cascade, CvMemStorage* storage,
-// CvSeq** rejectLevels, CvSeq** levelWeightds,
-// double scale_factor CV_DEFAULT(1.1),
-// int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
-// CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0)),
-// bool outputRejectLevels = false );
-
-
-CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image,
- CvHaarClassifierCascade* cascade, CvMemStorage* storage,
- double scale_factor CV_DEFAULT(1.1),
- int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
- CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0)));
-
-/* sets images for haar classifier cascade */
-CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade,
- const CvArr* sum, const CvArr* sqsum,
- const CvArr* tilted_sum, double scale );
-
-/* runs the cascade on the specified window */
-CVAPI(int) cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade,
- CvPoint pt, int start_stage CV_DEFAULT(0));
-
-
-/****************************************************************************************\
-* Latent SVM Object Detection functions *
-\****************************************************************************************/
-
-// DataType: STRUCT position
-// Structure describes the position of the filter in the feature pyramid
-// l - level in the feature pyramid
-// (x, y) - coordinate in level l
-typedef struct CvLSVMFilterPosition
-{
- int x;
- int y;
- int l;
-} CvLSVMFilterPosition;
-
-// DataType: STRUCT filterObject
-// Description of the filter, which corresponds to the part of the object
-// V - ideal (penalty = 0) position of the partial filter
-// from the root filter position (V_i in the paper)
-// penaltyFunction - vector describes penalty function (d_i in the paper)
-// pf[0] * x + pf[1] * y + pf[2] * x^2 + pf[3] * y^2
-// FILTER DESCRIPTION
-// Rectangular map (sizeX x sizeY),
-// every cell stores feature vector (dimension = p)
-// H - matrix of feature vectors
-// to set and get feature vectors (i,j)
-// used formula H[(j * sizeX + i) * p + k], where
-// k - component of feature vector in cell (i, j)
-// END OF FILTER DESCRIPTION
-typedef struct CvLSVMFilterObject{
- CvLSVMFilterPosition V;
- float fineFunction[4];
- int sizeX;
- int sizeY;
- int numFeatures;
- float *H;
-} CvLSVMFilterObject;
-
-// data type: STRUCT CvLatentSvmDetector
-// structure contains internal representation of trained Latent SVM detector
-// num_filters - total number of filters (root plus part) in model
-// num_components - number of components in model
-// num_part_filters - array containing number of part filters for each component
-// filters - root and part filters for all model components
-// b - biases for all model components
-// score_threshold - confidence level threshold
-typedef struct CvLatentSvmDetector
-{
- int num_filters;
- int num_components;
- int* num_part_filters;
- CvLSVMFilterObject** filters;
- float* b;
- float score_threshold;
-}
-CvLatentSvmDetector;
-
-// data type: STRUCT CvObjectDetection
-// structure contains the bounding box and confidence level for detected object
-// rect - bounding box for a detected object
-// score - confidence level
-typedef struct CvObjectDetection
-{
- CvRect rect;
- float score;
-} CvObjectDetection;
-
-//////////////// Object Detection using Latent SVM //////////////
-
-
-/*
-// load trained detector from a file
-//
-// API
-// CvLatentSvmDetector* cvLoadLatentSvmDetector(const char* filename);
-// INPUT
-// filename - path to the file containing the parameters of
- - trained Latent SVM detector
-// OUTPUT
-// trained Latent SVM detector in internal representation
-*/
-CVAPI(CvLatentSvmDetector*) cvLoadLatentSvmDetector(const char* filename);
-
-/*
-// release memory allocated for CvLatentSvmDetector structure
-//
-// API
-// void cvReleaseLatentSvmDetector(CvLatentSvmDetector** detector);
-// INPUT
-// detector - CvLatentSvmDetector structure to be released
-// OUTPUT
-*/
-CVAPI(void) cvReleaseLatentSvmDetector(CvLatentSvmDetector** detector);
-
-/*
-// find rectangular regions in the given image that are likely
-// to contain objects and corresponding confidence levels
-//
-// API
-// CvSeq* cvLatentSvmDetectObjects(const IplImage* image,
-// CvLatentSvmDetector* detector,
-// CvMemStorage* storage,
-// float overlap_threshold = 0.5f,
-// int numThreads = -1);
-// INPUT
-// image - image to detect objects in
-// detector - Latent SVM detector in internal representation
-// storage - memory storage to store the resultant sequence
-// of the object candidate rectangles
-// overlap_threshold - threshold for the non-maximum suppression algorithm
- = 0.5f [here will be the reference to original paper]
-// OUTPUT
-// sequence of detected objects (bounding boxes and confidence levels stored in CvObjectDetection structures)
-*/
-CVAPI(CvSeq*) cvLatentSvmDetectObjects(IplImage* image,
- CvLatentSvmDetector* detector,
- CvMemStorage* storage,
- float overlap_threshold CV_DEFAULT(0.5f),
- int numThreads CV_DEFAULT(-1));
-
-#ifdef __cplusplus
-}
-
-CV_EXPORTS CvSeq* cvHaarDetectObjectsForROC( const CvArr* image,
- CvHaarClassifierCascade* cascade, CvMemStorage* storage,
- std::vector<int>& rejectLevels, std::vector<double>& levelWeightds,
- double scale_factor CV_DEFAULT(1.1),
- int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
- CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0)),
- bool outputRejectLevels = false );
+typedef struct CvLatentSvmDetector CvLatentSvmDetector;
+typedef struct CvHaarClassifierCascade CvHaarClassifierCascade;
namespace cv
{
struct CV_EXPORTS ObjectDetection
{
ObjectDetection();
- ObjectDetection( const Rect& rect, float score, int classID=-1 );
+ ObjectDetection( const Rect& rect, float score, int classID = -1 );
Rect rect;
float score;
int classID;
};
LatentSvmDetector();
- LatentSvmDetector( const std::vector<String>& filenames, const std::vector<String>& classNames=std::vector<String>() );
+ LatentSvmDetector( const std::vector<String>& filenames, const std::vector<String>& classNames = std::vector<String>() );
virtual ~LatentSvmDetector();
virtual void clear();
virtual bool empty() const;
- bool load( const std::vector<String>& filenames, const std::vector<String>& classNames=std::vector<String>() );
+ bool load( const std::vector<String>& filenames, const std::vector<String>& classNames = std::vector<String>() );
virtual void detect( const Mat& image,
std::vector<ObjectDetection>& objectDetections,
- float overlapThreshold=0.5f,
- int numThreads=-1 );
+ float overlapThreshold = 0.5f,
+ int numThreads = -1 );
const std::vector<String>& getClassNames() const;
size_t getClassCount() const;
std::vector<String> classNames;
};
-CV_EXPORTS void groupRectangles(CV_OUT CV_IN_OUT std::vector<Rect>& rectList, int groupThreshold, double eps=0.2);
-CV_EXPORTS_W void groupRectangles(CV_OUT CV_IN_OUT std::vector<Rect>& rectList, CV_OUT std::vector<int>& weights, int groupThreshold, double eps=0.2);
-CV_EXPORTS void groupRectangles( std::vector<Rect>& rectList, int groupThreshold, double eps, std::vector<int>* weights, std::vector<double>* levelWeights );
-CV_EXPORTS void groupRectangles(std::vector<Rect>& rectList, std::vector<int>& rejectLevels,
- std::vector<double>& levelWeights, int groupThreshold, double eps=0.2);
-CV_EXPORTS void groupRectangles_meanshift(std::vector<Rect>& rectList, std::vector<double>& foundWeights, std::vector<double>& foundScales,
+CV_EXPORTS void groupRectangles(std::vector<Rect>& rectList, int groupThreshold, double eps = 0.2);
+CV_EXPORTS_W void groupRectangles(CV_IN_OUT std::vector<Rect>& rectList, CV_OUT std::vector<int>& weights, int groupThreshold, double eps = 0.2);
+CV_EXPORTS void groupRectangles(std::vector<Rect>& rectList, int groupThreshold, double eps, std::vector<int>* weights, std::vector<double>* levelWeights );
+CV_EXPORTS void groupRectangles(std::vector<Rect>& rectList, std::vector<int>& rejectLevels,
+ std::vector<double>& levelWeights, int groupThreshold, double eps = 0.2);
+CV_EXPORTS void groupRectangles_meanshift(std::vector<Rect>& rectList, std::vector<double>& foundWeights, std::vector<double>& foundScales,
double detectThreshold = 0.0, Size winDetSize = Size(64, 128));
-
class CV_EXPORTS FeatureEvaluator
{
public:
- enum { HAAR = 0, LBP = 1, HOG = 2 };
+ enum { HAAR = 0,
+ LBP = 1,
+ HOG = 2
+ };
+
virtual ~FeatureEvaluator();
virtual bool read(const FileNode& node);
template<> CV_EXPORTS void Ptr<CvHaarClassifierCascade>::delete_obj();
-enum
-{
- CASCADE_DO_CANNY_PRUNING=1,
- CASCADE_SCALE_IMAGE=2,
- CASCADE_FIND_BIGGEST_OBJECT=4,
- CASCADE_DO_ROUGH_SEARCH=8
-};
+enum { CASCADE_DO_CANNY_PRUNING = 1,
+ CASCADE_SCALE_IMAGE = 2,
+ CASCADE_FIND_BIGGEST_OBJECT = 4,
+ CASCADE_DO_ROUGH_SEARCH = 8
+ };
class CV_EXPORTS_W CascadeClassifier
{
virtual bool read( const FileNode& node );
CV_WRAP virtual void detectMultiScale( const Mat& image,
CV_OUT std::vector<Rect>& objects,
- double scaleFactor=1.1,
- int minNeighbors=3, int flags=0,
- Size minSize=Size(),
- Size maxSize=Size() );
+ double scaleFactor = 1.1,
+ int minNeighbors = 3, int flags = 0,
+ Size minSize = Size(),
+ Size maxSize = Size() );
CV_WRAP virtual void detectMultiScale( const Mat& image,
CV_OUT std::vector<Rect>& objects,
CV_OUT std::vector<int>& rejectLevels,
CV_OUT std::vector<double>& levelWeights,
- double scaleFactor=1.1,
- int minNeighbors=3, int flags=0,
- Size minSize=Size(),
- Size maxSize=Size(),
- bool outputRejectLevels=false );
+ double scaleFactor = 1.1,
+ int minNeighbors = 3, int flags = 0,
+ Size minSize = Size(),
+ Size maxSize = Size(),
+ bool outputRejectLevels = false );
bool isOldFormatCascade() const;
bool setImage( const Mat& );
protected:
- //virtual bool detectSingleScale( const Mat& image, int stripCount, Size processingRectSize,
- // int stripSize, int yStep, double factor, std::vector<Rect>& candidates );
-
virtual bool detectSingleScale( const Mat& image, int stripCount, Size processingRectSize,
int stripSize, int yStep, double factor, std::vector<Rect>& candidates,
- std::vector<int>& rejectLevels, std::vector<double>& levelWeights, bool outputRejectLevels=false);
+ std::vector<int>& rejectLevels, std::vector<double>& levelWeights, bool outputRejectLevels = false);
protected:
- enum { BOOST = 0 };
- enum { DO_CANNY_PRUNING = 1, SCALE_IMAGE = 2,
- FIND_BIGGEST_OBJECT = 4, DO_ROUGH_SEARCH = 8 };
+ enum { BOOST = 0
+ };
+ enum { DO_CANNY_PRUNING = CASCADE_DO_CANNY_PRUNING,
+ SCALE_IMAGE = CASCADE_SCALE_IMAGE,
+ FIND_BIGGEST_OBJECT = CASCADE_FIND_BIGGEST_OBJECT,
+ DO_ROUGH_SEARCH = CASCADE_DO_ROUGH_SEARCH
+ };
friend class CascadeClassifierInvoker;
struct CV_EXPORTS_W HOGDescriptor
{
public:
- enum { L2Hys=0 };
- enum { DEFAULT_NLEVELS=64 };
+ enum { L2Hys = 0
+ };
+ enum { DEFAULT_NLEVELS = 64
+ };
CV_WRAP HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8),
cellSize(8,8), nbins(9), derivAperture(1), winSigma(-1),
virtual bool read(FileNode& fn);
virtual void write(FileStorage& fs, const String& objname) const;
- CV_WRAP virtual bool load(const String& filename, const String& objname=String());
- CV_WRAP virtual void save(const String& filename, const String& objname=String()) const;
+ CV_WRAP virtual bool load(const String& filename, const String& objname = String());
+ CV_WRAP virtual void save(const String& filename, const String& objname = String()) const;
virtual void copyTo(HOGDescriptor& c) const;
CV_WRAP virtual void compute(const Mat& img,
CV_OUT std::vector<float>& descriptors,
- Size winStride=Size(), Size padding=Size(),
- const std::vector<Point>& locations
=std::vector<Point>()) const;
+ Size winStride = Size(), Size padding = Size(),
+ const std::vector<Point>& locations
= std::vector<Point>()) const;
//with found weights output
CV_WRAP virtual void detect(const Mat& img, CV_OUT std::vector<Point>& foundLocations,
CV_OUT std::vector<double>& weights,
- double hitThreshold=0, Size winStride=Size(),
- Size padding=Size(),
- const std::vector<Point>& searchLocations
=std::vector<Point>()) const;
+ double hitThreshold = 0, Size winStride = Size(),
+ Size padding = Size(),
+ const std::vector<Point>& searchLocations
= std::vector<Point>()) const;
//without found weights output
virtual void detect(const Mat& img, CV_OUT std::vector<Point>& foundLocations,
- double hitThreshold=0, Size winStride=Size(),
- Size padding=Size(),
+ double hitThreshold = 0, Size winStride = Size(),
+ Size padding = Size(),
const std::vector<Point>& searchLocations=std::vector<Point>()) const;
//with result weights output
CV_WRAP virtual void detectMultiScale(const Mat& img, CV_OUT std::vector<Rect>& foundLocations,
- CV_OUT std::vector<double>& foundWeights, double hitThreshold=0,
- Size winStride=Size(), Size padding=Size(), double scale=1.05,
- double finalThreshold=2.0,bool useMeanshiftGrouping = false) const;
+ CV_OUT std::vector<double>& foundWeights, double hitThreshold = 0,
+ Size winStride = Size(), Size padding = Size(), double scale = 1.05,
+ double finalThreshold = 2.0,bool useMeanshiftGrouping = false) const;
//without found weights output
virtual void detectMultiScale(const Mat& img, CV_OUT std::vector<Rect>& foundLocations,
- double hitThreshold=0, Size winStride=Size(),
- Size padding=Size(), double scale=1.05,
- double finalThreshold=2.0, bool useMeanshiftGrouping = false) const;
+ double hitThreshold = 0, Size winStride = Size(),
+ Size padding = Size(), double scale = 1.05,
+ double finalThreshold = 2.0, bool useMeanshiftGrouping = false) const;
CV_WRAP virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,
- Size paddingTL=Size(), Size paddingBR=Size()) const;
+ Size paddingTL = Size(), Size paddingBR = Size()) const;
CV_WRAP static std::vector<float> getDefaultPeopleDetector();
CV_WRAP static std::vector<float> getDaimlerPeopleDetector();
CV_EXPORTS_W void findDataMatrix(InputArray image,
CV_OUT std::vector<String>& codes,
- OutputArray corners=noArray(),
- OutputArrayOfArrays dmtx=noArray());
+ OutputArray corners = noArray(),
+ OutputArrayOfArrays dmtx = noArray());
+
CV_EXPORTS_W void drawDataMatrixCodes(InputOutputArray image,
const std::vector<String>& codes,
InputArray corners);
}
-/****************************************************************************************\
-* Datamatrix *
-\****************************************************************************************/
-
-struct CV_EXPORTS CvDataMatrixCode {
- char msg[4];
- CvMat *original;
- CvMat *corners;
-};
-
-CV_EXPORTS std::deque<CvDataMatrixCode> cvFindDataMatrix(CvMat *im);
-
-/****************************************************************************************\
-* LINE-MOD *
-\****************************************************************************************/
-
-namespace cv {
-namespace linemod {
-
-/// @todo Convert doxy comments to rst
-
-/**
- * \brief Discriminant feature described by its location and label.
- */
-struct CV_EXPORTS Feature
-{
- int x; ///< x offset
- int y; ///< y offset
- int label; ///< Quantization
-
- Feature() : x(0), y(0), label(0) {}
- Feature(int x, int y, int label);
-
- void read(const FileNode& fn);
- void write(FileStorage& fs) const;
-};
-
-inline Feature::Feature(int _x, int _y, int _label) : x(_x), y(_y), label(_label) {}
-
-struct CV_EXPORTS Template
-{
- int width;
- int height;
- int pyramid_level;
- std::vector<Feature> features;
-
- void read(const FileNode& fn);
- void write(FileStorage& fs) const;
-};
-
-/**
- * \brief Represents a modality operating over an image pyramid.
- */
-class QuantizedPyramid
-{
-public:
- // Virtual destructor
- virtual ~QuantizedPyramid() {}
-
- /**
- * \brief Compute quantized image at current pyramid level for online detection.
- *
- * \param[out] dst The destination 8-bit image. For each pixel at most one bit is set,
- * representing its classification.
- */
- virtual void quantize(Mat& dst) const =0;
-
- /**
- * \brief Extract most discriminant features at current pyramid level to form a new template.
- *
- * \param[out] templ The new template.
- */
- virtual bool extractTemplate(Template& templ) const =0;
-
- /**
- * \brief Go to the next pyramid level.
- *
- * \todo Allow pyramid scale factor other than 2
- */
- virtual void pyrDown() =0;
-
-protected:
- /// Candidate feature with a score
- struct Candidate
- {
- Candidate(int x, int y, int label, float score);
-
- /// Sort candidates with high score to the front
- bool operator<(const Candidate& rhs) const
- {
- return score > rhs.score;
- }
-
- Feature f;
- float score;
- };
-
- /**
- * \brief Choose candidate features so that they are not bunched together.
- *
- * \param[in] candidates Candidate features sorted by score.
- * \param[out] features Destination vector of selected features.
- * \param[in] num_features Number of candidates to select.
- * \param[in] distance Hint for desired distance between features.
- */
- static void selectScatteredFeatures(const std::vector<Candidate>& candidates,
- std::vector<Feature>& features,
- size_t num_features, float distance);
-};
-
-inline QuantizedPyramid::Candidate::Candidate(int x, int y, int label, float _score) : f(x, y, label), score(_score) {}
-
-/**
- * \brief Interface for modalities that plug into the LINE template matching representation.
- *
- * \todo Max response, to allow optimization of summing (255/MAX) features as uint8
- */
-class CV_EXPORTS Modality
-{
-public:
- // Virtual destructor
- virtual ~Modality() {}
-
- /**
- * \brief Form a quantized image pyramid from a source image.
- *
- * \param[in] src The source image. Type depends on the modality.
- * \param[in] mask Optional mask. If not empty, unmasked pixels are set to zero
- * in quantized image and cannot be extracted as features.
- */
- Ptr<QuantizedPyramid> process(const Mat& src,
- const Mat& mask = Mat()) const
- {
- return processImpl(src, mask);
- }
-
- virtual String name() const =0;
-
- virtual void read(const FileNode& fn) =0;
- virtual void write(FileStorage& fs) const =0;
-
- /**
- * \brief Create modality by name.
- *
- * The following modality types are supported:
- * - "ColorGradient"
- * - "DepthNormal"
- */
- static Ptr<Modality> create(const String& modality_type);
-
- /**
- * \brief Load a modality from file.
- */
- static Ptr<Modality> create(const FileNode& fn);
-
-protected:
- // Indirection is because process() has a default parameter.
- virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
- const Mat& mask) const =0;
-};
-
-/**
- * \brief Modality that computes quantized gradient orientations from a color image.
- */
-class CV_EXPORTS ColorGradient : public Modality
-{
-public:
- /**
- * \brief Default constructor. Uses reasonable default parameter values.
- */
- ColorGradient();
-
- /**
- * \brief Constructor.
- *
- * \param weak_threshold When quantizing, discard gradients with magnitude less than this.
- * \param num_features How many features a template must contain.
- * \param strong_threshold Consider as candidate features only gradients whose norms are
- * larger than this.
- */
- ColorGradient(float weak_threshold, size_t num_features, float strong_threshold);
-
- virtual String name() const;
-
- virtual void read(const FileNode& fn);
- virtual void write(FileStorage& fs) const;
-
- float weak_threshold;
- size_t num_features;
- float strong_threshold;
-
-protected:
- virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
- const Mat& mask) const;
-};
-
-/**
- * \brief Modality that computes quantized surface normals from a dense depth map.
- */
-class CV_EXPORTS DepthNormal : public Modality
-{
-public:
- /**
- * \brief Default constructor. Uses reasonable default parameter values.
- */
- DepthNormal();
-
- /**
- * \brief Constructor.
- *
- * \param distance_threshold Ignore pixels beyond this distance.
- * \param difference_threshold When computing normals, ignore contributions of pixels whose
- * depth difference with the central pixel is above this threshold.
- * \param num_features How many features a template must contain.
- * \param extract_threshold Consider as candidate feature only if there are no differing
- * orientations within a distance of extract_threshold.
- */
- DepthNormal(int distance_threshold, int difference_threshold, size_t num_features,
- int extract_threshold);
-
- virtual String name() const;
-
- virtual void read(const FileNode& fn);
- virtual void write(FileStorage& fs) const;
-
- int distance_threshold;
- int difference_threshold;
- size_t num_features;
- int extract_threshold;
-
-protected:
- virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
- const Mat& mask) const;
-};
-
-/**
- * \brief Debug function to colormap a quantized image for viewing.
- */
-void colormap(const Mat& quantized, Mat& dst);
-
-/**
- * \brief Represents a successful template match.
- */
-struct CV_EXPORTS Match
-{
- Match()
- {
- }
-
- Match(int x, int y, float similarity, const String& class_id, int template_id);
-
- /// Sort matches with high similarity to the front
- bool operator<(const Match& rhs) const
- {
- // Secondarily sort on template_id for the sake of duplicate removal
- if (similarity != rhs.similarity)
- return similarity > rhs.similarity;
- else
- return template_id < rhs.template_id;
- }
-
- bool operator==(const Match& rhs) const
- {
- return x == rhs.x && y == rhs.y && similarity == rhs.similarity && class_id == rhs.class_id;
- }
-
- int x;
- int y;
- float similarity;
- String class_id;
- int template_id;
-};
-
-inline Match::Match(int _x, int _y, float _similarity, const String& _class_id, int _template_id)
- : x(_x), y(_y), similarity(_similarity), class_id(_class_id), template_id(_template_id)
- {
- }
-
-/**
- * \brief Object detector using the LINE template matching algorithm with any set of
- * modalities.
- */
-class CV_EXPORTS Detector
-{
-public:
- /**
- * \brief Empty constructor, initialize with read().
- */
- Detector();
-
- /**
- * \brief Constructor.
- *
- * \param modalities Modalities to use (color gradients, depth normals, ...).
- * \param T_pyramid Value of the sampling step T at each pyramid level. The
- * number of pyramid levels is T_pyramid.size().
- */
- Detector(const std::vector< Ptr<Modality> >& modalities, const std::vector<int>& T_pyramid);
-
- /**
- * \brief Detect objects by template matching.
- *
- * Matches globally at the lowest pyramid level, then refines locally stepping up the pyramid.
- *
- * \param sources Source images, one for each modality.
- * \param threshold Similarity threshold, a percentage between 0 and 100.
- * \param[out] matches Template matches, sorted by similarity score.
- * \param class_ids If non-empty, only search for the desired object classes.
- * \param[out] quantized_images Optionally return vector<Mat> of quantized images.
- * \param masks The masks for consideration during matching. The masks should be CV_8UC1
- * where 255 represents a valid pixel. If non-empty, the vector must be
- * the same size as sources. Each element must be
- * empty or the same size as its corresponding source.
- */
- void match(const std::vector<Mat>& sources, float threshold, std::vector<Match>& matches,
- const std::vector<String>& class_ids = std::vector<String>(),
- OutputArrayOfArrays quantized_images = noArray(),
- const std::vector<Mat>& masks = std::vector<Mat>()) const;
-
- /**
- * \brief Add new object template.
- *
- * \param sources Source images, one for each modality.
- * \param class_id Object class ID.
- * \param object_mask Mask separating object from background.
- * \param[out] bounding_box Optionally return bounding box of the extracted features.
- *
- * \return Template ID, or -1 if failed to extract a valid template.
- */
- int addTemplate(const std::vector<Mat>& sources, const String& class_id,
- const Mat& object_mask, Rect* bounding_box = NULL);
-
- /**
- * \brief Add a new object template computed by external means.
- */
- int addSyntheticTemplate(const std::vector<Template>& templates, const String& class_id);
-
- /**
- * \brief Get the modalities used by this detector.
- *
- * You are not permitted to add/remove modalities, but you may dynamic_cast them to
- * tweak parameters.
- */
- const std::vector< Ptr<Modality> >& getModalities() const { return modalities; }
-
- /**
- * \brief Get sampling step T at pyramid_level.
- */
- int getT(int pyramid_level) const { return T_at_level[pyramid_level]; }
-
- /**
- * \brief Get number of pyramid levels used by this detector.
- */
- int pyramidLevels() const { return pyramid_levels; }
-
- /**
- * \brief Get the template pyramid identified by template_id.
- *
- * For example, with 2 modalities (Gradient, Normal) and two pyramid levels
- * (L0, L1), the order is (GradientL0, NormalL0, GradientL1, NormalL1).
- */
- const std::vector<Template>& getTemplates(const String& class_id, int template_id) const;
-
- int numTemplates() const;
- int numTemplates(const String& class_id) const;
- int numClasses() const { return static_cast<int>(class_templates.size()); }
-
- std::vector<String> classIds() const;
-
- void read(const FileNode& fn);
- void write(FileStorage& fs) const;
-
- String readClass(const FileNode& fn, const String &class_id_override = "");
- void writeClass(const String& class_id, FileStorage& fs) const;
-
- void readClasses(const std::vector<String>& class_ids,
- const String& format = "templates_%s.yml.gz");
- void writeClasses(const String& format = "templates_%s.yml.gz") const;
-
-protected:
- std::vector< Ptr<Modality> > modalities;
- int pyramid_levels;
- std::vector<int> T_at_level;
-
- typedef std::vector<Template> TemplatePyramid;
- typedef std::map<String, std::vector<TemplatePyramid> > TemplatesMap;
- TemplatesMap class_templates;
-
- typedef std::vector<Mat> LinearMemories;
- // Indexed as [pyramid level][modality][quantized label]
- typedef std::vector< std::vector<LinearMemories> > LinearMemoryPyramid;
-
- void matchClass(const LinearMemoryPyramid& lm_pyramid,
- const std::vector<Size>& sizes,
- float threshold, std::vector<Match>& matches,
- const String& class_id,
- const std::vector<TemplatePyramid>& template_pyramids) const;
-};
-
-/**
- * \brief Factory function for detector using LINE algorithm with color gradients.
- *
- * Default parameter settings suitable for VGA images.
- */
-CV_EXPORTS Ptr<Detector> getDefaultLINE();
-
-/**
- * \brief Factory function for detector using LINE-MOD algorithm with color gradients
- * and depth normals.
- *
- * Default parameter settings suitable for VGA images.
- */
-CV_EXPORTS Ptr<Detector> getDefaultLINEMOD();
-
-} // namespace linemod
-} // namespace cv
-
-#endif
+#include "opencv2/objdetect/linemod.hpp"
#endif
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_OBJDETECT_LINEMOD_HPP__
+#define __OPENCV_OBJDETECT_LINEMOD_HPP__
+
+#include "opencv2/core.hpp"
+#include <map>
+
+/****************************************************************************************\
+* LINE-MOD *
+\****************************************************************************************/
+
+namespace cv {
+namespace linemod {
+
+/// @todo Convert doxy comments to rst
+
+/**
+ * \brief Discriminant feature described by its location and label.
+ */
+struct CV_EXPORTS Feature
+{
+ int x; ///< x offset
+ int y; ///< y offset
+ int label; ///< Quantization
+
+ Feature() : x(0), y(0), label(0) {}
+ Feature(int x, int y, int label);
+
+ void read(const FileNode& fn);
+ void write(FileStorage& fs) const;
+};
+
+inline Feature::Feature(int _x, int _y, int _label) : x(_x), y(_y), label(_label) {}
+
+struct CV_EXPORTS Template
+{
+ int width;
+ int height;
+ int pyramid_level;
+ std::vector<Feature> features;
+
+ void read(const FileNode& fn);
+ void write(FileStorage& fs) const;
+};
+
+/**
+ * \brief Represents a modality operating over an image pyramid.
+ */
+class QuantizedPyramid
+{
+public:
+ // Virtual destructor
+ virtual ~QuantizedPyramid() {}
+
+ /**
+ * \brief Compute quantized image at current pyramid level for online detection.
+ *
+ * \param[out] dst The destination 8-bit image. For each pixel at most one bit is set,
+ * representing its classification.
+ */
+ virtual void quantize(Mat& dst) const =0;
+
+ /**
+ * \brief Extract most discriminant features at current pyramid level to form a new template.
+ *
+ * \param[out] templ The new template.
+ */
+ virtual bool extractTemplate(Template& templ) const =0;
+
+ /**
+ * \brief Go to the next pyramid level.
+ *
+ * \todo Allow pyramid scale factor other than 2
+ */
+ virtual void pyrDown() =0;
+
+protected:
+ /// Candidate feature with a score
+ struct Candidate
+ {
+ Candidate(int x, int y, int label, float score);
+
+ /// Sort candidates with high score to the front
+ bool operator<(const Candidate& rhs) const
+ {
+ return score > rhs.score;
+ }
+
+ Feature f;
+ float score;
+ };
+
+ /**
+ * \brief Choose candidate features so that they are not bunched together.
+ *
+ * \param[in] candidates Candidate features sorted by score.
+ * \param[out] features Destination vector of selected features.
+ * \param[in] num_features Number of candidates to select.
+ * \param[in] distance Hint for desired distance between features.
+ */
+ static void selectScatteredFeatures(const std::vector<Candidate>& candidates,
+ std::vector<Feature>& features,
+ size_t num_features, float distance);
+};
+
+inline QuantizedPyramid::Candidate::Candidate(int x, int y, int label, float _score) : f(x, y, label), score(_score) {}
+
+/**
+ * \brief Interface for modalities that plug into the LINE template matching representation.
+ *
+ * \todo Max response, to allow optimization of summing (255/MAX) features as uint8
+ */
+class CV_EXPORTS Modality
+{
+public:
+ // Virtual destructor
+ virtual ~Modality() {}
+
+ /**
+ * \brief Form a quantized image pyramid from a source image.
+ *
+ * \param[in] src The source image. Type depends on the modality.
+ * \param[in] mask Optional mask. If not empty, unmasked pixels are set to zero
+ * in quantized image and cannot be extracted as features.
+ */
+ Ptr<QuantizedPyramid> process(const Mat& src,
+ const Mat& mask = Mat()) const
+ {
+ return processImpl(src, mask);
+ }
+
+ virtual String name() const =0;
+
+ virtual void read(const FileNode& fn) =0;
+ virtual void write(FileStorage& fs) const =0;
+
+ /**
+ * \brief Create modality by name.
+ *
+ * The following modality types are supported:
+ * - "ColorGradient"
+ * - "DepthNormal"
+ */
+ static Ptr<Modality> create(const String& modality_type);
+
+ /**
+ * \brief Load a modality from file.
+ */
+ static Ptr<Modality> create(const FileNode& fn);
+
+protected:
+ // Indirection is because process() has a default parameter.
+ virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
+ const Mat& mask) const =0;
+};
+
+/**
+ * \brief Modality that computes quantized gradient orientations from a color image.
+ */
+class CV_EXPORTS ColorGradient : public Modality
+{
+public:
+ /**
+ * \brief Default constructor. Uses reasonable default parameter values.
+ */
+ ColorGradient();
+
+ /**
+ * \brief Constructor.
+ *
+ * \param weak_threshold When quantizing, discard gradients with magnitude less than this.
+ * \param num_features How many features a template must contain.
+ * \param strong_threshold Consider as candidate features only gradients whose norms are
+ * larger than this.
+ */
+ ColorGradient(float weak_threshold, size_t num_features, float strong_threshold);
+
+ virtual String name() const;
+
+ virtual void read(const FileNode& fn);
+ virtual void write(FileStorage& fs) const;
+
+ float weak_threshold;
+ size_t num_features;
+ float strong_threshold;
+
+protected:
+ virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
+ const Mat& mask) const;
+};
+
+/**
+ * \brief Modality that computes quantized surface normals from a dense depth map.
+ */
+class CV_EXPORTS DepthNormal : public Modality
+{
+public:
+ /**
+ * \brief Default constructor. Uses reasonable default parameter values.
+ */
+ DepthNormal();
+
+ /**
+ * \brief Constructor.
+ *
+ * \param distance_threshold Ignore pixels beyond this distance.
+ * \param difference_threshold When computing normals, ignore contributions of pixels whose
+ * depth difference with the central pixel is above this threshold.
+ * \param num_features How many features a template must contain.
+ * \param extract_threshold Consider as candidate feature only if there are no differing
+ * orientations within a distance of extract_threshold.
+ */
+ DepthNormal(int distance_threshold, int difference_threshold, size_t num_features,
+ int extract_threshold);
+
+ virtual String name() const;
+
+ virtual void read(const FileNode& fn);
+ virtual void write(FileStorage& fs) const;
+
+ int distance_threshold;
+ int difference_threshold;
+ size_t num_features;
+ int extract_threshold;
+
+protected:
+ virtual Ptr<QuantizedPyramid> processImpl(const Mat& src,
+ const Mat& mask) const;
+};
+
+/**
+ * \brief Debug function to colormap a quantized image for viewing.
+ */
+void colormap(const Mat& quantized, Mat& dst);
+
+/**
+ * \brief Represents a successful template match.
+ */
+struct CV_EXPORTS Match
+{
+ Match()
+ {
+ }
+
+ Match(int x, int y, float similarity, const String& class_id, int template_id);
+
+ /// Sort matches with high similarity to the front
+ bool operator<(const Match& rhs) const
+ {
+ // Secondarily sort on template_id for the sake of duplicate removal
+ if (similarity != rhs.similarity)
+ return similarity > rhs.similarity;
+ else
+ return template_id < rhs.template_id;
+ }
+
+ bool operator==(const Match& rhs) const
+ {
+ return x == rhs.x && y == rhs.y && similarity == rhs.similarity && class_id == rhs.class_id;
+ }
+
+ int x;
+ int y;
+ float similarity;
+ String class_id;
+ int template_id;
+};
+
+inline
+Match::Match(int _x, int _y, float _similarity, const String& _class_id, int _template_id)
+ : x(_x), y(_y), similarity(_similarity), class_id(_class_id), template_id(_template_id)
+{}
+
+/**
+ * \brief Object detector using the LINE template matching algorithm with any set of
+ * modalities.
+ */
+class CV_EXPORTS Detector
+{
+public:
+ /**
+ * \brief Empty constructor, initialize with read().
+ */
+ Detector();
+
+ /**
+ * \brief Constructor.
+ *
+ * \param modalities Modalities to use (color gradients, depth normals, ...).
+ * \param T_pyramid Value of the sampling step T at each pyramid level. The
+ * number of pyramid levels is T_pyramid.size().
+ */
+ Detector(const std::vector< Ptr<Modality> >& modalities, const std::vector<int>& T_pyramid);
+
+ /**
+ * \brief Detect objects by template matching.
+ *
+ * Matches globally at the lowest pyramid level, then refines locally stepping up the pyramid.
+ *
+ * \param sources Source images, one for each modality.
+ * \param threshold Similarity threshold, a percentage between 0 and 100.
+ * \param[out] matches Template matches, sorted by similarity score.
+ * \param class_ids If non-empty, only search for the desired object classes.
+ * \param[out] quantized_images Optionally return vector<Mat> of quantized images.
+ * \param masks The masks for consideration during matching. The masks should be CV_8UC1
+ * where 255 represents a valid pixel. If non-empty, the vector must be
+ * the same size as sources. Each element must be
+ * empty or the same size as its corresponding source.
+ */
+ void match(const std::vector<Mat>& sources, float threshold, std::vector<Match>& matches,
+ const std::vector<String>& class_ids = std::vector<String>(),
+ OutputArrayOfArrays quantized_images = noArray(),
+ const std::vector<Mat>& masks = std::vector<Mat>()) const;
+
+ /**
+ * \brief Add new object template.
+ *
+ * \param sources Source images, one for each modality.
+ * \param class_id Object class ID.
+ * \param object_mask Mask separating object from background.
+ * \param[out] bounding_box Optionally return bounding box of the extracted features.
+ *
+ * \return Template ID, or -1 if failed to extract a valid template.
+ */
+ int addTemplate(const std::vector<Mat>& sources, const String& class_id,
+ const Mat& object_mask, Rect* bounding_box = NULL);
+
+ /**
+ * \brief Add a new object template computed by external means.
+ */
+ int addSyntheticTemplate(const std::vector<Template>& templates, const String& class_id);
+
+ /**
+ * \brief Get the modalities used by this detector.
+ *
+ * You are not permitted to add/remove modalities, but you may dynamic_cast them to
+ * tweak parameters.
+ */
+ const std::vector< Ptr<Modality> >& getModalities() const { return modalities; }
+
+ /**
+ * \brief Get sampling step T at pyramid_level.
+ */
+ int getT(int pyramid_level) const { return T_at_level[pyramid_level]; }
+
+ /**
+ * \brief Get number of pyramid levels used by this detector.
+ */
+ int pyramidLevels() const { return pyramid_levels; }
+
+ /**
+ * \brief Get the template pyramid identified by template_id.
+ *
+ * For example, with 2 modalities (Gradient, Normal) and two pyramid levels
+ * (L0, L1), the order is (GradientL0, NormalL0, GradientL1, NormalL1).
+ */
+ const std::vector<Template>& getTemplates(const String& class_id, int template_id) const;
+
+ int numTemplates() const;
+ int numTemplates(const String& class_id) const;
+ int numClasses() const { return static_cast<int>(class_templates.size()); }
+
+ std::vector<String> classIds() const;
+
+ void read(const FileNode& fn);
+ void write(FileStorage& fs) const;
+
+ String readClass(const FileNode& fn, const String &class_id_override = "");
+ void writeClass(const String& class_id, FileStorage& fs) const;
+
+ void readClasses(const std::vector<String>& class_ids,
+ const String& format = "templates_%s.yml.gz");
+ void writeClasses(const String& format = "templates_%s.yml.gz") const;
+
+protected:
+ std::vector< Ptr<Modality> > modalities;
+ int pyramid_levels;
+ std::vector<int> T_at_level;
+
+ typedef std::vector<Template> TemplatePyramid;
+ typedef std::map<String, std::vector<TemplatePyramid> > TemplatesMap;
+ TemplatesMap class_templates;
+
+ typedef std::vector<Mat> LinearMemories;
+ // Indexed as [pyramid level][modality][quantized label]
+ typedef std::vector< std::vector<LinearMemories> > LinearMemoryPyramid;
+
+ void matchClass(const LinearMemoryPyramid& lm_pyramid,
+ const std::vector<Size>& sizes,
+ float threshold, std::vector<Match>& matches,
+ const String& class_id,
+ const std::vector<TemplatePyramid>& template_pyramids) const;
+};
+
+/**
+ * \brief Factory function for detector using LINE algorithm with color gradients.
+ *
+ * Default parameter settings suitable for VGA images.
+ */
+CV_EXPORTS Ptr<Detector> getDefaultLINE();
+
+/**
+ * \brief Factory function for detector using LINE-MOD algorithm with color gradients
+ * and depth normals.
+ *
+ * Default parameter settings suitable for VGA images.
+ */
+CV_EXPORTS Ptr<Detector> getDefaultLINEMOD();
+
+} // namespace linemod
+} // namespace cv
+
+#endif // __OPENCV_OBJDETECT_LINEMOD_HPP__
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_OBJDETECT_C_H__
+#define __OPENCV_OBJDETECT_C_H__
+
+#include "opencv2/core/core_c.h"
+
+#ifdef __cplusplus
+#include <deque>
+#include <vector>
+
+extern "C" {
+#endif
+
+/****************************************************************************************\
+* Haar-like Object Detection functions *
+\****************************************************************************************/
+
+#define CV_HAAR_MAGIC_VAL 0x42500000
+#define CV_TYPE_NAME_HAAR "opencv-haar-classifier"
+
+#define CV_IS_HAAR_CLASSIFIER( haar ) \
+ ((haar) != NULL && \
+ (((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL)
+
+#define CV_HAAR_FEATURE_MAX 3
+
+typedef struct CvHaarFeature
+{
+ int tilted;
+ struct
+ {
+ CvRect r;
+ float weight;
+ } rect[CV_HAAR_FEATURE_MAX];
+} CvHaarFeature;
+
+typedef struct CvHaarClassifier
+{
+ int count;
+ CvHaarFeature* haar_feature;
+ float* threshold;
+ int* left;
+ int* right;
+ float* alpha;
+} CvHaarClassifier;
+
+typedef struct CvHaarStageClassifier
+{
+ int count;
+ float threshold;
+ CvHaarClassifier* classifier;
+
+ int next;
+ int child;
+ int parent;
+} CvHaarStageClassifier;
+
+typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade;
+
+typedef struct CvHaarClassifierCascade
+{
+ int flags;
+ int count;
+ CvSize orig_window_size;
+ CvSize real_window_size;
+ double scale;
+ CvHaarStageClassifier* stage_classifier;
+ CvHidHaarClassifierCascade* hid_cascade;
+} CvHaarClassifierCascade;
+
+typedef struct CvAvgComp
+{
+ CvRect rect;
+ int neighbors;
+} CvAvgComp;
+
+/* Loads haar classifier cascade from a directory.
+ It is obsolete: convert your cascade to xml and use cvLoad instead */
+CVAPI(CvHaarClassifierCascade*) cvLoadHaarClassifierCascade(
+ const char* directory, CvSize orig_window_size);
+
+CVAPI(void) cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade );
+
+#define CV_HAAR_DO_CANNY_PRUNING 1
+#define CV_HAAR_SCALE_IMAGE 2
+#define CV_HAAR_FIND_BIGGEST_OBJECT 4
+#define CV_HAAR_DO_ROUGH_SEARCH 8
+
+CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image,
+ CvHaarClassifierCascade* cascade, CvMemStorage* storage,
+ double scale_factor CV_DEFAULT(1.1),
+ int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
+ CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0)));
+
+/* sets images for haar classifier cascade */
+CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade,
+ const CvArr* sum, const CvArr* sqsum,
+ const CvArr* tilted_sum, double scale );
+
+/* runs the cascade on the specified window */
+CVAPI(int) cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade,
+ CvPoint pt, int start_stage CV_DEFAULT(0));
+
+
+/****************************************************************************************\
+* Latent SVM Object Detection functions *
+\****************************************************************************************/
+
+// DataType: STRUCT position
+// Structure describes the position of the filter in the feature pyramid
+// l - level in the feature pyramid
+// (x, y) - coordinate in level l
+typedef struct CvLSVMFilterPosition
+{
+ int x;
+ int y;
+ int l;
+} CvLSVMFilterPosition;
+
+// DataType: STRUCT filterObject
+// Description of the filter, which corresponds to the part of the object
+// V - ideal (penalty = 0) position of the partial filter
+// from the root filter position (V_i in the paper)
+// penaltyFunction - vector describes penalty function (d_i in the paper)
+// pf[0] * x + pf[1] * y + pf[2] * x^2 + pf[3] * y^2
+// FILTER DESCRIPTION
+// Rectangular map (sizeX x sizeY),
+// every cell stores feature vector (dimension = p)
+// H - matrix of feature vectors
+// to set and get feature vectors (i,j)
+// used formula H[(j * sizeX + i) * p + k], where
+// k - component of feature vector in cell (i, j)
+// END OF FILTER DESCRIPTION
+typedef struct CvLSVMFilterObject{
+ CvLSVMFilterPosition V;
+ float fineFunction[4];
+ int sizeX;
+ int sizeY;
+ int numFeatures;
+ float *H;
+} CvLSVMFilterObject;
+
+// data type: STRUCT CvLatentSvmDetector
+// structure contains internal representation of trained Latent SVM detector
+// num_filters - total number of filters (root plus part) in model
+// num_components - number of components in model
+// num_part_filters - array containing number of part filters for each component
+// filters - root and part filters for all model components
+// b - biases for all model components
+// score_threshold - confidence level threshold
+typedef struct CvLatentSvmDetector
+{
+ int num_filters;
+ int num_components;
+ int* num_part_filters;
+ CvLSVMFilterObject** filters;
+ float* b;
+ float score_threshold;
+} CvLatentSvmDetector;
+
+// data type: STRUCT CvObjectDetection
+// structure contains the bounding box and confidence level for detected object
+// rect - bounding box for a detected object
+// score - confidence level
+typedef struct CvObjectDetection
+{
+ CvRect rect;
+ float score;
+} CvObjectDetection;
+
+//////////////// Object Detection using Latent SVM //////////////
+
+
+/*
+// load trained detector from a file
+//
+// API
+// CvLatentSvmDetector* cvLoadLatentSvmDetector(const char* filename);
+// INPUT
+// filename - path to the file containing the parameters of
+ - trained Latent SVM detector
+// OUTPUT
+// trained Latent SVM detector in internal representation
+*/
+CVAPI(CvLatentSvmDetector*) cvLoadLatentSvmDetector(const char* filename);
+
+/*
+// release memory allocated for CvLatentSvmDetector structure
+//
+// API
+// void cvReleaseLatentSvmDetector(CvLatentSvmDetector** detector);
+// INPUT
+// detector - CvLatentSvmDetector structure to be released
+// OUTPUT
+*/
+CVAPI(void) cvReleaseLatentSvmDetector(CvLatentSvmDetector** detector);
+
+/*
+// find rectangular regions in the given image that are likely
+// to contain objects and corresponding confidence levels
+//
+// API
+// CvSeq* cvLatentSvmDetectObjects(const IplImage* image,
+// CvLatentSvmDetector* detector,
+// CvMemStorage* storage,
+// float overlap_threshold = 0.5f,
+// int numThreads = -1);
+// INPUT
+// image - image to detect objects in
+// detector - Latent SVM detector in internal representation
+// storage - memory storage to store the resultant sequence
+// of the object candidate rectangles
+// overlap_threshold - threshold for the non-maximum suppression algorithm
+ = 0.5f [here will be the reference to original paper]
+// OUTPUT
+// sequence of detected objects (bounding boxes and confidence levels stored in CvObjectDetection structures)
+*/
+CVAPI(CvSeq*) cvLatentSvmDetectObjects(IplImage* image,
+ CvLatentSvmDetector* detector,
+ CvMemStorage* storage,
+ float overlap_threshold CV_DEFAULT(0.5f),
+ int numThreads CV_DEFAULT(-1));
+
+#ifdef __cplusplus
+}
+
+CV_EXPORTS CvSeq* cvHaarDetectObjectsForROC( const CvArr* image,
+ CvHaarClassifierCascade* cascade, CvMemStorage* storage,
+ std::vector<int>& rejectLevels, std::vector<double>& levelWeightds,
+ double scale_factor = 1.1,
+ int min_neighbors = 3, int flags = 0,
+ CvSize min_size = cvSize(0, 0), CvSize max_size = cvSize(0, 0),
+ bool outputRejectLevels = false );
+
+struct CvDataMatrixCode
+{
+ char msg[4];
+ CvMat* original;
+ CvMat* corners;
+};
+
+CV_EXPORTS std::deque<CvDataMatrixCode> cvFindDataMatrix(CvMat *im);
+
+#endif
+
+
+#endif /* __OPENCV_OBJDETECT_C_H__ */
#ifndef _LSVM_ROUTINE_H_
#define _LSVM_ROUTINE_H_
+#include "opencv2/objdetect/objdetect_c.h"
+
#include "_lsvm_types.h"
#include "_lsvm_error.h"
#ifndef LSVM_PARSER
#define LSVM_PARSER
+#include "opencv2/objdetect/objdetect_c.h"
#include "_lsvm_types.h"
#include <cstdio>
#include "cascadedetect.hpp"
+#include "opencv2/objdetect/objdetect_c.h"
#if defined (LOG_CASCADE_STATISTIC)
struct Logger
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/objdetect/objdetect_c.h"
-#include <deque>
#include <algorithm>
class Sampler {
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/objdetect/objdetect_c.h"
#include <stdio.h>
#if CV_SSE2
//M*/
#include "precomp.hpp"
+#include "opencv2/core/core_c.h"
#include <cstdio>
#include <iterator>
String eerr("file not exist");
String efile(__FILE__);
String efunc(__FUNCTION__);
- throw Exception(CV_StsError, eerr, efile, efunc, __LINE__);
+ throw Exception(Error::StsError, eerr, efile, efunc, __LINE__);
}
char version_buffer[10];
if (!fread (&version_buffer,sizeof(char),10,modelfl))
String eerr("version?");
String efile(__FILE__);
String efunc(__FUNCTION__);
- throw Exception(CV_StsError, eerr, efile, efunc, __LINE__);
+ throw Exception(Error::StsError, eerr, efile, efunc, __LINE__);
}
if(strcmp(version_buffer,"V6.01")) {
String eerr("version doesnot match");
String efile(__FILE__);
String efunc(__FUNCTION__);
- throw Exception(CV_StsError, eerr, efile, efunc, __LINE__);
+ throw Exception(Error::StsError, eerr, efile, efunc, __LINE__);
}
/* read version number */
int version = 0;
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/objdetect/objdetect_c.h"
#include "_lsvmparser.h"
#include "_lsvm_matching.h"
case 64: return 6;
case 128: return 7;
default:
- CV_Error(CV_StsBadArg, "Invalid value of quantized parameter");
+ CV_Error(Error::StsBadArg, "Invalid value of quantized parameter");
return -1; //avoid warning
}
}
if (quantized_images.needed())
quantized_images.create(1, static_cast<int>(pyramid_levels * modalities.size()), CV_8U);
- assert(sources.size() == modalities.size());
+ CV_Assert(sources.size() == modalities.size());
// Initialize each modality with our sources
std::vector< Ptr<QuantizedPyramid> > quantizers;
for (int i = 0; i < (int)modalities.size(); ++i){
Mat mask, source;
source = sources[i];
if(!masks.empty()){
- assert(masks.size() == modalities.size());
+ CV_Assert(masks.size() == modalities.size());
mask = masks[i];
}
- assert(mask.empty() || mask.size() == source.size());
+ CV_Assert(mask.empty() || mask.size() == source.size());
quantizers.push_back(modalities[i]->process(source, mask));
}
// pyramid level -> modality -> quantization
#include "precomp.hpp"
+#include "opencv2/objdetect/objdetect_c.h"
#include "_lsvm_matching.h"
#include <stdio.h>
#include "test_precomp.hpp"
#include "opencv2/imgproc.hpp"
+#include "opencv2/objdetect/objdetect_c.h"
using namespace cv;
using namespace std;
// fn[TOTAL_NO_PAIR_E] >> eps.totalNoPair;
// read detectors
- if( fn[DETECTOR_NAMES].node->data.seq != 0 )
+ if( fn[DETECTOR_NAMES].size() != 0 )
{
FileNodeIterator it = fn[DETECTOR_NAMES].begin();
for( ; it != fn[DETECTOR_NAMES].end(); )
// read images filenames and images
string dataPath = ts->get_data_path();
- if( fn[IMAGE_FILENAMES].node->data.seq != 0 )
+ if( fn[IMAGE_FILENAMES].size() != 0 )
{
for( FileNodeIterator it = fn[IMAGE_FILENAMES].begin(); it != fn[IMAGE_FILENAMES].end(); )
{
{
char buf[10];
sprintf( buf, "%s%d", "img_", ii );
- cvWriteComment( validationFS.fs, buf, 0 );
+ //cvWriteComment( validationFS.fs, buf, 0 );
validationFS << *it;
}
validationFS << "]"; // IMAGE_FILENAMES
string imageIdxStr = buf;
FileNode node = validationFS.getFirstTopLevelNode()[VALIDATION][detectorNames[detectorIdx]][imageIdxStr];
vector<Rect> valRects;
- if( node.node->data.seq != 0 )
+ if( node.size() != 0 )
{
for( FileNodeIterator it2 = node.begin(); it2 != node.end(); )
{
if( flag )
flags.push_back( 0 );
else
- flags.push_back( CV_HAAR_SCALE_IMAGE );
+ flags.push_back( CASCADE_SCALE_IMAGE );
}
void CV_CascadeDetectorTest::writeDetector( FileStorage& fs, int di )
{
- int sc = flags[di] & CV_HAAR_SCALE_IMAGE ? 0 : 1;
+ int sc = flags[di] & CASCADE_SCALE_IMAGE ? 0 : 1;
fs << FILENAME << detectorFilenames[di];
fs << C_SCALE_CASCADE << sc;
}
CvMat c_gray = grayImg;
CvSeq* rs = cvHaarDetectObjects(&c_gray, c_cascade, storage, 1.1, 3, flags[di] );
-
+
objects.clear();
for( int i = 0; i < rs->total; i++ )
{
void CV_HOGDetectorTest::readDetector( const FileNode& fn )
{
String filename;
- if( fn[FILENAME].node->data.seq != 0 )
+ if( fn[FILENAME].size() != 0 )
fn[FILENAME] >> filename;
detectorFilenames.push_back( filename);
}
}
const double eps = 0.0;
- double diff_norm = norm(Mat(actual_weights) - Mat(weights), CV_L2);
+ double diff_norm = norm(Mat(actual_weights) - Mat(weights), NORM_L2);
if (diff_norm > eps)
{
ts->printf(cvtest::TS::SUMMARY, "Weights for found locations aren't equal.\n"
std::vector<float> actual_descriptors;
actual_hog->compute(img, actual_descriptors, winStride, padding, locations);
- double diff_norm = cv::norm(Mat(actual_descriptors) - Mat(descriptors), CV_L2);
+ double diff_norm = cv::norm(Mat(actual_descriptors) - Mat(descriptors), NORM_L2);
const double eps = 0.0;
if (diff_norm > eps)
{
const double eps = 0.0;
for (i = 0; i < 2; ++i)
{
- double diff_norm = norm(reference_mats[i] - actual_mats[i], CV_L2);
+ double diff_norm = norm(reference_mats[i] - actual_mats[i], NORM_L2);
if (diff_norm > eps)
{
ts->printf(cvtest::TS::LOG, "%s matrices are not equal\n"
//M*/
#include "test_precomp.hpp"
+#include "opencv2/objdetect/objdetect_c.h"
#include <string>
#ifdef HAVE_TBB
#include "opencv2/features2d.hpp"
#include "opencv2/objdetect.hpp"
#include "opencv2/softcascade.hpp"
-#include "opencv2/video/tracking.hpp"
-#include "opencv2/video/background_segm.hpp"
+#include "opencv2/video.hpp"
#include "opencv2/photo.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/highgui/highgui_c.h"
#include "opencv2/photo/photo_c.h"
#include "opencv2/video/tracking_c.h"
+#include "opencv2/objdetect/objdetect_c.h"
#include "opencv2/opencv_modules.hpp"
Ptr<SuperResolution> cv::superres::createSuperResolution_BTVL1_GPU()
{
- CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform");
+ CV_Error(Error::StsNotImplemented, "The called functionality is disabled for current build or platform");
return Ptr<SuperResolution>();
}
-#include "opencv2/objdetect/objdetect.hpp"
+#include "opencv2/objdetect/objdetect_c.h"
#include "opencv2/highgui/highgui_c.h"
#include <ctype.h>
t = (double)cvGetTickCount();
cascade.detectMultiScale( smallImg, faces,
1.1, 2, 0
- //|CV_HAAR_FIND_BIGGEST_OBJECT
- //|CV_HAAR_DO_ROUGH_SEARCH
- |CV_HAAR_SCALE_IMAGE
+ //|CASCADE_FIND_BIGGEST_OBJECT
+ //|CASCADE_DO_ROUGH_SEARCH
+ |CASCADE_SCALE_IMAGE
,
Size(30, 30) );
if( tryflip )
flip(smallImg, smallImg, 1);
cascade.detectMultiScale( smallImg, faces2,
1.1, 2, 0
- //|CV_HAAR_FIND_BIGGEST_OBJECT
- //|CV_HAAR_DO_ROUGH_SEARCH
- |CV_HAAR_SCALE_IMAGE
+ //|CASCADE_FIND_BIGGEST_OBJECT
+ //|CASCADE_DO_ROUGH_SEARCH
+ |CASCADE_SCALE_IMAGE
,
Size(30, 30) );
for( vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end(); r++ )
smallImgROI = smallImg(*r);
nestedCascade.detectMultiScale( smallImgROI, nestedObjects,
1.1, 2, 0
- //|CV_HAAR_FIND_BIGGEST_OBJECT
- //|CV_HAAR_DO_ROUGH_SEARCH
- //|CV_HAAR_DO_CANNY_PRUNING
- |CV_HAAR_SCALE_IMAGE
+ //|CASCADE_FIND_BIGGEST_OBJECT
+ //|CASCADE_DO_ROUGH_SEARCH
+ //|CASCADE_DO_CANNY_PRUNING
+ |CASCADE_SCALE_IMAGE
,
Size(30, 30) );
for( vector<Rect>::const_iterator nr = nestedObjects.begin(); nr != nestedObjects.end(); nr++ )
-#include "opencv2/objdetect.hpp"
+#include "opencv2/objdetect/objdetect_c.h"
#include "opencv2/highgui/highgui_c.h"
#include <stdio.h>
cascade.detectMultiScale( smallImg, faces,
1.1, 2, 0
- //|CV_HAAR_FIND_BIGGEST_OBJECT
- //|CV_HAAR_DO_ROUGH_SEARCH
- |CV_HAAR_SCALE_IMAGE
+ //|CASCADE_FIND_BIGGEST_OBJECT
+ //|CASCADE_DO_ROUGH_SEARCH
+ |CASCADE_SCALE_IMAGE
,
Size(30, 30) );
if( tryflip )
flip(smallImg, smallImg, 1);
cascade.detectMultiScale( smallImg, faces2,
1.1, 2, 0
- //|CV_HAAR_FIND_BIGGEST_OBJECT
- //|CV_HAAR_DO_ROUGH_SEARCH
- |CV_HAAR_SCALE_IMAGE
+ //|CASCADE_FIND_BIGGEST_OBJECT
+ //|CASCADE_DO_ROUGH_SEARCH
+ |CASCADE_SCALE_IMAGE
,
Size(30, 30) );
for( vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end(); r++ )
smallImgROI = smallImg(*r);
nestedCascade.detectMultiScale( smallImgROI, nestedObjects,
1.1, 0, 0
- //|CV_HAAR_FIND_BIGGEST_OBJECT
- //|CV_HAAR_DO_ROUGH_SEARCH
- //|CV_HAAR_DO_CANNY_PRUNING
- |CV_HAAR_SCALE_IMAGE
+ //|CASCADE_FIND_BIGGEST_OBJECT
+ //|CASCADE_DO_ROUGH_SEARCH
+ //|CASCADE_DO_CANNY_PRUNING
+ |CASCADE_SCALE_IMAGE
,
Size(30, 30) );
for (size_t i = 0; i < Faces.size(); i++)
{
- rectangle(ReferenceFrame, Faces[i], CV_RGB(0,255,0));
+ rectangle(ReferenceFrame, Faces[i], Scalar(0,255,0));
}
imshow(WindowName, ReferenceFrame);
conf << d.confidence;
cv::rectangle(frame, cv::Rect((int)d.x, (int)d.y, (int)d.w, (int)d.h), cv::Scalar(b, 0, 255 - b, 255), 2);
- cv::putText(frame, conf.str() , cv::Point((int)d.x + 10, (int)d.y - 5),1, 1.1, cv::Scalar(25, 133, 255, 0), 1, CV_AA);
+ cv::putText(frame, conf.str() , cv::Point((int)d.x + 10, (int)d.y - 5),1, 1.1, cv::Scalar(25, 133, 255, 0), 1, cv::LINE_AA);
if (wf)
myfile << d.x << "," << d.y << "," << d.w << "," << d.h << "," << d.confidence << "\n";
cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
equalizeHist( frame_gray, frame_gray );
//-- Detect faces
- face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+ face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CASCADE_SCALE_IMAGE, Size(30, 30) );
for( size_t i = 0; i < faces.size(); i++ )
{
std::vector<Rect> eyes;
//-- In each face, detect eyes
- eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+ eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CASCADE_SCALE_IMAGE, Size(30, 30) );
for( size_t j = 0; j < eyes.size(); j++ )
{
std::vector<Rect> eyes;
//-- In each face, detect eyes
- eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+ eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CASCADE_SCALE_IMAGE, Size(30, 30) );
if( eyes.size() == 2)
{
//-- Draw the face
Size minSize = cascade_gpu.getClassifierSize();
cascade_cpu.detectMultiScale(resized_cpu, facesBuf_cpu, 1.2,
(filterRects || findLargestObject) ? 4 : 0,
- (findLargestObject ? CV_HAAR_FIND_BIGGEST_OBJECT : 0)
- | CV_HAAR_SCALE_IMAGE,
+ (findLargestObject ? CASCADE_FIND_BIGGEST_OBJECT : 0)
+ | CASCADE_SCALE_IMAGE,
minSize);
detections_num = (int)facesBuf_cpu.size();
}
for (size_t i = 0; i < found.size(); i++)
{
Rect r = found[i];
- rectangle(img_to_show, r.tl(), r.br(), CV_RGB(0, 255, 0), 3);
+ rectangle(img_to_show, r.tl(), r.br(), Scalar(0, 255, 0), 3);
}
if (use_gpu)
for (size_t i = 0; i < lines_cpu.size(); ++i)
{
Vec4i l = lines_cpu[i];
- line(dst_cpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, CV_AA);
+ line(dst_cpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, LINE_AA);
}
GpuMat d_src(mask);
for (size_t i = 0; i < lines_gpu.size(); ++i)
{
Vec4i l = lines_gpu[i];
- line(dst_gpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, CV_AA);
+ line(dst_gpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, LINE_AA);
}
imshow("source", src);
}
-static int CV_CDECL cvErrorCallback(int /*status*/, const char* /*func_name*/,
+static int cvErrorCallback(int /*status*/, const char* /*func_name*/,
const char* err_msg, const char* /*file_name*/,
int /*line*/, void* /*userdata*/)
{
projects / platform / upstream / opencv.git / commitdiff