Integration object detection using Latent SVM. Sample was added.

modules/objdetect/include/opencv2/objdetect/objdetect.hpp

@@ -139,6 +139,129 @@ CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascad
 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
+{
+    unsigned int x;
+    unsigned int y;
+    unsigned int l;
+} position;
+
+// 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
+// xp              - auxillary parameter for internal use
+//                   size of row in feature vectors 
+//                   (yp = (int) (p / xp); p = xp * yp)
+typedef struct{
+    position V;
+    float fineFunction[4];
+    unsigned int sizeX;
+    unsigned int sizeY;
+    unsigned int p;
+    unsigned int xp;
+    float *H;
+} filterObject;
+
+// 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;
+	filterObject** 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);
+// 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));
+
 #ifdef __cplusplus
 }