latentsvm caskade

reworked PR 3

comment off #include "opencv2/core/private.hpp". It prevent the project from being referenced from outside the opencv library.

renaming + docs;

modules/latentsvm/CMakeLists.txt

+set(the_description "Object Detection")
+ocv_define_module(latentsvm opencv_core opencv_imgproc opencv_objdetect opencv_ts OPTIONAL opencv_highgui)

modules/latentsvm/doc/latent_svm_cascade.rst

+Latent SVM
+===============================================================
+
+Discriminatively Trained Part Based Models for Object Detection
+---------------------------------------------------------------
+
+The object detector described below has been initially proposed by
+P.F. Felzenszwalb in [Felzenszwalb2010a]_.  It is based on a
+Dalal-Triggs detector that uses a single filter on histogram of
+oriented gradients (HOG) features to represent an object category.
+This detector uses a sliding window approach, where a filter is
+applied at all positions and scales of an image. The first
+innovation is enriching the Dalal-Triggs model using a
+star-structured part-based model defined by a "root" filter
+(analogous to the Dalal-Triggs filter) plus a set of parts filters
+and associated deformation models. The score of one of star models
+at a particular position and scale within an image is the score of
+the root filter at the given location plus the sum over parts of the
+maximum, over placements of that part, of the part filter score on
+its location minus a deformation cost easuring the deviation of the
+part from its ideal location relative to the root. Both root and
+part filter scores are defined by the dot product between a filter
+(a set of weights) and a subwindow of a feature pyramid computed
+from the input image. Another improvement is a representation of the
+class of models by a mixture of star models. The score of a mixture
+model at a particular position and scale is the maximum over
+components, of the score of that component model at the given
+location. 
+
+The detector was dramatically speeded-up with cascade algorithm
+proposed by P.F. Felzenszwalb in [Felzenszwalb2010b]_. The algorithm
+prunes partial hypotheses using thresholds on their scores.The basic
+idea of the algorithm is to use a hierarchy of models defined by an
+ordering of the original model's parts. For a model with (n+1)
+parts, including the root, a sequence of (n+1) models is obtained.
+The i-th model in this sequence is defined by the first i parts from
+the original model. Using this hierarchy, low scoring hypotheses can be
+pruned after looking at the best configuration of a subset of the parts.
+Hypotheses that score high under a weak model are evaluated further using
+a richer model.
+
+In OpenCV there is an C++ implementation of Latent SVM.
+
+.. highlight:: cpp
+
+LSVMDetector
+-----------------
+.. ocv:class:: LSVMDetector
+
+This is a C++ abstract class, it provides external user API to work with Latent SVM.
+
+LSVMDetector::ObjectDetection
+----------------------------------
+.. ocv:struct:: LSVMDetector::ObjectDetection
+
+  Structure contains the detection information.
+
+  .. ocv:member:: Rect rect
+
+     bounding box for a detected object
+
+  .. ocv:member:: float score
+
+     confidence level
+
+  .. ocv:member:: int classID
+
+     class (model or detector) ID that detect an object
+
+LSVMDetector::~LSVMDetector
+-------------------------------------
+Destructor.
+
+.. ocv:function:: LSVMDetector::~LSVMDetector()
+
+LSVMDetector::create
+-----------------------
+Load the trained models from given ``.xml`` files and return ``cv::Ptr<LSVMDetector>``.
+
+.. ocv:function:: static cv::Ptr<LSVMDetector> LSVMDetector::create( const vector<string>& filenames, const vector<string>& classNames=vector<string>() )
+
+    :param filenames: A set of filenames storing the trained detectors (models). Each file contains one model. See examples of such files here /opencv_extra/testdata/cv/LSVMDetector/models_VOC2007/.
+
+    :param classNames: A set of trained models names. If it's empty then the name of each model will be constructed from the name of file containing the model. E.g. the model stored in "/home/user/cat.xml" will get the name "cat".
+
+LSVMDetector::detect
+-------------------------
+Find rectangular regions in the given image that are likely to contain objects of loaded classes (models)
+and corresponding confidence levels.
+
+.. ocv:function:: void LSVMDetector::detect( const Mat& image, vector<ObjectDetection>& objectDetections, float overlapThreshold=0.5f, int numThreads=-1 )
+
+    :param image: An image.
+    :param objectDetections: The detections: rectangulars, scores and class IDs.
+    :param overlapThreshold: Threshold for the non-maximum suppression algorithm.
+    :param numThreads: Number of threads used in parallel version of the algorithm.
+
+LSVMDetector::getClassNames
+--------------------------------
+Return the class (model) names that were passed in constructor or method ``load`` or extracted from models filenames in those methods.
+
+.. ocv:function:: const vector<string>& LSVMDetector::getClassNames() const
+
+LSVMDetector::getClassCount
+--------------------------------
+Return a count of loaded models (classes).
+
+.. ocv:function:: size_t LSVMDetector::getClassCount() const
+
+
+.. [Felzenszwalb2010a] Felzenszwalb, P. F. and Girshick, R. B. and McAllester, D. and Ramanan, D. *Object Detection with Discriminatively Trained Part Based Models*. PAMI, vol. 32, no. 9, pp. 1627-1645, September 2010
+.. [Felzenszwalb2010b] Felzenszwalb, P. F. and Girshick, R. B. and McAllester, D. *Cascade Object Detection with Deformable Part Models*. CVPR 2010, pp. 2241-2248
+

modules/latentsvm/include/opencv2/latentsvm.hpp

+/*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) 2010-2013, University of Nizhny Novgorod, 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.
+//
+// SVM implementation authors:
+// Evgeniy Kozinov - evgeniy.kozinov@gmail.com
+// Valentina Kustikova - valentina.kustikova@gmail.com
+// Nikolai Zolotykh - Nikolai.Zolotykh@gmail.com
+// Iosif Meyerov - meerov@vmk.unn.ru
+// Alexey Polovinkin - polovinkin.alexey@gmail.com
+//
+//M*/
+
+#ifndef __OPENCV_LATENTSVM_HPP__
+#define __OPENCV_LATENTSVM_HPP__
+
+#include "opencv2/core.hpp"
+
+#include <map>
+#include <vector>
+#include <string>
+
+namespace cv
+{
+
+namespace lsvm
+{
+
+class CV_EXPORTS_W LSVMDetector
+{
+public:
+
+    struct CV_EXPORTS_W ObjectDetection
+    {
+        ObjectDetection();
+        ObjectDetection( const Rect& rect, float score, int classID=-1 );
+        Rect rect;
+        float score;
+        int classID;
+    };
+
+    virtual bool isEmpty() const = 0;
+    virtual void detect(cv::Mat const &image, CV_OUT std::vector<ObjectDetection> &objects,
+                         float overlapThreshold=0.5f ) = 0;
+
+    virtual std::vector<std::string> const& getClassNames() const = 0;
+    virtual size_t getClassCount() const = 0;
+
+    static cv::Ptr<LSVMDetector> create(std::vector<std::string> const &filenames,
+                                        std::vector<std::string> const &classNames = std::vector<std::string>());
+
+    virtual ~LSVMDetector(){}
+};
+
+} // namespace lsvm
+} // namespace cv
+
+#endif

modules/latentsvm/perf/perf_cascadeclassifier.cpp

+#include "perf_precomp.hpp"
+#include <opencv2/imgproc.hpp>
+
+using namespace std;
+using namespace cv;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+typedef std::tr1::tuple<std::string, int> ImageName_MinSize_t;
+typedef perf::TestBaseWithParam<ImageName_MinSize_t> ImageName_MinSize;
+
+PERF_TEST_P(ImageName_MinSize, CascadeClassifierLBPFrontalFace,
+            testing::Combine(testing::Values( std::string("cv/shared/lena.png"),
+                                              std::string("cv/shared/1_itseez-0000289.png"),
+                                              std::string("cv/shared/1_itseez-0000492.png"),
+                                              std::string("cv/shared/1_itseez-0000573.png")),
+                             testing::Values(24, 30, 40, 50, 60, 70, 80, 90)
+                             )
+            )
+{
+    const string filename = get<0>(GetParam());
+    int min_size = get<1>(GetParam());
+    Size minSize(min_size, min_size);
+
+    CascadeClassifier cc(getDataPath("cv/cascadeandhog/cascades/lbpcascade_frontalface.xml"));
+    if (cc.empty())
+        FAIL() << "Can't load cascade file";
+
+    Mat img = imread(getDataPath(filename), 0);
+    if (img.empty())
+        FAIL() << "Can't load source image";
+
+    vector<Rect> faces;
+
+    equalizeHist(img, img);
+    declare.in(img);
+
+    while(next())
+    {
+        faces.clear();
+
+        startTimer();
+        cc.detectMultiScale(img, faces, 1.1, 3, 0, minSize);
+        stopTimer();
+    }
+
+    std::sort(faces.begin(), faces.end(), comparators::RectLess());
+    SANITY_CHECK(faces, 3.001 * faces.size());
+}
\ No newline at end of file

modules/latentsvm/perf/perf_main.cpp

+#include "perf_precomp.hpp"
+
+CV_PERF_TEST_MAIN(objdetect)

modules/latentsvm/perf/perf_precomp.cpp

+#include "perf_precomp.hpp"

modules/latentsvm/perf/perf_precomp.hpp

+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
+#endif
+
+#ifndef __OPENCV_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+
+#ifdef GTEST_CREATE_SHARED_LIBRARY
+#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
+#endif
+
+#endif

modules/latentsvm/src/_lsvmc_error.h

+/*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) 2010-2013, University of Nizhny Novgorod, 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 LSVM_ERROR
+#define LSVM_ERROR
+
+#define LATENT_SVM_OK 0
+#define LATENT_SVM_MEM_NULL 2
+#define DISTANCE_TRANSFORM_OK 1
+#define DISTANCE_TRANSFORM_GET_INTERSECTION_ERROR -1
+#define DISTANCE_TRANSFORM_ERROR -2
+#define DISTANCE_TRANSFORM_EQUAL_POINTS -3
+#define LATENT_SVM_GET_FEATURE_PYRAMID_FAILED -4
+#define LATENT_SVM_SEARCH_OBJECT_FAILED -5
+#define LATENT_SVM_FAILED_SUPERPOSITION -6
+#define FILTER_OUT_OF_BOUNDARIES -7
+#define LATENT_SVM_TBB_SCHEDULE_CREATION_FAILED -8
+#define LATENT_SVM_TBB_NUMTHREADS_NOT_CORRECT -9
+#define FFT_OK 2
+#define FFT_ERROR -10
+#define LSVM_PARSER_FILE_NOT_FOUND -11
+
+#endif

modules/latentsvm/src/_lsvmc_function.h

+/*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) 2010-2013, University of Nizhny Novgorod, 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 FUNCTION_SC
+#define FUNCTION_SC
+
+#include "_lsvmc_types.h"
+
+namespace cv
+{
+namespace lsvm
+{
+
+float calcM         (int k,int di,int dj, const CvLSVMFeaturePyramidCaskade * H, const CvLSVMFilterObjectCaskade *filter);
+float calcM_PCA     (int k,int di,int dj, const CvLSVMFeaturePyramidCaskade * H, const CvLSVMFilterObjectCaskade *filter);
+float calcM_PCA_cash(int k,int di,int dj, const CvLSVMFeaturePyramidCaskade * H, const CvLSVMFilterObjectCaskade *filter, float * cashM, int * maskM, int step);
+float calcFine (const CvLSVMFilterObjectCaskade *filter, int di, int dj);
+}
+}
+#endif
\ No newline at end of file

modules/latentsvm/src/_lsvmc_matching.h

+/*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) 2010-2013, University of Nizhny Novgorod, 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*/
+
+/*****************************************************************************/
+/*                      Matching procedure API                               */
+/*****************************************************************************/
+//
+#ifndef _LSVM_MATCHING_H_
+#define _LSVM_MATCHING_H_
+
+#include "_lsvmc_latentsvm.h"
+#include "_lsvmc_error.h"
+#include "_lsvmc_routine.h"
+
+namespace cv
+{
+namespace lsvm
+{
+
+
+/*
+// Computation border size for feature map
+//
+// API
+// int computeBorderSize(int maxXBorder, int maxYBorder, int *bx, int *by);
+// INPUT
+// maxXBorder        - the largest root filter size (X-direction)
+// maxYBorder        - the largest root filter size (Y-direction)
+// OUTPUT
+// bx                - border size (X-direction)
+// by                - border size (Y-direction)
+// RESULT
+// Error status
+*/
+int computeBorderSize(int maxXBorder, int maxYBorder, int *bx, int *by);
+
+/*
+// Addition nullable border to the feature map
+//
+// API
+// int addNullableBorder(featureMap *map, int bx, int by);
+// INPUT
+// map               - feature map
+// bx                - border size (X-direction)
+// by                - border size (Y-direction)
+// OUTPUT
+// RESULT
+// Error status
+*/
+int addNullableBorder(CvLSVMFeatureMapCaskade *map, int bx, int by);
+
+/*
+// Perform non-maximum suppression algorithm (described in original paper)
+// to remove "similar" bounding boxes
+//
+// API
+// int nonMaximumSuppression(int numBoxes, const CvPoint *points, 
+                             const CvPoint *oppositePoints, const float *score,
+                             float overlapThreshold, 
+                             int *numBoxesout, CvPoint **pointsOut, 
+                             CvPoint **oppositePointsOut, float **scoreOut);
+// INPUT
+// numBoxes          - number of bounding boxes
+// points            - array of left top corner coordinates
+// oppositePoints    - array of right bottom corner coordinates
+// score             - array of detection scores
+// overlapThreshold  - threshold: bounding box is removed if overlap part 
+					   is greater than passed value
+// OUTPUT
+// numBoxesOut       - the number of bounding boxes algorithm returns
+// pointsOut         - array of left top corner coordinates
+// oppositePointsOut - array of right bottom corner coordinates
+// scoreOut          - array of detection scores
+// RESULT
+// Error status
+*/
+int nonMaximumSuppression(int numBoxes, const CvPoint *points, 
+                          const CvPoint *oppositePoints, const float *score,
+                          float overlapThreshold, 
+                          int *numBoxesOut, CvPoint **pointsOut, 
+                          CvPoint **oppositePointsOut, float **scoreOut);
+int getMaxFilterDims(const CvLSVMFilterObjectCaskade **filters, int kComponents,
+                     const int *kPartFilters, 
+                     unsigned int *maxXBorder, unsigned int *maxYBorder);
+//}
+
+int getMaxFilterDims(const CvLSVMFilterObjectCaskade **filters, int kComponents,
+                     const int *kPartFilters, 
+                     unsigned int *maxXBorder, unsigned int *maxYBorder);
+}
+}
+#endif

modules/latentsvm/src/_lsvmc_parser.h

+/*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) 2010-2013, University of Nizhny Novgorod, 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 LSVM_PARSER
+#define LSVM_PARSER
+
+#include "_lsvmc_types.h"
+
+#define MODEL    1
+#define P        2
+#define COMP     3
+#define SCORE    4
+#define RFILTER  100
+#define PFILTERs 101
+#define PFILTER  200
+#define SIZEX    150
+#define SIZEY    151
+#define WEIGHTS  152
+#define TAGV     300
+#define Vx       350
+#define Vy       351
+#define TAGD     400
+#define Dx       451
+#define Dy       452
+#define Dxx      453
+#define Dyy      454
+#define BTAG     500
+
+#define PCA          5
+#define WEIGHTSPCA   162
+#define CASCADE_Th   163
+#define HYPOTHES_PCA 164
+#define DEFORM_PCA   165
+#define HYPOTHES     166
+#define DEFORM       167
+
+#define PCACOEFF     6
+
+#define STEP_END 1000
+
+#define EMODEL    (STEP_END + MODEL)
+#define EP        (STEP_END + P)
+#define ECOMP     (STEP_END + COMP)
+#define ESCORE    (STEP_END + SCORE)
+#define ERFILTER  (STEP_END + RFILTER)
+#define EPFILTERs (STEP_END + PFILTERs)
+#define EPFILTER  (STEP_END + PFILTER)
+#define ESIZEX    (STEP_END + SIZEX)
+#define ESIZEY    (STEP_END + SIZEY)
+#define EWEIGHTS  (STEP_END + WEIGHTS)
+#define ETAGV     (STEP_END + TAGV)
+#define EVx       (STEP_END + Vx)
+#define EVy       (STEP_END + Vy)
+#define ETAGD     (STEP_END + TAGD)
+#define EDx       (STEP_END + Dx)
+#define EDy       (STEP_END + Dy)
+#define EDxx      (STEP_END + Dxx)
+#define EDyy      (STEP_END + Dyy)
+#define EBTAG     (STEP_END + BTAG)
+
+#define EPCA          (STEP_END + PCA)
+#define EWEIGHTSPCA   (STEP_END + WEIGHTSPCA)
+#define ECASCADE_Th   (STEP_END + CASCADE_Th)
+#define EHYPOTHES_PCA (STEP_END + HYPOTHES_PCA)
+#define EDEFORM_PCA   (STEP_END + DEFORM_PCA)
+#define EHYPOTHES     (STEP_END + HYPOTHES)
+#define EDEFORM       (STEP_END + DEFORM)
+
+#define EPCACOEFF     (STEP_END + PCACOEFF)
+
+namespace cv
+{
+namespace lsvm
+{
+
+    int loadModel(
+             // input parametr
+              const char *modelPath,// model path
+             
+              // output parametrs
+              CvLSVMFilterObjectCaskade ***filters,
+              int *kFilters, 
+              int *kComponents, 
+              int **kPartFilters, 
+              float **b,
+              float *scoreThreshold,
+              float ** PCAcoeff);
+}
+}
+#endif

modules/latentsvm/src/_lsvmc_resizeimg.h

+/*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) 2010-2013, University of Nizhny Novgorod, 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 _LSVM_RESIZEIMG_H_
+#define _LSVM_RESIZEIMG_H_
+
+#include "_lsvmc_types.h"
+
+namespace cv
+{
+namespace lsvm
+{
+
+IplImage * resize_opencv (IplImage * img, float scale);
+}
+}
+
+#endif

modules/latentsvm/src/_lsvmc_routine.h

+/*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) 2010-2013, University of Nizhny Novgorod, 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 _LSVM_ROUTINE_H_
+#define _LSVM_ROUTINE_H_
+
+#include "_lsvmc_types.h"
+#include "_lsvmc_error.h"
+
+namespace cv
+{
+namespace lsvm
+{
+
+
+//////////////////////////////////////////////////////////////
+// Memory management routines
+// All paramaters names correspond to previous data structures description
+// All "alloc" functions return allocated memory for 1 object
+// with all fields including arrays
+// Error status is return value
+//////////////////////////////////////////////////////////////
+int allocFilterObject(CvLSVMFilterObjectCaskade **obj, const int sizeX, const int sizeY, 
+                      const int p);
+int freeFilterObject (CvLSVMFilterObjectCaskade **obj);
+
+int allocFeatureMapObject(CvLSVMFeatureMapCaskade **obj, const int sizeX, const int sizeY,
+                          const int p);
+int freeFeatureMapObject (CvLSVMFeatureMapCaskade **obj);
+
+int allocFeaturePyramidObject(CvLSVMFeaturePyramidCaskade **obj, 
+                              const int countLevel);
+
+int freeFeaturePyramidObject (CvLSVMFeaturePyramidCaskade **obj);
+
+}
+}
+#endif

modules/latentsvm/src/_lsvmc_types.h

+/*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) 2010-2013, University of Nizhny Novgorod, 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 SVM_TYPE
+#define SVM_TYPE
+
+#include "float.h"
+
+#define PI    CV_PI
+
+#define EPS 0.000001
+
+#define F_MAX FLT_MAX
+#define F_MIN -FLT_MAX
+
+// The number of elements in bin
+// The number of sectors in gradient histogram building
+#define NUM_SECTOR 9
+
+// The number of levels in image resize procedure
+// We need Lambda levels to resize image twice
+#define LAMBDA 10
+
+// Block size. Used in feature pyramid building procedure
+#define SIDE_LENGTH 8
+
+#define VAL_OF_TRUNCATE 0.2f 
+namespace cv
+{
+namespace lsvm
+{
+//////////////////////////////////////////////////////////////
+// main data structures                                     //
+//////////////////////////////////////////////////////////////
+
+// 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
+{
+    cv::Rect rect;
+    float score;
+} CvObjectDetection;
+
+
+// DataType: STRUCT featureMap
+// FEATURE MAP DESCRIPTION
+//   Rectangular map (sizeX x sizeY), 
+//   every cell stores feature vector (dimension = numFeatures)
+// map             - matrix of feature vectors
+//                   to set and get feature vectors (i,j) 
+//                   used formula map[(j * sizeX + i) * p + k], where
+//                   k - component of feature vector in cell (i, j)
+typedef struct{
+    int sizeX;
+    int sizeY;
+    int numFeatures;
+    float *map;
+} CvLSVMFeatureMapCaskade;
+
+// DataType: STRUCT featurePyramid
+//
+// numLevels    - number of levels in the feature pyramid
+// pyramid      - array of pointers to feature map at different levels
+typedef struct{
+    int numLevels;
+    CvLSVMFeatureMapCaskade **pyramid;
+} CvLSVMFeaturePyramidCaskade;
+
+// DataType: STRUCT filterDisposition
+// The structure stores preliminary results in optimization process
+// with objective function D 
+//
+// x            - array with X coordinates of optimization problems solutions
+// y            - array with Y coordinates of optimization problems solutions
+// score        - array with optimal objective values
+typedef struct{
+    float *score;
+    int *x;
+    int *y;
+} CvLSVMFilterDisposition;
+
+// 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 CvLSVMFilterObjectCaskade{
+    CvLSVMFilterPosition V;
+    float fineFunction[4];
+    int sizeX;
+    int sizeY;
+    int numFeatures;
+    float *H;
+    float *H_PCA;
+    float Hypothesis, Deformation;
+    float Hypothesis_PCA, Deformation_PCA;
+    int deltaX;
+    int deltaY;
+} CvLSVMFilterObjectCaskade;
+
+// 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 CvLatentSvmDetectorCaskade
+{
+    int num_filters;
+    int num_components;
+    int* num_part_filters;
+    CvLSVMFilterObjectCaskade** filters;
+    float* b;
+    float score_threshold;
+    float *pca;
+    int pca_size;
+} CvLatentSvmDetectorCaskade;
+}
+}
+#endif

modules/latentsvm/src/lsvmc_function.cpp

+/*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) 2010-2013, University of Nizhny Novgorod, 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*/
+
+#include "precomp.hpp"
+#include "_lsvmc_function.h"
+namespace cv
+{
+namespace lsvm
+{
+
+float calcM    (int k,int di,int dj, const CvLSVMFeaturePyramidCaskade * H, const CvLSVMFilterObjectCaskade *filter){
+    int i, j;
+    float m = 0.0f;
+    for(j = dj; j < dj + filter->sizeY; j++){
+        for(i = di * H->pyramid[k]->numFeatures; i < (di + filter->sizeX) * H->pyramid[k]->numFeatures; i++){
+             m += H->pyramid[k]->map[(j * H->pyramid[k]->sizeX     ) * H->pyramid[k]->numFeatures + i] * 
+                  filter ->H        [((j - dj) * filter->sizeX - di) * H->pyramid[k]->numFeatures + i];            
+        }
+    }
+    return m;
+}
+float calcM_PCA(int k,int di,int dj, const CvLSVMFeaturePyramidCaskade * H, const CvLSVMFilterObjectCaskade *filter){
+    int i, j;
+    float m = 0.0f;
+    for(j = dj; j < dj + filter->sizeY; j++){
+        for(i = di * H->pyramid[k]->numFeatures; i < (di + filter->sizeX) * H->pyramid[k]->numFeatures; i++){
+            m += H->pyramid[k]->map[(j * H->pyramid[k]->sizeX     ) * H->pyramid[k]->numFeatures + i] * 
+                 filter ->H_PCA    [((j - dj) * filter->sizeX - di) * H->pyramid[k]->numFeatures + i];
+        }
+    }
+
+    return m;
+}
+float calcM_PCA_cash(int k,int di,int dj, const CvLSVMFeaturePyramidCaskade * H, const CvLSVMFilterObjectCaskade *filter, float * cashM, int * maskM, int step){
+    int i, j, n;
+    float m = 0.0f;
+    float tmp1, tmp2, tmp3, tmp4;
+    float res;
+    int pos;
+    float *a, *b;
+
+    pos = dj * step + di;
+
+    if(!((maskM[pos / (sizeof(int) * 8)]) & (1 << pos % (sizeof(int) * 8))))
+    {
+        for(j = dj; j < dj + filter->sizeY; j++)
+        {
+            a = H->pyramid[k]->map + (j * H->pyramid[k]->sizeX) * H->pyramid[k]->numFeatures
+              + di * H->pyramid[k]->numFeatures;
+            b = filter ->H_PCA + (j - dj) * filter->sizeX * H->pyramid[k]->numFeatures;
+            n = ((di + filter->sizeX) * H->pyramid[k]->numFeatures) - 
+              (di * H->pyramid[k]->numFeatures);
+            
+            res = 0.0f;
+            tmp1 = 0.0f; tmp2 = 0.0f; tmp3 = 0.0f; tmp4 = 0.0f;
+
+            for (i = 0; i < (n >> 2); ++i)
+            {
+                tmp1 += a[4 * i + 0] * b[4 * i + 0];
+                tmp2 += a[4 * i + 1] * b[4 * i + 1];
+                tmp3 += a[4 * i + 2] * b[4 * i + 2];
+                tmp4 += a[4 * i + 3] * b[4 * i + 3];
+            }
+            
+            for (i = (n >> 2) << 2; i < n; ++i) //?
+            {
+                res += a[i] * b[i];
+            }
+
+            res += tmp1 + tmp2 + tmp3 + tmp4;
+
+            m += res;
+        }
+
+        cashM[pos                    ]  = m;
+        maskM[pos / (sizeof(int) * 8)] |= 1 << pos % (sizeof(int) * 8);
+    }
+    else
+    {
+        m = cashM[pos];
+    }
+    return m;
+}
+float calcFine (const CvLSVMFilterObjectCaskade *filter, int di, int dj){
+    return filter->fineFunction[0] * di      + filter->fineFunction[1] * dj + 
+           filter->fineFunction[2] * di * di + filter->fineFunction[3] * dj * dj;
+}
+}
+}

modules/latentsvm/src/lsvmc_matching.cpp

+/*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) 2010-2013, University of Nizhny Novgorod, 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*/
+
+#include "precomp.hpp"
+#include "_lsvmc_matching.h"
+#include <stdio.h>
+
+#ifndef max
+#define max(a,b)            (((a) > (b)) ? (a) : (b))
+#endif
+
+#ifndef min
+#define min(a,b)            (((a) < (b)) ? (a) : (b))
+#endif
+namespace cv
+{
+namespace lsvm
+{
+
+void sort(int n, const float* x, int* indices);
+
+/*
+// Computation border size for feature map
+//
+// API
+// int computeBorderSize(int maxXBorder, int maxYBorder, int *bx, int *by);
+// INPUT
+// maxXBorder        - the largest root filter size (X-direction)
+// maxYBorder        - the largest root filter size (Y-direction)
+// OUTPUT
+// bx                - border size (X-direction)
+// by                - border size (Y-direction)
+// RESULT
+// Error status
+*/
+int computeBorderSize(int maxXBorder, int maxYBorder, int *bx, int *by)
+{
+    *bx = (int)ceilf(((float) maxXBorder) / 2.0f + 1.0f);
+    *by = (int)ceilf(((float) maxYBorder) / 2.0f + 1.0f);
+    return LATENT_SVM_OK;
+}
+
+/*
+// Addition nullable border to the feature map
+//
+// API
+// int addNullableBorder(featureMap *map, int bx, int by);
+// INPUT
+// map               - feature map
+// bx                - border size (X-direction)
+// by                - border size (Y-direction)
+// OUTPUT
+// RESULT
+// Error status
+*/
+int addNullableBorder(CvLSVMFeatureMapCaskade *map, int bx, int by)
+{
+    int sizeX, sizeY, i, j, k;
+    float *new_map;
+    sizeX = map->sizeX + 2 * bx;
+    sizeY = map->sizeY + 2 * by;
+    new_map = (float *)malloc(sizeof(float) * sizeX * sizeY * map->numFeatures);
+    for (i = 0; i < sizeX * sizeY * map->numFeatures; i++)
+    {
+        new_map[i] = 0.0;
+    }
+    for (i = by; i < map->sizeY + by; i++)
+    {
+        for (j = bx; j < map->sizeX + bx; j++)
+        {
+            for (k = 0; k < map->numFeatures; k++)
+            {
+                new_map[(i * sizeX + j) * map->numFeatures + k] =
+                    map->map[((i - by) * map->sizeX + j - bx) * map->numFeatures + k];
+            }
+        }
+    }
+    map->sizeX = sizeX;
+    map->sizeY = sizeY;
+    free(map->map);
+    map->map = new_map;
+    return LATENT_SVM_OK;
+}
+
+/*
+// Computation maximum filter size for each dimension
+//
+// API
+// int getMaxFilterDims(const CvLSVMFilterObjectCaskade **filters, int kComponents,
+                        const int *kPartFilters, 
+                        unsigned int *maxXBorder, unsigned int *maxYBorder);
+// INPUT
+// filters           - a set of filters (at first root filter, then part filters 
+                       and etc. for all components)
+// kComponents       - number of components
+// kPartFilters      - number of part filters for each component
+// OUTPUT
+// maxXBorder        - maximum of filter size at the horizontal dimension
+// maxYBorder        - maximum of filter size at the vertical dimension
+// RESULT
+// Error status
+*/
+int getMaxFilterDims(const CvLSVMFilterObjectCaskade **filters, int kComponents,
+                     const int *kPartFilters, 
+                     unsigned int *maxXBorder, unsigned int *maxYBorder)
+{
+    int i, componentIndex;    
+    *maxXBorder = filters[0]->sizeX;
+    *maxYBorder = filters[0]->sizeY;
+    componentIndex = kPartFilters[0] + 1;
+    for (i = 1; i < kComponents; i++)
+    {
+        if (unsigned(filters[componentIndex]->sizeX) > *maxXBorder)
+        {
+            *maxXBorder = filters[componentIndex]->sizeX;
+        }
+        if (unsigned(filters[componentIndex]->sizeY) > *maxYBorder)
+        {
+            *maxYBorder = filters[componentIndex]->sizeY;
+        }
+        componentIndex += (kPartFilters[i] + 1);
+    }
+    return LATENT_SVM_OK;
+}
+
+void sort(int n, const float* x, int* indices)
+{
+	int i, j;
+	for (i = 0; i < n; i++)
+		for (j = i + 1; j < n; j++)
+		{
+			if (x[indices[j]] > x[indices[i]])
+			{
+				//float x_tmp = x[i];
+				int index_tmp = indices[i];
+				//x[i] = x[j];
+				indices[i] = indices[j];
+				//x[j] = x_tmp;
+				indices[j] = index_tmp;
+			}
+		}
+}
+
+/*
+// Perform non-maximum suppression algorithm (described in original paper)
+// to remove "similar" bounding boxes
+//
+// API
+// int nonMaximumSuppression(int numBoxes, const CvPoint *points,
+                             const CvPoint *oppositePoints, const float *score,
+                             float overlapThreshold,
+                             int *numBoxesOut, CvPoint **pointsOut,
+                             CvPoint **oppositePointsOut, float **scoreOut);
+// INPUT
+// numBoxes          - number of bounding boxes
+// points            - array of left top corner coordinates
+// oppositePoints    - array of right bottom corner coordinates
+// score             - array of detection scores
+// overlapThreshold  - threshold: bounding box is removed if overlap part
+                       is greater than passed value
+// OUTPUT
+// numBoxesOut       - the number of bounding boxes algorithm returns
+// pointsOut         - array of left top corner coordinates
+// oppositePointsOut - array of right bottom corner coordinates
+// scoreOut          - array of detection scores
+// RESULT
+// Error status
+*/
+int nonMaximumSuppression(int numBoxes, const CvPoint *points,
+                          const CvPoint *oppositePoints, const float *score,
+                          float overlapThreshold,
+                          int *numBoxesOut, CvPoint **pointsOut,
+                          CvPoint **oppositePointsOut, float **scoreOut)
+{
+    int i, j, index;
+    float* box_area = (float*)malloc(numBoxes * sizeof(float));
+    int* indices = (int*)malloc(numBoxes * sizeof(int));
+    int* is_suppressed = (int*)malloc(numBoxes * sizeof(int));
+
+    for (i = 0; i < numBoxes; i++)
+    {
+        indices[i] = i;
+        is_suppressed[i] = 0;
+        box_area[i] = (float)( (oppositePoints[i].x - points[i].x + 1) *
+                                (oppositePoints[i].y - points[i].y + 1));
+    }
+
+    sort(numBoxes, score, indices);
+    for (i = 0; i < numBoxes; i++)
+    {
+        if (!is_suppressed[indices[i]])
+        {
+            for (j = i + 1; j < numBoxes; j++)
+            {
+                if (!is_suppressed[indices[j]])
+                {
+                    int x1max = max(points[indices[i]].x, points[indices[j]].x);
+                    int x2min = min(oppositePoints[indices[i]].x, oppositePoints[indices[j]].x);
+                    int y1max = max(points[indices[i]].y, points[indices[j]].y);
+                    int y2min = min(oppositePoints[indices[i]].y, oppositePoints[indices[j]].y);
+                    int overlapWidth = x2min - x1max + 1;
+                    int overlapHeight = y2min - y1max + 1;
+                    if (overlapWidth > 0 && overlapHeight > 0)
+                    {
+                        float overlapPart = (overlapWidth * overlapHeight) / box_area[indices[j]];
+                        if (overlapPart > overlapThreshold)
+                        {
+                            is_suppressed[indices[j]] = 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    *numBoxesOut = 0;
+    for (i = 0; i < numBoxes; i++)
+    {
+        if (!is_suppressed[i]) (*numBoxesOut)++;
+    }
+
+    *pointsOut = (CvPoint *)malloc((*numBoxesOut) * sizeof(CvPoint));
+    *oppositePointsOut = (CvPoint *)malloc((*numBoxesOut) * sizeof(CvPoint));
+    *scoreOut = (float *)malloc((*numBoxesOut) * sizeof(float));
+    index = 0;
+    for (i = 0; i < numBoxes; i++)
+    {
+        if (!is_suppressed[indices[i]])
+        {
+            (*pointsOut)[index].x = points[indices[i]].x;
+            (*pointsOut)[index].y = points[indices[i]].y;
+            (*oppositePointsOut)[index].x = oppositePoints[indices[i]].x;
+            (*oppositePointsOut)[index].y = oppositePoints[indices[i]].y;
+            (*scoreOut)[index] = score[indices[i]];
+            index++;
+        }
+
+    }
+
+    free(indices);
+    free(box_area);
+    free(is_suppressed);
+
+    return LATENT_SVM_OK;
+}
+}
+}

modules/latentsvm/src/lsvmc_resizeimg.cpp

+/*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) 2010-2013, University of Nizhny Novgorod, 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*/
+
+#include "precomp.hpp"
+#include "_lsvmc_resizeimg.h"
+#include <stdio.h>
+#include <assert.h>
+#include <math.h>
+
+namespace cv
+{
+namespace lsvm
+{
+
+IplImage* resize_opencv(IplImage* img, float scale)
+{
+    IplImage* imgTmp;
+
+    int W, H, tW, tH;
+
+    W = img->width;
+    H = img->height;
+
+    tW = (int)(((float)W) * scale + 0.5);
+    tH = (int)(((float)H) * scale + 0.5);
+
+    imgTmp = cvCreateImage(cvSize(tW , tH), img->depth, img->nChannels);
+    cvResize(img, imgTmp, CV_INTER_AREA);
+
+    return imgTmp;
+}
+}
+}

modules/latentsvm/src/precomp.cpp

+/*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) 2010-2013, University of Nizhny Novgorod, 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*/
+
+#include "precomp.hpp"
+
+/* End of file. */

modules/latentsvm/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("latentsvm")

modules/latentsvm/test/test_precomp.cpp

+#include "test_precomp.hpp"

modules/latentsvm/test/test_precomp.hpp

+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
+#endif
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/latentsvm.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+#endif