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_latentsvm.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*/
+
+/*****************************************************************************/
+/*                      Latent SVM prediction API                            */
+/*****************************************************************************/
+
+#ifndef _LATENTSVM_H_
+#define _LATENTSVM_H_
+
+#include <stdio.h>
+#include "_lsvmc_types.h"
+#include "_lsvmc_error.h"
+#include "_lsvmc_routine.h"
+
+namespace cv
+{
+namespace lsvm
+{
+
+//////////////////////////////////////////////////////////////
+// Building feature pyramid
+// (pyramid constructed both contrast and non-contrast image)
+//////////////////////////////////////////////////////////////
+
+void FeaturePyramid32(CvLSVMFeaturePyramidCaskade* H, int maxX, int maxY);
+
+/*
+// Creation PSA feature pyramid
+//
+// API
+// featurePyramid* createPSA_FeaturePyramid(featurePyramid* H);
+
+// INPUT
+// H                 - feature pyramid     
+// OUTPUT
+// RESULT
+// PSA feature pyramid
+*/
+CvLSVMFeaturePyramidCaskade* createPCA_FeaturePyramid(CvLSVMFeaturePyramidCaskade* H, 
+                                               CvLatentSvmDetectorCaskade* detector, 
+                                               int maxX, int maxY);
+
+/*
+// Getting feature pyramid  
+//
+// API
+// int getFeaturePyramid(IplImage * image, const CvLSVMFilterObjectCaskade **all_F, 
+                      const int n_f,
+                      const int lambda, const int k, 
+                      const int startX, const int startY, 
+                      const int W, const int H, featurePyramid **maps);
+// INPUT
+// image             - image
+// lambda            - resize scale
+// k                 - size of cells
+// startX            - X coordinate of the image rectangle to search
+// startY            - Y coordinate of the image rectangle to search
+// W                 - width of the image rectangle to search
+// H                 - height of the image rectangle to search
+// OUTPUT
+// maps              - feature maps for all levels
+// RESULT
+// Error status
+*/
+int getFeaturePyramid(IplImage * image, CvLSVMFeaturePyramidCaskade **maps);
+
+/*
+// Getting feature map for the selected subimage  
+//
+// API
+// int getFeatureMaps(const IplImage * image, const int k, featureMap **map);
+// INPUT
+// image             - selected subimage
+// k                 - size of cells
+// OUTPUT
+// map               - feature map
+// RESULT
+// Error status
+*/
+int getFeatureMaps(const IplImage * image, const int k, CvLSVMFeatureMapCaskade **map);
+
+
+/*
+// Feature map Normalization and Truncation 
+//
+// API
+// int normalizationAndTruncationFeatureMaps(featureMap *map, const float alfa);
+// INPUT
+// map               - feature map
+// alfa              - truncation threshold
+// OUTPUT
+// map               - truncated and normalized feature map
+// RESULT
+// Error status
+*/
+int normalizeAndTruncate(CvLSVMFeatureMapCaskade *map, const float alfa);
+
+/*
+// Feature map reduction
+// In each cell we reduce dimension of the feature vector
+// according to original paper special procedure
+//
+// API
+// int PCAFeatureMaps(featureMap *map)
+// INPUT
+// map               - feature map
+// OUTPUT
+// map               - feature map
+// RESULT
+// Error status
+*/
+int PCAFeatureMaps(CvLSVMFeatureMapCaskade *map);
+
+//////////////////////////////////////////////////////////////
+// search object
+//////////////////////////////////////////////////////////////
+
+/*
+// Transformation filter displacement from the block space 
+// to the space of pixels at the initial image
+//
+// API
+// int convertPoints(int countLevel, int lambda, 
+                     int initialImageLevel,
+                     CvPoint *points, int *levels, 
+                     CvPoint **partsDisplacement, int kPoints, int n, 
+                     int maxXBorder,
+                     int maxYBorder);
+// INPUT
+// countLevel        - the number of levels in the feature pyramid
+// lambda            - method parameter
+// initialImageLevel - level of feature pyramid that contains feature map
+                       for initial image
+// points            - the set of root filter positions (in the block space)
+// levels            - the set of levels
+// partsDisplacement - displacement of part filters (in the block space)
+// kPoints           - number of root filter positions
+// n                 - number of part filters
+// maxXBorder        - the largest root filter size (X-direction)
+// maxYBorder        - the largest root filter size (Y-direction)
+// OUTPUT
+// points            - the set of root filter positions (in the space of pixels)
+// partsDisplacement - displacement of part filters (in the space of pixels)
+// RESULT
+// Error status
+*/
+int convertPoints(int countLevel, int lambda, 
+                  int initialImageLevel,
+                  CvPoint *points, int *levels, 
+                  CvPoint **partsDisplacement, int kPoints, int n, 
+                  int maxXBorder,
+                  int maxYBorder);
+
+/*
+// Elimination boxes that are outside the image boudaries
+//
+// API
+// int clippingBoxes(int width, int height, 
+                     CvPoint *points, int kPoints);
+// INPUT
+// width             - image wediht
+// height            - image heigth
+// points            - a set of points (coordinates of top left or
+                       bottom right corners)
+// kPoints           - points number
+// OUTPUT
+// points            - updated points (if coordinates less than zero then
+                       set zero coordinate, if coordinates more than image 
+                       size then set coordinates equal image size)
+// RESULT
+// Error status
+*/
+int clippingBoxes(int width, int height, 
+                  CvPoint *points, int kPoints);
+
+/*
+// Creation feature pyramid with nullable border
+//
+// API
+// featurePyramid* createFeaturePyramidWithBorder(const IplImage *image,
+                                                  int maxXBorder, int maxYBorder);
+
+// INPUT
+// image             - initial image     
+// maxXBorder        - the largest root filter size (X-direction)
+// maxYBorder        - the largest root filter size (Y-direction)
+// OUTPUT
+// RESULT
+// Feature pyramid with nullable border
+*/
+CvLSVMFeaturePyramidCaskade* createFeaturePyramidWithBorder(IplImage *image,
+                                               int maxXBorder, int maxYBorder);
+
+/*
+// Computation root filters displacement and values of score function
+//
+// API
+// int searchObjectThresholdSomeComponents(const featurePyramid *H,
+                                           const CvLSVMFilterObjectCaskade **filters, 
+                                           int kComponents, const int *kPartFilters,
+                                           const float *b, float scoreThreshold,
+                                           CvPoint **points, CvPoint **oppPoints,
+                                           float **score, int *kPoints);
+// INPUT
+// H                 - feature pyramid
+// filters           - filters (root filter then it's part filters, etc.)
+// kComponents       - root filters number
+// kPartFilters      - array of part filters number for each component
+// b                 - array of linear terms
+// scoreThreshold    - score threshold
+// OUTPUT
+// points            - root filters displacement (top left corners)
+// oppPoints         - root filters displacement (bottom right corners)
+// score             - array of score values
+// kPoints           - number of boxes
+// RESULT
+// Error status
+*/
+int searchObjectThresholdSomeComponents(const CvLSVMFeaturePyramidCaskade *H,
+										const CvLSVMFeaturePyramidCaskade *H_PCA,
+                                        const CvLSVMFilterObjectCaskade **filters, 
+                                        int kComponents, const int *kPartFilters,
+                                        const float *b, float scoreThreshold,
+                                        CvPoint **points, CvPoint **oppPoints,
+                                        float **score, int *kPoints);
+
+/*
+// Compute opposite point for filter box
+//
+// API
+// int getOppositePoint(CvPoint point,
+                        int sizeX, int sizeY,
+                        float step, int degree,
+                        CvPoint *oppositePoint);
+
+// INPUT
+// point             - coordinates of filter top left corner
+                       (in the space of pixels)
+// (sizeX, sizeY)    - filter dimension in the block space
+// step              - scaling factor
+// degree            - degree of the scaling factor
+// OUTPUT
+// oppositePoint     - coordinates of filter bottom corner
+                       (in the space of pixels)
+// RESULT
+// Error status
+*/
+int getOppositePoint(CvPoint point,
+                     int sizeX, int sizeY,
+                     float step, int degree,
+                     CvPoint *oppositePoint);
+
+/*
+// Drawing root filter boxes
+//
+// API
+// int showRootFilterBoxes(const IplImage *image,
+                           const CvLSVMFilterObjectCaskade *filter, 
+                           CvPoint *points, int *levels, int kPoints,
+                           CvScalar color, int thickness, 
+                           int line_type, int shift);
+// INPUT
+// image             - initial image
+// filter            - root filter object
+// points            - a set of points
+// levels            - levels of feature pyramid
+// kPoints           - number of points
+// color             - line color for each box
+// thickness         - line thickness
+// line_type         - line type
+// shift             - shift
+// OUTPUT
+// window contained initial image and filter boxes
+// RESULT
+// Error status
+*/
+int showRootFilterBoxes(IplImage *image,
+                        const CvLSVMFilterObjectCaskade *filter, 
+                        CvPoint *points, int *levels, int kPoints,
+                        CvScalar color, int thickness, 
+                        int line_type, int shift);
+
+/*
+// Drawing part filter boxes
+//
+// API
+// int showPartFilterBoxes(const IplImage *image,
+                           const CvLSVMFilterObjectCaskade *filter, 
+                           CvPoint *points, int *levels, int kPoints,
+                           CvScalar color, int thickness, 
+                           int line_type, int shift);
+// INPUT
+// image             - initial image
+// filters           - a set of part filters
+// n                 - number of part filters
+// partsDisplacement - a set of points
+// levels            - levels of feature pyramid
+// kPoints           - number of foot filter positions
+// color             - line color for each box
+// thickness         - line thickness
+// line_type         - line type
+// shift             - shift
+// OUTPUT
+// window contained initial image and filter boxes
+// RESULT
+// Error status
+*/
+int showPartFilterBoxes(IplImage *image,
+                        const CvLSVMFilterObjectCaskade **filters,
+                        int n, CvPoint **partsDisplacement, 
+                        int *levels, int kPoints,
+                        CvScalar color, int thickness, 
+                        int line_type, int shift);
+
+/*
+// Drawing boxes
+//
+// API
+// int showBoxes(const IplImage *img, 
+                 const CvPoint *points, const CvPoint *oppositePoints, int kPoints, 
+                 CvScalar color, int thickness, int line_type, int shift);
+// INPUT
+// img               - initial image
+// points            - top left corner coordinates
+// oppositePoints    - right bottom corner coordinates
+// kPoints           - points number
+// color             - line color for each box
+// thickness         - line thickness
+// line_type         - line type
+// shift             - shift
+// OUTPUT
+// RESULT
+// Error status
+*/
+int showBoxes(IplImage *img, 
+              const CvPoint *points, const CvPoint *oppositePoints, int kPoints, 
+              CvScalar color, int thickness, int line_type, int shift);
+}
+}
+#endif

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_featurepyramid.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_latentsvm.h"
+#include "_lsvmc_resizeimg.h"
+
+#ifdef HAVE_TBB
+#include <tbb/tbb.h>
+#include "tbb/parallel_for.h"
+#include "tbb/blocked_range.h"
+#endif
+
+#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
+{
+
+int getPathOfFeaturePyramid(IplImage * image,
+                            float step, int numStep, int startIndex,
+                            int sideLength, CvLSVMFeaturePyramidCaskade **maps);
+
+/*
+// Getting feature map for the selected subimage
+//
+// API
+// int getFeatureMaps(const IplImage * image, const int k, featureMap **map);
+// INPUT
+// image             - selected subimage
+// k                 - size of cells
+// OUTPUT
+// map               - feature map
+// RESULT
+// Error status
+*/
+int getFeatureMaps(const IplImage* image, const int k, CvLSVMFeatureMapCaskade **map)
+{
+    int sizeX, sizeY;
+    int p, px, stringSize;
+    int height, width, numChannels;
+    int i, j, kk, c, ii, jj, d;
+    float  * datadx, * datady;
+    
+    int   ch; 
+    float magnitude, x, y, tx, ty;
+    
+    IplImage * dx, * dy;
+    int *nearest;
+    float *w, a_x, b_x;
+
+    float kernel[3] = {-1.f, 0.f, 1.f};
+    CvMat kernel_dx = cvMat(1, 3, CV_32F, kernel);
+    CvMat kernel_dy = cvMat(3, 1, CV_32F, kernel);
+
+    float * r;
+    int   * alfa;
+    
+    float boundary_x[NUM_SECTOR + 1];
+    float boundary_y[NUM_SECTOR + 1];
+    float max, dotProd;
+    int   maxi;
+
+    height = image->height;
+    width  = image->width ;
+
+    numChannels = image->nChannels;
+
+    dx    = cvCreateImage(cvSize(image->width, image->height), 
+                          IPL_DEPTH_32F, 3);
+    dy    = cvCreateImage(cvSize(image->width, image->height), 
+                          IPL_DEPTH_32F, 3);
+
+    sizeX = width  / k;
+    sizeY = height / k;
+    px    = 3 * NUM_SECTOR; 
+    p     = px;
+    stringSize = sizeX * p;
+    allocFeatureMapObject(map, sizeX, sizeY, p);
+
+    cvFilter2D(image, dx, &kernel_dx, cvPoint(-1, 0));
+    cvFilter2D(image, dy, &kernel_dy, cvPoint(0, -1));
+    
+    float arg_vector;
+    for(i = 0; i <= NUM_SECTOR; i++)
+    {
+        arg_vector    = ( (float) i ) * ( (float)(PI) / (float)(NUM_SECTOR) );
+        boundary_x[i] = cosf(arg_vector);
+        boundary_y[i] = sinf(arg_vector);
+    }/*for(i = 0; i <= NUM_SECTOR; i++) */
+
+    r    = (float *)malloc( sizeof(float) * (width * height));
+    alfa = (int   *)malloc( sizeof(int  ) * (width * height * 2));
+
+    for(j = 1; j < height - 1; j++)
+    {
+        datadx = (float*)(dx->imageData + dx->widthStep * j);
+        datady = (float*)(dy->imageData + dy->widthStep * j);
+        for(i = 1; i < width - 1; i++)
+        {
+            c = 0;
+            x = (datadx[i * numChannels + c]);
+            y = (datady[i * numChannels + c]);
+
+            r[j * width + i] =sqrtf(x * x + y * y);
+            for(ch = 1; ch < numChannels; ch++)
+            {
+                tx = (datadx[i * numChannels + ch]);
+                ty = (datady[i * numChannels + ch]);
+                magnitude = sqrtf(tx * tx + ty * ty);
+                if(magnitude > r[j * width + i])
+                {
+                    r[j * width + i] = magnitude;
+                    c = ch;
+                    x = tx;
+                    y = ty;
+                }
+            }/*for(ch = 1; ch < numChannels; ch++)*/
+            
+            max  = boundary_x[0] * x + boundary_y[0] * y;
+            maxi = 0;
+            for (kk = 0; kk < NUM_SECTOR; kk++) 
+            {
+                dotProd = boundary_x[kk] * x + boundary_y[kk] * y;
+                if (dotProd > max) 
+                {
+                    max  = dotProd;
+                    maxi = kk;
+                }
+                else 
+                {
+                    if (-dotProd > max) 
+                    {
+                        max  = -dotProd;
+                        maxi = kk + NUM_SECTOR;
+                    }
+                }
+            }
+            alfa[j * width * 2 + i * 2    ] = maxi % NUM_SECTOR;
+            alfa[j * width * 2 + i * 2 + 1] = maxi;  
+        }/*for(i = 0; i < width; i++)*/
+    }/*for(j = 0; j < height; j++)*/
+
+    nearest = (int  *)malloc(sizeof(int  ) *  k);
+    w       = (float*)malloc(sizeof(float) * (k * 2));
+    
+    for(i = 0; i < k / 2; i++)
+    {
+        nearest[i] = -1;
+    }/*for(i = 0; i < k / 2; i++)*/
+    for(i = k / 2; i < k; i++)
+    {
+        nearest[i] = 1;
+    }/*for(i = k / 2; i < k; i++)*/
+
+    for(j = 0; j < k / 2; j++)
+    {
+        b_x = k / 2 + j + 0.5f;
+        a_x = k / 2 - j - 0.5f;
+        w[j * 2    ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x)); 
+        w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));  
+    }/*for(j = 0; j < k / 2; j++)*/
+    for(j = k / 2; j < k; j++)
+    {
+        a_x = j - k / 2 + 0.5f;
+        b_x =-j + k / 2 - 0.5f + k;
+        w[j * 2    ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x)); 
+        w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));  
+    }/*for(j = k / 2; j < k; j++)*/
+
+    for(i = 0; i < sizeY; i++)
+    {
+      for(j = 0; j < sizeX; j++)
+      {
+        for(ii = 0; ii < k; ii++)
+        {
+          for(jj = 0; jj < k; jj++)
+          {
+            if ((i * k + ii > 0) && 
+                (i * k + ii < height - 1) && 
+                (j * k + jj > 0) && 
+                (j * k + jj < width  - 1))
+            {
+              d = (k * i + ii) * width + (j * k + jj);
+              (*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2    ]] += 
+                  r[d] * w[ii * 2] * w[jj * 2];
+              (*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2] * w[jj * 2];
+              if ((i + nearest[ii] >= 0) && 
+                  (i + nearest[ii] <= sizeY - 1))
+              {
+                (*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2    ]             ] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 ];
+                (*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 ];
+              }
+              if ((j + nearest[jj] >= 0) && 
+                  (j + nearest[jj] <= sizeX - 1))
+              {
+                (*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2    ]             ] += 
+                  r[d] * w[ii * 2] * w[jj * 2 + 1];
+                (*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2] * w[jj * 2 + 1];
+              }
+              if ((i + nearest[ii] >= 0) && 
+                  (i + nearest[ii] <= sizeY - 1) && 
+                  (j + nearest[jj] >= 0) && 
+                  (j + nearest[jj] <= sizeX - 1))
+              {
+                (*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2    ]             ] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
+                (*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
+              }
+            }
+          }/*for(jj = 0; jj < k; jj++)*/
+        }/*for(ii = 0; ii < k; ii++)*/
+      }/*for(j = 1; j < sizeX - 1; j++)*/
+    }/*for(i = 1; i < sizeY - 1; i++)*/
+    
+    cvReleaseImage(&dx);
+    cvReleaseImage(&dy);
+
+
+    free(w);
+    free(nearest);
+    
+    free(r);
+    free(alfa);
+
+    return LATENT_SVM_OK;
+}
+
+/*
+// Feature map Normalization and Truncation 
+//
+// API
+// int normalizeAndTruncate(featureMap *map, const float alfa);
+// INPUT
+// map               - feature map
+// alfa              - truncation threshold
+// OUTPUT
+// map               - truncated and normalized feature map
+// RESULT
+// Error status
+*/
+int normalizeAndTruncate(CvLSVMFeatureMapCaskade *map, const float alfa)
+{
+    int i,j, ii;
+    int sizeX, sizeY, p, pos, pp, xp, pos1, pos2;
+    float * partOfNorm; // norm of C(i, j)
+    float * newData;
+    float   valOfNorm;
+
+    sizeX     = map->sizeX;
+    sizeY     = map->sizeY;
+    partOfNorm = (float *)malloc (sizeof(float) * (sizeX * sizeY));
+
+    p  = NUM_SECTOR;
+    xp = NUM_SECTOR * 3;
+    pp = NUM_SECTOR * 12;
+
+    for(i = 0; i < sizeX * sizeY; i++)
+    {
+        valOfNorm = 0.0f;
+        pos = i * map->numFeatures;
+        for(j = 0; j < p; j++)
+        {
+            valOfNorm += map->map[pos + j] * map->map[pos + j];
+        }/*for(j = 0; j < p; j++)*/
+        partOfNorm[i] = valOfNorm;
+    }/*for(i = 0; i < sizeX * sizeY; i++)*/
+    
+    sizeX -= 2;
+    sizeY -= 2;
+
+    newData = (float *)malloc (sizeof(float) * (sizeX * sizeY * pp));
+//normalization
+    for(i = 1; i <= sizeY; i++)
+    {
+        for(j = 1; j <= sizeX; j++)
+        {
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j + 1)] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j + 1)]) + FLT_EPSILON;
+            pos1 = (i  ) * (sizeX + 2) * xp + (j  ) * xp;
+            pos2 = (i-1) * (sizeX    ) * pp + (j-1) * pp;
+            for(ii = 0; ii < p; ii++)
+            {
+                newData[pos2 + ii        ] = map->map[pos1 + ii    ] / valOfNorm;
+            }/*for(ii = 0; ii < p; ii++)*/
+            for(ii = 0; ii < 2 * p; ii++)
+            {
+                newData[pos2 + ii + p * 4] = map->map[pos1 + ii + p] / valOfNorm;
+            }/*for(ii = 0; ii < 2 * p; ii++)*/
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j + 1)] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j + 1)]) + FLT_EPSILON;
+            for(ii = 0; ii < p; ii++)
+            {
+                newData[pos2 + ii + p    ] = map->map[pos1 + ii    ] / valOfNorm;
+            }/*for(ii = 0; ii < p; ii++)*/
+            for(ii = 0; ii < 2 * p; ii++)
+            {
+                newData[pos2 + ii + p * 6] = map->map[pos1 + ii + p] / valOfNorm;
+            }/*for(ii = 0; ii < 2 * p; ii++)*/
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j - 1)] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j - 1)]) + FLT_EPSILON;
+            for(ii = 0; ii < p; ii++)
+            {
+                newData[pos2 + ii + p * 2] = map->map[pos1 + ii    ] / valOfNorm;
+            }/*for(ii = 0; ii < p; ii++)*/
+            for(ii = 0; ii < 2 * p; ii++)
+            {
+                newData[pos2 + ii + p * 8] = map->map[pos1 + ii + p] / valOfNorm;
+            }/*for(ii = 0; ii < 2 * p; ii++)*/
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j - 1)] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j - 1)]) + FLT_EPSILON;
+            for(ii = 0; ii < p; ii++)
+            {
+                newData[pos2 + ii + p * 3 ] = map->map[pos1 + ii    ] / valOfNorm;
+            }/*for(ii = 0; ii < p; ii++)*/
+            for(ii = 0; ii < 2 * p; ii++)
+            {
+                newData[pos2 + ii + p * 10] = map->map[pos1 + ii + p] / valOfNorm;
+            }/*for(ii = 0; ii < 2 * p; ii++)*/
+        }/*for(j = 1; j <= sizeX; j++)*/
+    }/*for(i = 1; i <= sizeY; i++)*/
+//truncation
+    for(i = 0; i < sizeX * sizeY * pp; i++)
+    {
+        if(newData [i] > alfa) newData [i] = alfa;
+    }/*for(i = 0; i < sizeX * sizeY * pp; i++)*/
+//swop data
+
+    map->numFeatures  = pp;
+    map->sizeX = sizeX;
+    map->sizeY = sizeY;
+
+    free (map->map);
+    free (partOfNorm);
+
+    map->map = newData;
+
+    return LATENT_SVM_OK;
+}
+/*
+// Feature map reduction
+// In each cell we reduce dimension of the feature vector
+// according to original paper special procedure
+//
+// API
+// int PCAFeatureMaps(featureMap *map)
+// INPUT
+// map               - feature map
+// OUTPUT
+// map               - feature map
+// RESULT
+// Error status
+*/
+int PCAFeatureMaps(CvLSVMFeatureMapCaskade *map)
+{ 
+    int i,j, ii, jj, k;
+    int sizeX, sizeY, p,  pp, xp, yp, pos1, pos2;
+    float * newData;
+    float val;
+    float nx, ny;
+    
+    sizeX = map->sizeX;
+    sizeY = map->sizeY;
+    p     = map->numFeatures;
+    pp    = NUM_SECTOR * 3 + 4;
+    yp    = 4;
+    xp    = NUM_SECTOR;
+
+    nx    = 1.0f / sqrtf((float)(xp * 2));
+    ny    = 1.0f / sqrtf((float)(yp    ));
+
+    newData = (float *)malloc (sizeof(float) * (sizeX * sizeY * pp));
+
+    for(i = 0; i < sizeY; i++)
+    {
+        for(j = 0; j < sizeX; j++)
+        {
+            pos1 = ((i)*sizeX + j)*p;
+            pos2 = ((i)*sizeX + j)*pp;
+            k = 0;
+            for(jj = 0; jj < xp * 2; jj++)
+            {
+                val = 0;
+                for(ii = 0; ii < yp; ii++)
+                {
+                    val += map->map[pos1 + yp * xp + ii * xp * 2 + jj];
+                }/*for(ii = 0; ii < yp; ii++)*/
+                newData[pos2 + k] = val * ny;
+                k++;
+            }/*for(jj = 0; jj < xp * 2; jj++)*/
+            for(jj = 0; jj < xp; jj++)
+            {
+                val = 0;
+                for(ii = 0; ii < yp; ii++)
+                {
+                    val += map->map[pos1 + ii * xp + jj];
+                }/*for(ii = 0; ii < yp; ii++)*/
+                newData[pos2 + k] = val * ny;
+                k++;
+            }/*for(jj = 0; jj < xp; jj++)*/
+            for(ii = 0; ii < yp; ii++)
+            {
+                val = 0;
+                for(jj = 0; jj < 2 * xp; jj++)
+                {
+                    val += map->map[pos1 + yp * xp + ii * xp * 2 + jj];
+                }/*for(jj = 0; jj < xp; jj++)*/
+                newData[pos2 + k] = val * nx;
+                k++;
+            } /*for(ii = 0; ii < yp; ii++)*/           
+        }/*for(j = 0; j < sizeX; j++)*/
+    }/*for(i = 0; i < sizeY; i++)*/
+//swop data
+
+    map->numFeatures = pp;
+
+    free (map->map);
+
+    map->map = newData;
+
+    return LATENT_SVM_OK;
+}
+
+int getPathOfFeaturePyramid(IplImage * image, 
+                            float step, int numStep, int startIndex,
+                            int sideLength, CvLSVMFeaturePyramidCaskade **maps)
+{
+    CvLSVMFeatureMapCaskade *map;
+    IplImage *scaleTmp;
+    float scale;
+    int   i;
+    
+    for(i = 0; i < numStep; i++)
+    {
+        scale = 1.0f / powf(step, (float)i);
+        scaleTmp = resize_opencv (image, scale);
+        getFeatureMaps(scaleTmp, sideLength, &map);
+        normalizeAndTruncate(map, VAL_OF_TRUNCATE);
+        PCAFeatureMaps(map);
+        (*maps)->pyramid[startIndex + i] = map;
+        cvReleaseImage(&scaleTmp);
+    }/*for(i = 0; i < numStep; i++)*/
+    return LATENT_SVM_OK;
+}
+
+#ifdef HAVE_TBB
+
+class PathOfFeaturePyramid : public ParallelLoopBody{
+public:
+    IplImage * image;
+    float step;
+    int startIndex;
+    int sideLength;
+    CvLSVMFeaturePyramidCaskade **maps;
+
+    void operator() (const Range& range) const
+    {
+        CvLSVMFeatureMapCaskade *map;
+        IplImage *scaleTmp;
+        float scale;
+        int   err;
+        
+        for( int i=range.start; i!=range.end; ++i )
+        {
+          scale = 1.0f / powf(step, (float)i);
+          scaleTmp = resize_opencv (image, scale);
+          err = getFeatureMaps(scaleTmp, sideLength, &map);
+          err = normalizeAndTruncate(map, VAL_OF_TRUNCATE);
+          err = PCAFeatureMaps(map);
+          (*maps)->pyramid[startIndex + i] = map;
+          cvReleaseImage(&scaleTmp);
+        }
+    }
+};
+
+
+int getPathOfFeaturePyramid_TBB(IplImage * image, 
+                            float step, int numStep, int startIndex,
+                            int sideLength, CvLSVMFeaturePyramidCaskade **maps)
+{
+    PathOfFeaturePyramid str;
+    str.step = step;
+    str.startIndex = startIndex;
+    str.sideLength = sideLength;
+    str.maps = maps;
+    str.image = image;
+    
+    cv::parallel_for_(Range( 0, numStep ), str );
+    
+    return LATENT_SVM_OK;
+}
+#endif
+
+/*
+// Getting feature pyramid  
+//
+// API
+// int getFeaturePyramid(IplImage * image, const CvLSVMFilterObjectCaskade **all_F, 
+                      const int n_f,
+                      const int lambda, const int k, 
+                      const int startX, const int startY, 
+                      const int W, const int H, featurePyramid **maps);
+// INPUT
+// image             - image
+// OUTPUT
+// maps              - feature maps for all levels
+// RESULT
+// Error status
+*/
+int getFeaturePyramid(IplImage * image, CvLSVMFeaturePyramidCaskade **maps)
+{
+    IplImage *imgResize;
+    float step;
+    int   numStep;
+    int   maxNumCells;
+    int   W, H;
+    
+    if(image->depth == IPL_DEPTH_32F)
+    {
+        imgResize = image;
+    }
+    else
+    {
+        imgResize = cvCreateImage(cvSize(image->width , image->height) ,
+                                  IPL_DEPTH_32F , 3);
+        cvConvert(image, imgResize);        
+    }
+    
+    W = imgResize->width;
+    H = imgResize->height;
+
+    step = powf(2.0f, 1.0f / ((float)LAMBDA));
+    maxNumCells = W / SIDE_LENGTH;
+    if( maxNumCells > H / SIDE_LENGTH )
+    {
+        maxNumCells = H / SIDE_LENGTH;
+    }
+    numStep = (int)(logf((float) maxNumCells / (5.0f)) / logf( step )) + 1;
+    
+    allocFeaturePyramidObject(maps, numStep + LAMBDA);
+
+#ifdef HAVE_TBB
+    getPathOfFeaturePyramid_TBB(imgResize, step   , LAMBDA, 0, 
+                            SIDE_LENGTH / 2, maps);
+    getPathOfFeaturePyramid_TBB(imgResize, step, numStep, LAMBDA, 
+                            SIDE_LENGTH    , maps);
+#else
+    getPathOfFeaturePyramid(imgResize, step   , LAMBDA, 0, 
+                            SIDE_LENGTH / 2, maps);
+    getPathOfFeaturePyramid(imgResize, step, numStep, LAMBDA, 
+                            SIDE_LENGTH    , maps);
+#endif
+
+    if(image->depth != IPL_DEPTH_32F)
+    {
+        cvReleaseImage(&imgResize);
+    }
+
+    return LATENT_SVM_OK;
+}
+}
+}

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_latentsvm.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_latentsvm.h"
+#include "_lsvmc_matching.h"
+#include "_lsvmc_function.h"
+
+#ifdef HAVE_TBB
+#include <tbb/tbb.h>
+#include "tbb/parallel_for.h"
+#include "tbb/blocked_range.h"
+#endif
+
+namespace cv
+{
+namespace lsvm
+{
+
+int estimateBoxes(CvPoint *points, int *levels, int kPoints,
+                  int sizeX, int sizeY, CvPoint **oppositePoints);
+
+int searchObjectThreshold(const CvLSVMFeaturePyramidCaskade *H,
+                          const CvLSVMFeaturePyramidCaskade *H_PCA,
+                          const CvLSVMFilterObjectCaskade **all_F, int n,
+                          float b,
+                          int maxXBorder, int maxYBorder,
+                          float scoreThreshold,
+                          CvPoint **points, int **levels, int *kPoints,
+                          float **score, CvPoint ***partsDisplacement);
+
+void FeaturePyramid32(CvLSVMFeaturePyramidCaskade* H, int maxX, int maxY){
+    CvLSVMFeatureMapCaskade *H32; 
+    int i, j, k, l;
+    int p  = H->pyramid[0]->numFeatures;
+
+    for(i = 0; i < H->numLevels; i++){
+        allocFeatureMapObject(&(H32), H->pyramid[i]->sizeX, H->pyramid[i]->sizeY, p + 1);
+        for(j = 0; j < (H->pyramid[i]->sizeX * H->pyramid[i]->sizeY); j++){
+            for(k = 0; k < p; k++){
+                H32->map[j * (p + 1) + k] = H->pyramid[i]->map[j * p + k];
+            }
+            H32->map[j * (p + 1) + k] = 1.0f;
+        }
+        freeFeatureMapObject(&(H->pyramid[i]));
+        H->pyramid[i] = H32;
+    }
+    for(l = 0; l < H->numLevels; l++){
+        for(j = maxY + 1; j < (H->pyramid[l]->sizeY - maxY - 1); j++){
+            for(i = maxX + 1; i < (H->pyramid[l]->sizeX - maxX - 1); i++){
+                H->pyramid[l]->map[ (j * H->pyramid[l]->sizeX + i) * (p+1) + p] = 0.0f;
+            }
+        }
+    }
+}
+
+CvLSVMFeaturePyramidCaskade* createPCA_FeaturePyramid(CvLSVMFeaturePyramidCaskade* H, CvLatentSvmDetectorCaskade* detector, int maxX, int maxY){
+    CvLSVMFeaturePyramidCaskade *H_PCA; 
+    int i, j, k, l;
+    int max_l = detector->pca_size;
+    int p = H->pyramid[0]->numFeatures;
+
+    allocFeaturePyramidObject(&H_PCA, H->numLevels);
+
+    for(i = 0; i < H->numLevels; i++){
+        allocFeatureMapObject(&(H_PCA->pyramid[i]), H->pyramid[i]->sizeX, H->pyramid[i]->sizeY, 6);
+        for(j = 0; j < (H->pyramid[i]->sizeX * H->pyramid[i]->sizeY); j++){
+            for(k = 0; k < 5; k++){
+                for(l = 0; l < max_l; l++){
+                    H_PCA->pyramid[i]->map[j * 6 + k] += 
+                      detector->pca[k * max_l + l] * H->pyramid[i]->map[j * p + l];
+                }
+            }
+            H_PCA->pyramid[i]->map[j * 6 + k] = 1.0f;
+        }
+    }
+    for(l = 0; l < H->numLevels; l++){
+        for(j = maxY + 1; j < (H->pyramid[l]->sizeY - maxY - 1); j++){
+            for(i = maxX + 1; i < (H->pyramid[l]->sizeX - maxX - 1); i++){
+                H_PCA->pyramid[l]->map[ (j * H->pyramid[l]->sizeX + i) * 6 + 5] = 0.0f;
+            }
+        }
+    }
+    
+    return H_PCA;
+}
+
+/*
+// Transformation filter displacement from the block space 
+// to the space of pixels at the initial image
+//
+// API
+// int convertPoints(int countLevel, CvPoint *points, int *levels, 
+                  CvPoint **partsDisplacement, int kPoints, int n);
+// INPUT
+// countLevel        - the number of levels in the feature pyramid
+// points            - the set of root filter positions (in the block space)
+// levels            - the set of levels
+// partsDisplacement - displacement of part filters (in the block space)
+// kPoints           - number of root filter positions
+// n                 - number of part filters
+// initialImageLevel - level that contains features for initial image
+// maxXBorder        - the largest root filter size (X-direction)
+// maxYBorder        - the largest root filter size (Y-direction)
+// OUTPUT
+// points            - the set of root filter positions (in the space of pixels)
+// partsDisplacement - displacement of part filters (in the space of pixels)
+// RESULT
+// Error status
+*/
+int convertPoints(int /*countLevel*/, int lambda, 
+                  int initialImageLevel,
+                  CvPoint *points, int *levels, 
+                  CvPoint **partsDisplacement, int kPoints, int n, 
+                  int maxXBorder,
+                  int maxYBorder)
+{
+    int i, j;
+    float step, scale;
+    step = powf( 2.0f, 1.0f / ((float)lambda) );
+
+    //computeBorderSize(maxXBorder, maxYBorder, &bx, &by);
+    
+    for (i = 0; i < kPoints; i++)
+    {
+        // scaling factor for root filter
+        scale = SIDE_LENGTH * powf(step, (float)(levels[i] - initialImageLevel));
+        points[i].x = (int)((points[i].x - maxXBorder) * scale);
+        points[i].y = (int)((points[i].y - maxYBorder) * scale);
+
+        // scaling factor for part filters
+        scale = SIDE_LENGTH * powf(step, (float)(levels[i] - lambda - initialImageLevel));
+        for (j = 0; j < n; j++)
+        {            
+            partsDisplacement[i][j].x = (int)((partsDisplacement[i][j].x - 
+                                               maxXBorder) * scale);
+            partsDisplacement[i][j].y = (int)((partsDisplacement[i][j].y - 
+                                               maxYBorder) * scale);
+        }
+    }
+    return LATENT_SVM_OK;
+}
+
+/*
+// Elimination boxes that are outside the image boudaries
+//
+// API
+// int clippingBoxes(int width, int height, 
+                     CvPoint *points, int kPoints);
+// INPUT
+// width             - image wediht
+// height            - image heigth
+// points            - a set of points (coordinates of top left or
+                       bottom right corners)
+// kPoints           - points number
+// OUTPUT
+// points            - updated points (if coordinates less than zero then
+                       set zero coordinate, if coordinates more than image 
+                       size then set coordinates equal image size)
+// RESULT
+// Error status
+*/
+int clippingBoxes(int width, int height, 
+                  CvPoint *points, int kPoints)
+{
+    int i;
+    for (i = 0; i < kPoints; i++)
+    {
+        if (points[i].x > width - 1)
+        {
+            points[i].x = width - 1;
+        }
+        if (points[i].x < 0)
+        {
+            points[i].x = 0;
+        }
+        if (points[i].y > height - 1)
+        {
+            points[i].y = height - 1;
+        }
+        if (points[i].y < 0)
+        {
+            points[i].y = 0;
+        }
+    }
+    return LATENT_SVM_OK;
+}
+
+/*
+// Creation feature pyramid with nullable border
+//
+// API
+// featurePyramid* createFeaturePyramidWithBorder(const IplImage *image,
+                                                  int maxXBorder, int maxYBorder);
+
+// INPUT
+// image             - initial image     
+// maxXBorder        - the largest root filter size (X-direction)
+// maxYBorder        - the largest root filter size (Y-direction)
+// OUTPUT
+// RESULT
+// Feature pyramid with nullable border
+*/
+CvLSVMFeaturePyramidCaskade* createFeaturePyramidWithBorder(IplImage *image,
+                                               int maxXBorder, int maxYBorder)
+{
+    int opResult;
+    int bx, by;
+    int level;
+    CvLSVMFeaturePyramidCaskade *H;
+
+    // Obtaining feature pyramid
+    opResult = getFeaturePyramid(image, &H);
+
+    if (opResult != LATENT_SVM_OK)
+    {
+        freeFeaturePyramidObject(&H);
+        return NULL;
+    } /* if (opResult != LATENT_SVM_OK) */
+
+    // Addition nullable border for each feature map
+    // the size of the border for root filters
+    bx = maxXBorder + 1; 
+    by = maxYBorder + 1;
+    for (level = 0; level < H->numLevels; level++)
+    {
+        addNullableBorder(H->pyramid[level], bx, by);
+    }
+    return H;
+}
+
+/*
+// Computation right bottom corners coordinates of bounding boxes
+//
+// API
+// int estimateBoxes(CvPoint *points, int *levels, int kPoints, 
+                     int sizeX, int sizeY, CvPoint **oppositePoints);
+// INPUT
+// points            - left top corners coordinates of bounding boxes
+// levels            - levels of feature pyramid where points were found
+// (sizeX, sizeY)    - size of root filter
+// OUTPUT
+// oppositePoins     - right bottom corners coordinates of bounding boxes
+// RESULT
+// Error status
+*/
+int estimateBoxes(CvPoint *points, int *levels, int kPoints, 
+                  int sizeX, int sizeY, CvPoint **oppositePoints)
+{
+    int i;
+    float step;
+
+    step = powf( 2.0f, 1.0f / ((float)(LAMBDA)));
+
+    *oppositePoints = (CvPoint *)malloc(sizeof(CvPoint) * kPoints);
+    for (i = 0; i < kPoints; i++)
+    {
+        getOppositePoint(points[i], sizeX, sizeY, step, levels[i] - LAMBDA, &((*oppositePoints)[i]));
+    }
+    return LATENT_SVM_OK;
+}
+
+/*
+// Computation of the root filter displacement and values of score function
+//
+// API
+// int searchObjectThreshold(const featurePyramid *H, 
+                             const CvLSVMFilterObjectCaskade **all_F, int n,
+                             float b, 
+                             int maxXBorder, int maxYBorder, 
+                             float scoreThreshold,
+                             CvPoint **points, int **levels, int *kPoints, 
+                             float **score, CvPoint ***partsDisplacement);
+// INPUT
+// H                 - feature pyramid
+// all_F             - the set of filters (the first element is root filter, 
+                       other elements - part filters)
+// n                 - the number of part filters
+// b                 - linear term of the score function
+// maxXBorder        - the largest root filter size (X-direction)
+// maxYBorder        - the largest root filter size (Y-direction)
+// scoreThreshold    - score threshold
+// OUTPUT
+// points            - positions (x, y) of the upper-left corner 
+                       of root filter frame
+// levels            - levels that correspond to each position
+// kPoints           - number of positions
+// score             - values of the score function
+// partsDisplacement - part filters displacement for each position 
+                       of the root filter
+// RESULT
+// Error status
+*/
+int searchObjectThreshold(const CvLSVMFeaturePyramidCaskade *H,
+                          const CvLSVMFeaturePyramidCaskade *H_PCA,
+                          const CvLSVMFilterObjectCaskade **all_F, int n,
+                          float b, 
+                          int maxXBorder, int maxYBorder, 
+                          float scoreThreshold,
+                          CvPoint **points, int **levels, int *kPoints, 
+                          float **score, CvPoint ***partsDisplacement)
+{
+    int opResult = LATENT_SVM_OK;
+
+  int i, j, k, path;
+  int di, dj, ii;
+
+    //int *map,jj, nomer;
+    //FILE *dump;
+
+  float p;
+  float fine;
+  float mpath;
+
+  CvPoint *tmpPoints;
+  int     *tmpLevels;
+    float   **tmpAScore;
+
+    int flag,flag2;
+
+    CvPoint *PCAPoints;
+  int     *PCALevels;
+    float   **PCAAScore; 
+  int      PCAkPoints;
+    float    PCAScore;
+    int tmpSize = 10;
+    int tmpStep = 10;
+
+    float *rootScoreForLevel;
+    int maxX, maxY, maxPathX, maxPathY, step;
+    int pathX, pathY;
+    int ai;
+
+
+    float **cashM;
+    int   **maskM;
+    int    sizeM;
+
+    sizeM  = H_PCA->pyramid[0]->sizeX - maxXBorder + 1;
+    sizeM *= H_PCA->pyramid[0]->sizeY - maxYBorder + 1;
+
+    cashM = (float**)malloc(sizeof(float *) * n);
+    maskM = (int **)malloc(sizeof(int   *) * n);
+    for(ai = 0; ai < n; ai++){
+        cashM[ai] = (float*)malloc(sizeof(float) * sizeM);
+        maskM[ai] = (int *)malloc(sizeof(int) * (sizeM/(sizeof(int) * 8) + 1));
+    }
+    
+    
+    PCAPoints = (CvPoint*)malloc(sizeof(CvPoint) * tmpSize);
+    PCALevels = (int*)malloc(sizeof(int)     * tmpSize);
+    PCAAScore = (float **)malloc(sizeof(float *) * tmpSize);
+    for(ai = 0; ai < tmpSize; ai++){
+        PCAAScore[ai] = (float *)malloc(sizeof(float) * (n + 2));
+    }
+
+    PCAkPoints = 0;
+    for(k = LAMBDA; k < H_PCA->numLevels; k++){
+        maxX = H_PCA->pyramid[k]->sizeX - maxXBorder + 1;
+        maxY = H_PCA->pyramid[k]->sizeY - maxYBorder + 1;
+        maxPathX = H_PCA->pyramid[k - LAMBDA]->sizeX - maxXBorder + 1;
+        maxPathY = H_PCA->pyramid[k - LAMBDA]->sizeY - maxYBorder + 1;
+        rootScoreForLevel = (float *) malloc(sizeof(float) 
+            * (maxX - (int)ceil(maxXBorder/2.0)) 
+            * (maxY - (int)ceil(maxYBorder/2.0)));
+
+        step = maxX - (int)ceil(maxXBorder/2.0);
+        //dump = fopen("map_10.csv", "w");
+        for(j = (int)ceil(maxYBorder/2.0) ; j < maxY; j++){
+            for(i = (int)ceil(maxXBorder/2.0) ; i < maxX; i++){        
+          rootScoreForLevel[(j - (int)ceil(maxYBorder/2.0)) * step + i - (int)ceil(maxXBorder/2.0)] 
+                = calcM_PCA(k, i, j, H_PCA, all_F[0]);
+        //         fprintf(dump, "%f;", rootScoreForLevel[j * maxX + i]);
+            }
+        //     fprintf(dump, "\n");
+        }
+        // fclose(dump);
+
+        sizeM  = maxPathX * maxPathY;
+        for(path = 0 ; path < n; path++){
+            memset(maskM[path], 0, sizeof(int) * (sizeM/(sizeof(int) * 8) + 1));
+        }
+      
+        for(j = (int)ceil(maxYBorder/2.0) ; j < maxY; j++){
+            for(i = (int)ceil(maxXBorder/2.0) ; i < maxX; i++){
+    //      PCAScore = calcM_PCA(k, i, j, H_PCA, all_F[0]);
+                PCAScore = 
+                    rootScoreForLevel[(j - (int)ceil(maxYBorder/2.0)) * step + i - (int)ceil(maxXBorder/2.0)];
+                PCAScore += b;
+                PCAAScore[PCAkPoints][0] = PCAScore - b;
+
+                flag2=0;
+          for(path = 1 ; (path <= n) && (!flag2); path++){
+                    if(PCAScore > all_F[path - 1]->Deformation_PCA)
+                    {
+              p = F_MIN ;
+                        //pathX = (i - maxXBorder - 1) * 2 + maxXBorder + 1 + all_F[path]->V.x;
+                        //pathY = (j - maxYBorder - 1) * 2 + maxYBorder + 1 + all_F[path]->V.y; 
+                        pathX = i * 2 - maxXBorder + all_F[path]->V.x;
+                        pathY = j * 2 - maxYBorder + all_F[path]->V.y; 
+                        flag = 1;
+                        for(dj = max(0,        pathY - all_F[path]->deltaY); 
+                dj < min(maxPathY, pathY + all_F[path]->deltaY); 
+                dj++){
+                            for(di = max(0,        pathX - all_F[path]->deltaX); 
+                      di < min(maxPathX, pathX + all_F[path]->deltaX); 
+                      di++){
+                    //fine = calcFine(all_F[path], abs(pathX - di), abs(pathY - dj));
+                                fine = calcFine(all_F[path], pathX - di, pathY - dj);
+                                if((PCAScore - fine) > all_F[path - 1]->Hypothesis_PCA)
+                                {
+                                    flag = 0;
+                      mpath = calcM_PCA_cash(k - LAMBDA, di, dj, H_PCA, all_F[path], cashM[path - 1], maskM[path - 1], maxPathX) - fine;
+                      if( mpath > p){
+                        p     = mpath;
+                                }
+                                }
+                            }
+                        }
+                        if(flag==0){
+                            PCAAScore[PCAkPoints][path] = p;// + pfine;
+                            PCAScore += p;// + pfine;                            
+                        } else flag2 = 1;
+            } 
+                    else flag2 = 1;
+          }
+                if((PCAScore > all_F[n]->Hypothesis_PCA)&&(flag2==0)){
+                 PCALevels[PCAkPoints]   = k;
+            PCAPoints[PCAkPoints].x = i;
+            PCAPoints[PCAkPoints].y = j;
+                    PCAAScore[PCAkPoints][n + 1] = PCAScore;
+            PCAkPoints ++;
+            if(PCAkPoints >= tmpSize){
+                        tmpPoints = (CvPoint*)malloc(sizeof(CvPoint) * (tmpSize + tmpStep));
+                        tmpLevels = (int*)malloc(sizeof(int)     * (tmpSize + tmpStep));
+                        tmpAScore = (float **)malloc(sizeof(float *) * (tmpSize + tmpStep));
+                        for(ai = tmpSize; ai < tmpSize + tmpStep; ai++){
+                            tmpAScore[ai] = (float *)malloc(sizeof(float) * (n + 2));
+                        }
+                        for(ii = 0; ii < PCAkPoints; ii++){
+                            tmpLevels[ii]   = PCALevels[ii]  ;
+                    tmpPoints[ii].x = PCAPoints[ii].x;
+                    tmpPoints[ii].y = PCAPoints[ii].y;
+                            tmpAScore[ii]   = PCAAScore[ii]  ;
+                        }
+                        free(PCALevels);
+                        free(PCAPoints);
+                        free(PCAAScore);
+                        PCALevels = tmpLevels;
+                        PCAPoints = tmpPoints;
+                        PCAAScore = tmpAScore;
+                        tmpSize += tmpStep;
+            }
+                }     
+        }            
+      }
+        free (rootScoreForLevel);
+    }
+
+  (*points) = (CvPoint *)malloc(sizeof(CvPoint) * PCAkPoints);
+  (*levels) = (int    *)malloc(sizeof(int    ) * PCAkPoints);
+  (*score ) = (float  *)malloc(sizeof(float  ) * PCAkPoints);
+  (*partsDisplacement) = (CvPoint **)malloc(sizeof(CvPoint *) * (PCAkPoints + 1));
+  
+  (*kPoints) = 0;
+    if(PCAkPoints > 0)
+        (*partsDisplacement)[(*kPoints)] = (CvPoint *)malloc(sizeof(CvPoint) * (n + 1));
+    for(ii = 0; ii < PCAkPoints; ii++)
+    {
+      k = PCALevels[ii]  ;
+      i = PCAPoints[ii].x;
+      j = PCAPoints[ii].y;
+        
+        maxPathX = H_PCA->pyramid[k - LAMBDA]->sizeX - maxXBorder + 1;
+        maxPathY = H_PCA->pyramid[k - LAMBDA]->sizeY - maxYBorder + 1;
+
+      (*score )[(*kPoints)] = PCAAScore[ii][n + 1] + calcM(k, i, j, H, all_F[0]) - PCAAScore[ii][0];
+        (*partsDisplacement)[(*kPoints)][0].x = i;
+    (*partsDisplacement)[(*kPoints)][0].y = j;
+      for(path = 1 ; path <= n; path++){
+            if((*score )[(*kPoints)] < all_F[path - 1]->Deformation) break;
+           // {
+        p = F_MIN ;
+            flag = 1;
+            //pathX = (i - maxXBorder - 1) * 2 + maxXBorder + 1 + all_F[path]->V.x;
+            //pathY = (j - maxYBorder - 1) * 2 + maxYBorder + 1 + all_F[path]->V.y; 
+            pathX = i * 2 - maxXBorder + all_F[path]->V.x;
+            pathY = j * 2 - maxYBorder + all_F[path]->V.y; 
+            for(dj = max(0,        pathY - all_F[path]->deltaY); 
+          dj < min(maxPathY, pathY + all_F[path]->deltaY); 
+          dj++){
+                for(di = max(0,        pathX - all_F[path]->deltaX); 
+                di < min(maxPathX, pathX + all_F[path]->deltaX); 
+                di++){
+            //fine = calcFine(all_F[path], abs(pathX - di), abs(pathY - dj));
+                    fine = calcFine(all_F[path], pathX - di, pathY - dj);
+                    if(((*score )[(*kPoints)] - fine) > all_F[path - 1]->Hypothesis)
+                    {
+                        flag = 0;
+                        mpath = calcM(k - LAMBDA, di, dj, H, all_F[path]) - fine;
+              if(mpath > p){
+                p = mpath;
+                (*partsDisplacement)[(*kPoints)][path].x = di;
+                (*partsDisplacement)[(*kPoints)][path].y = dj;
+              }
+            }
+          }
+        }
+            if(flag == 0)
+            (*score )[(*kPoints)] +=  p - PCAAScore[ii][path];// + pfine;
+       // }
+      }
+      if((*score )[(*kPoints)] > scoreThreshold)
+        {
+        (*levels)[(*kPoints)]   = k;
+        (*points)[(*kPoints)].x = i;
+        (*points)[(*kPoints)].y = j;
+        (*kPoints) ++;
+            (*partsDisplacement)[(*kPoints)] = (CvPoint*) malloc(sizeof(CvPoint) * (n + 1));
+      }
+  }
+    if((*kPoints) > 0){
+        free((*partsDisplacement)[(*kPoints)]);
+    }
+    // Matching end
+
+    free(PCAPoints);
+    free(PCALevels);
+    for(ai = 0; ai < tmpSize; ai++){
+        free(PCAAScore[ai]);
+    }
+    free(PCAAScore);
+
+    for(ai = 0; ai < n; ai++){
+        free(cashM[ai]);
+        free(maskM[ai]);
+    }
+    free(cashM);
+    free(maskM);
+
+    if (opResult != (LATENT_SVM_OK))
+    {
+        return LATENT_SVM_SEARCH_OBJECT_FAILED;
+    }  
+   
+    // Transformation filter displacement from the block space 
+    // to the space of pixels at the initial image
+    // that settles at the level number LAMBDA
+    convertPoints(H->numLevels, LAMBDA, LAMBDA, (*points), 
+                  (*levels), (*partsDisplacement), (*kPoints), n, 
+                  maxXBorder, maxYBorder);
+
+    return LATENT_SVM_OK;
+}
+
+/*
+// Compute opposite point for filter box
+//
+// API
+// int getOppositePoint(CvPoint point,
+                        int sizeX, int sizeY,
+                        float step, int degree,
+                        CvPoint *oppositePoint);
+
+// INPUT
+// point             - coordinates of filter top left corner
+                       (in the space of pixels)
+// (sizeX, sizeY)    - filter dimension in the block space
+// step              - scaling factor
+// degree            - degree of the scaling factor
+// OUTPUT
+// oppositePoint     - coordinates of filter bottom corner
+                       (in the space of pixels)
+// RESULT
+// Error status
+*/
+int getOppositePoint(CvPoint point,
+                     int sizeX, int sizeY,
+                     float step, int degree,
+                     CvPoint *oppositePoint)
+{
+    float scale;
+    scale = SIDE_LENGTH * powf(step, (float)degree);
+    oppositePoint->x = (int)(point.x + sizeX * scale);
+    oppositePoint->y = (int)(point.y + sizeY * scale);
+    return LATENT_SVM_OK;
+}
+
+
+/*
+// Drawing root filter boxes
+//
+// API
+// int showRootFilterBoxes(const IplImage *image,
+                           const CvLSVMFilterObjectCaskade *filter, 
+                           CvPoint *points, int *levels, int kPoints,
+                           CvScalar color, int thickness, 
+                           int line_type, int shift);
+// INPUT
+// image             - initial image
+// filter            - root filter object
+// points            - a set of points
+// levels            - levels of feature pyramid
+// kPoints           - number of points
+// color             - line color for each box
+// thickness         - line thickness
+// line_type         - line type
+// shift             - shift
+// OUTPUT
+// window contained initial image and filter boxes
+// RESULT
+// Error status
+*/
+int showRootFilterBoxes(IplImage *image,
+                        const CvLSVMFilterObjectCaskade *filter, 
+                        CvPoint *points, int *levels, int kPoints,
+                        CvScalar color, int thickness, 
+                        int line_type, int shift)
+{   
+    int i;
+    float step;
+    CvPoint oppositePoint;
+    step = powf( 2.0f, 1.0f / ((float)LAMBDA));
+    
+    for (i = 0; i < kPoints; i++)
+    {
+        // Drawing rectangle for filter
+        getOppositePoint(points[i], filter->sizeX, filter->sizeY, 
+                         step, levels[i] - LAMBDA, &oppositePoint);
+        cvRectangle(image, points[i], oppositePoint, 
+                    color, thickness, line_type, shift);
+    }
+#ifdef HAVE_OPENCV_HIGHGUI
+    cvShowImage("Initial image", image);
+#endif
+    return LATENT_SVM_OK;
+}
+
+/*
+// Drawing part filter boxes
+//
+// API
+// int showPartFilterBoxes(const IplImage *image,
+                           const CvLSVMFilterObjectCaskade *filter, 
+                           CvPoint *points, int *levels, int kPoints,
+                           CvScalar color, int thickness, 
+                           int line_type, int shift);
+// INPUT
+// image             - initial image
+// filters           - a set of part filters
+// n                 - number of part filters
+// partsDisplacement - a set of points
+// levels            - levels of feature pyramid
+// kPoints           - number of foot filter positions
+// color             - line color for each box
+// thickness         - line thickness
+// line_type         - line type
+// shift             - shift
+// OUTPUT
+// window contained initial image and filter boxes
+// RESULT
+// Error status
+*/
+int showPartFilterBoxes(IplImage *image,
+                        const CvLSVMFilterObjectCaskade **filters,
+                        int n, CvPoint **partsDisplacement, 
+                        int *levels, int kPoints,
+                        CvScalar color, int thickness, 
+                        int line_type, int shift)
+{
+    int i, j;
+    float step;
+    CvPoint oppositePoint;
+
+    step = powf( 2.0f, 1.0f / ((float)LAMBDA));
+
+    for (i = 0; i < kPoints; i++)
+    {
+        for (j = 0; j < n; j++)
+        {
+            // Drawing rectangles for part filters
+            getOppositePoint(partsDisplacement[i][j], 
+                             filters[j + 1]->sizeX, filters[j + 1]->sizeY, 
+                             step, levels[i] - 2 * LAMBDA, &oppositePoint);
+            cvRectangle(image, partsDisplacement[i][j], oppositePoint, 
+                        color, thickness, line_type, shift);
+        }
+    }
+#ifdef HAVE_OPENCV_HIGHGUI
+    cvShowImage("Initial image", image);
+#endif
+    return LATENT_SVM_OK;
+}
+
+/*
+// Drawing boxes
+//
+// API
+// int showBoxes(const IplImage *img, 
+                 const CvPoint *points, const CvPoint *oppositePoints, int kPoints, 
+                 CvScalar color, int thickness, int line_type, int shift);
+// INPUT
+// img               - initial image
+// points            - top left corner coordinates
+// oppositePoints    - right bottom corner coordinates
+// kPoints           - points number
+// color             - line color for each box
+// thickness         - line thickness
+// line_type         - line type
+// shift             - shift
+// OUTPUT
+// RESULT
+// Error status
+*/
+int showBoxes(IplImage *img, 
+              const CvPoint *points, const CvPoint *oppositePoints, int kPoints, 
+              CvScalar color, int thickness, int line_type, int shift)
+{
+    int i;
+    for (i = 0; i < kPoints; i++)
+    {
+        cvRectangle(img, points[i], oppositePoints[i], 
+                    color, thickness, line_type, shift);
+    }
+#ifdef HAVE_OPENCV_HIGHGUI
+    cvShowImage("Initial image", img);
+#endif
+    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;
+//}
+
+
+#ifdef HAVE_TBB
+
+class PathOfModel :public ParallelLoopBody{
+    int *componentIndex;
+    const CvLSVMFeaturePyramidCaskade *H;
+    const CvLSVMFeaturePyramidCaskade *H_PCA;
+    const CvLSVMFilterObjectCaskade **filters;
+    const int *kPartFilters;
+    const float *b;
+    unsigned int maxXBorder, maxYBorder;
+    CvPoint **pointsArr, **oppPointsArr, ***partsDisplacementArr;
+    float **scoreArr;
+    int *kPointsArr, **levelsArr;
+    float scoreThreshold;
+    CvPoint **oppPoints;
+public:
+    PathOfModel(
+      int *_componentIndex,
+    const CvLSVMFeaturePyramidCaskade *_H,
+    const CvLSVMFeaturePyramidCaskade *_H_PCA,
+    const CvLSVMFilterObjectCaskade **_filters,
+    const int *_kPartFilters,
+    const float *_b,
+    unsigned int _maxXBorder, unsigned int _maxYBorder,
+    CvPoint **_pointsArr, CvPoint  **_oppPointsArr, CvPoint  ***_partsDisplacementArr,
+    float **_scoreArr,
+    int *_kPointsArr, int **_levelsArr,
+    float _scoreThreshold,
+    CvPoint **_oppPoints
+    ):
+    componentIndex(_componentIndex),
+    H(_H),
+    H_PCA(_H_PCA),
+    filters(_filters),
+    kPartFilters(_kPartFilters),
+    b(_b),
+    maxXBorder(_maxXBorder),
+    maxYBorder(_maxYBorder),
+    pointsArr(_pointsArr),
+    oppPointsArr(_oppPointsArr),
+    partsDisplacementArr(_partsDisplacementArr),
+    scoreArr(_scoreArr),
+    kPointsArr(_kPointsArr),
+    levelsArr(_levelsArr),
+    scoreThreshold(_scoreThreshold),
+    oppPoints(_oppPoints)
+    {}
+
+    
+    void operator() (const Range& range) const
+    {
+        
+      for( int i=range.start; i!=range.end; ++i )
+        {
+          searchObjectThreshold(H, H_PCA, &(filters[componentIndex[i]]), kPartFilters[i],
+            b[i], maxXBorder, maxYBorder, scoreThreshold, 
+            &(pointsArr[i]), &(levelsArr[i]), &(kPointsArr[i]), 
+            &(scoreArr[i]), &(partsDisplacementArr[i]));
+          estimateBoxes(pointsArr[i], levelsArr[i], kPointsArr[i], 
+            filters[componentIndex[i]]->sizeX, filters[componentIndex[i]]->sizeY, &(oppPointsArr[i]));
+        }
+    }
+};
+
+#endif
+/*
+// Computation root filters displacement and values of score function
+//
+// API
+// int searchObjectThresholdSomeComponents(const featurePyramid *H,
+                                           const CvLSVMFilterObjectCaskade **filters, 
+                                           int kComponents, const int *kPartFilters,
+                                           const float *b, float scoreThreshold,
+                                           CvPoint **points, CvPoint **oppPoints,
+                                           float **score, int *kPoints);
+// INPUT
+// H                 - feature pyramid
+// filters           - filters (root filter then it's part filters, etc.)
+// kComponents       - root filters number
+// kPartFilters      - array of part filters number for each component
+// b                 - array of linear terms
+// scoreThreshold    - score threshold
+// OUTPUT
+// points            - root filters displacement (top left corners)
+// oppPoints         - root filters displacement (bottom right corners)
+// score             - array of score values
+// kPoints           - number of boxes
+// RESULT
+// Error status
+*/
+int searchObjectThresholdSomeComponents(const CvLSVMFeaturePyramidCaskade *H,
+                                        const CvLSVMFeaturePyramidCaskade *H_PCA,
+                                        const CvLSVMFilterObjectCaskade **filters, 
+                                        int kComponents, const int *kPartFilters,
+                                        const float *b, float scoreThreshold,
+                                        CvPoint **points, CvPoint **oppPoints,
+                                        float **score, int *kPoints)
+{
+    int i, j, s, f, *componentIndex;
+    unsigned int maxXBorder, maxYBorder;
+    CvPoint **pointsArr, **oppPointsArr, ***partsDisplacementArr;
+    float **scoreArr;
+    int *kPointsArr, **levelsArr;
+    int sum;
+    
+    // Allocation memory
+    pointsArr = (CvPoint **)malloc(sizeof(CvPoint *) * kComponents);
+    oppPointsArr = (CvPoint **)malloc(sizeof(CvPoint *) * kComponents);
+    scoreArr = (float **)malloc(sizeof(float *) * kComponents);
+    kPointsArr = (int *)malloc(sizeof(int) * kComponents);
+    levelsArr = (int **)malloc(sizeof(int *) * kComponents);
+    partsDisplacementArr = (CvPoint ***)malloc(sizeof(CvPoint **) * kComponents);
+    componentIndex = (int *)malloc(sizeof(int) * kComponents);
+    
+    // Getting maximum filter dimensions
+    getMaxFilterDims(filters, kComponents, kPartFilters, &maxXBorder, &maxYBorder);
+    *kPoints = 0;
+    sum = 0;
+    componentIndex[0] = 0;
+    for (i = 1; i < kComponents; i++)
+    {
+        componentIndex[i] = componentIndex[i - 1] + (kPartFilters[i - 1] + 1);
+    }
+    // For each component perform searching
+//#pragma omp parallel for schedule(dynamic) reduction(+ : sum) 
+#ifdef HAVE_TBB
+    PathOfModel POM(
+      componentIndex,
+      H,
+      H_PCA,
+      filters,
+      kPartFilters,
+      b,
+      maxXBorder,
+      maxYBorder,
+      pointsArr,
+      oppPointsArr,
+      partsDisplacementArr,
+      scoreArr,
+      kPointsArr,
+      levelsArr,
+      scoreThreshold,
+      oppPoints);
+    cv::parallel_for_( Range( 0, kComponents ), POM);
+#else
+    for (i = 0; i < kComponents; i++)
+    {
+        searchObjectThreshold(H, H_PCA, &(filters[componentIndex[i]]), kPartFilters[i],
+            b[i], maxXBorder, maxYBorder, scoreThreshold, 
+            &(pointsArr[i]), &(levelsArr[i]), &(kPointsArr[i]), 
+            &(scoreArr[i]), &(partsDisplacementArr[i]));
+        estimateBoxes(pointsArr[i], levelsArr[i], kPointsArr[i], 
+            filters[componentIndex[i]]->sizeX, filters[componentIndex[i]]->sizeY, &(oppPointsArr[i]));
+    }
+#endif
+    for (i = 0; i < kComponents; i++)
+    {    
+        //*kPoints += kPointsArr[i];
+        sum += kPointsArr[i];
+    } 
+    *kPoints = sum;
+    *points = (CvPoint *)malloc(sizeof(CvPoint) * (*kPoints));
+    *oppPoints = (CvPoint *)malloc(sizeof(CvPoint) * (*kPoints));
+    *score = (float *)malloc(sizeof(float) * (*kPoints));
+
+    //file = fopen("point.txt", "w");
+    s = 0;
+    for (i = 0; i < kComponents; i++)
+    {
+        f = s + kPointsArr[i];
+        for (j = s; j < f; j++)
+        {
+            (*points)[j].x = pointsArr[i][j - s].x;
+            (*points)[j].y = pointsArr[i][j - s].y;
+            (*oppPoints)[j].x = oppPointsArr[i][j - s].x;
+            (*oppPoints)[j].y = oppPointsArr[i][j - s].y;
+            (*score)[j] = scoreArr[i][j - s];
+      //      fprintf(file, "%d %d %d %d %f\n", (*points)[j].x, (*points)[j].y,
+      //          (*oppPoints)[j].x, (*oppPoints)[j].y, (*score)[j]);
+        }
+        s = f;
+    }
+    //fclose(file);
+
+    // Release allocated memory
+    for (i = 0; i < kComponents; i++)
+    {
+        free(pointsArr[i]);
+        free(oppPointsArr[i]);
+        free(scoreArr[i]);
+        free(levelsArr[i]);
+        for (j = 0; j < kPointsArr[i]; j++)
+        {
+            free(partsDisplacementArr[i][j]);
+        }
+        free(partsDisplacementArr[i]);
+    }
+    free(pointsArr);
+    free(oppPointsArr);
+    free(scoreArr);
+    free(kPointsArr);
+    free(levelsArr);
+    free(partsDisplacementArr);
+    free(componentIndex);
+    return LATENT_SVM_OK;
+}
+}
+}

modules/latentsvm/src/lsvmc_latentsvmdetector.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_parser.h"
+#include "_lsvmc_matching.h"
+namespace cv
+{
+namespace lsvm
+{
+
+std::string extractModelName( const std::string& filename );
+
+const int pca_size = 31;
+
+CvLatentSvmDetectorCaskade* cvLoadLatentSvmDetectorCaskade(const char* filename);
+void cvReleaseLatentSvmDetectorCaskade(CvLatentSvmDetectorCaskade** detector);
+CvSeq* cvLatentSvmDetectObjectsCaskade(IplImage* image,
+                                CvLatentSvmDetectorCaskade* detector,
+                                CvMemStorage* storage,
+                                float overlap_threshold);
+
+/*
+// load trained detector from a file
+//
+// API
+// CvLatentSvmDetectorCaskade* 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
+*/
+CvLatentSvmDetectorCaskade* cvLoadLatentSvmDetectorCaskade(const char* filename)
+{
+    CvLatentSvmDetectorCaskade* detector = 0;
+    CvLSVMFilterObjectCaskade** filters = 0;
+    int kFilters = 0;
+    int kComponents = 0;
+    int* kPartFilters = 0;
+    float* b = 0;
+    float scoreThreshold = 0.f;
+    int err_code = 0;
+	float* PCAcoeff = 0;
+
+    err_code = loadModel(filename, &filters, &kFilters, &kComponents, &kPartFilters, &b, &scoreThreshold, &PCAcoeff);
+    if (err_code != LATENT_SVM_OK) return 0;
+
+    detector = (CvLatentSvmDetectorCaskade*)malloc(sizeof(CvLatentSvmDetectorCaskade));
+    detector->filters = filters;
+    detector->b = b;
+    detector->num_components = kComponents;
+    detector->num_filters = kFilters;
+    detector->num_part_filters = kPartFilters;
+    detector->score_threshold = scoreThreshold;
+	  detector->pca = PCAcoeff;
+    detector->pca_size = pca_size;
+
+    return detector;
+}
+
+/*
+// release memory allocated for CvLatentSvmDetectorCaskade structure
+//
+// API
+// void cvReleaseLatentSvmDetector(CvLatentSvmDetectorCaskade** detector);
+// INPUT
+// detector             - CvLatentSvmDetectorCaskade structure to be released
+// OUTPUT
+*/
+void cvReleaseLatentSvmDetectorCaskade(CvLatentSvmDetectorCaskade** detector)
+{
+    free((*detector)->b);
+    free((*detector)->num_part_filters);
+    for (int i = 0; i < (*detector)->num_filters; i++)
+    {
+        free((*detector)->filters[i]->H);
+        free((*detector)->filters[i]);
+    }
+    free((*detector)->filters);
+	free((*detector)->pca);
+    free((*detector));
+    *detector = 0;
+}
+
+/*
+// find rectangular regions in the given image that are likely
+// to contain objects and corresponding confidence levels
+//
+// API
+// CvSeq* cvLatentSvmDetectObjects(const IplImage* image,
+//                                  CvLatentSvmDetectorCaskade* 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 [here will be the reference to original paper]
+// OUTPUT
+// sequence of detected objects (bounding boxes and confidence levels stored in CvObjectDetection structures)
+*/
+CvSeq* cvLatentSvmDetectObjectsCaskade(IplImage* image,
+                                CvLatentSvmDetectorCaskade* detector,
+                                CvMemStorage* storage,
+                                float overlap_threshold)
+{
+    CvLSVMFeaturePyramidCaskade *H = 0;
+	CvLSVMFeaturePyramidCaskade *H_PCA = 0;
+    CvPoint *points = 0, *oppPoints = 0;
+    int kPoints = 0;
+    float *score = 0;
+    unsigned int maxXBorder = 0, maxYBorder = 0;
+    int numBoxesOut = 0;
+    CvPoint *pointsOut = 0;
+    CvPoint *oppPointsOut = 0;
+    float *scoreOut = 0;
+    CvSeq* result_seq = 0;
+    int error = 0;
+
+    if(image->nChannels == 3)
+        cvCvtColor(image, image, CV_BGR2RGB);
+
+    // Getting maximum filter dimensions
+    getMaxFilterDims((const CvLSVMFilterObjectCaskade**)(detector->filters), detector->num_components,
+                     detector->num_part_filters, &maxXBorder, &maxYBorder);
+    // Create feature pyramid with nullable border
+    H = createFeaturePyramidWithBorder(image, maxXBorder, maxYBorder);
+	
+	// Create PSA feature pyramid
+    H_PCA = createPCA_FeaturePyramid(H, detector, maxXBorder, maxYBorder);
+    
+    FeaturePyramid32(H, maxXBorder, maxYBorder);
+	
+    // Search object
+    error = searchObjectThresholdSomeComponents(H, H_PCA,(const CvLSVMFilterObjectCaskade**)(detector->filters),
+        detector->num_components, detector->num_part_filters, detector->b, detector->score_threshold,
+        &points, &oppPoints, &score, &kPoints);
+    if (error != LATENT_SVM_OK)
+    {
+        return NULL;
+    }
+    // Clipping boxes
+    clippingBoxes(image->width, image->height, points, kPoints);
+    clippingBoxes(image->width, image->height, oppPoints, kPoints);
+    // NMS procedure
+    nonMaximumSuppression(kPoints, points, oppPoints, score, overlap_threshold,
+                &numBoxesOut, &pointsOut, &oppPointsOut, &scoreOut);
+
+    result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvObjectDetection), storage );
+
+    for (int i = 0; i < numBoxesOut; i++)
+    {
+        CvObjectDetection detection;
+        detection.score = scoreOut[i];
+        detection.rect.x = pointsOut[i].x;
+        detection.rect.y = pointsOut[i].y;
+        detection.rect.width = oppPointsOut[i].x - pointsOut[i].x;
+        detection.rect.height = oppPointsOut[i].y - pointsOut[i].y;
+        cvSeqPush(result_seq, &detection);
+    }
+
+    if(image->nChannels == 3)
+        cvCvtColor(image, image, CV_RGB2BGR);
+
+    freeFeaturePyramidObject(&H);
+	freeFeaturePyramidObject(&H_PCA);
+    free(points);
+    free(oppPoints);
+    free(score);
+
+    return result_seq;
+}
+
+class LSVMDetectorImpl : public LSVMDetector
+{
+public:
+
+    LSVMDetectorImpl( const std::vector<std::string>& filenames, const std::vector<std::string>& classNames=std::vector<std::string>() );
+    ~LSVMDetectorImpl();
+
+    bool isEmpty() const;
+
+    void detect(cv::Mat const &image, CV_OUT std::vector<ObjectDetection>& objects, float overlapThreshold=0.5f);
+
+    const std::vector<std::string>& getClassNames() const;
+    size_t getClassCount() const;
+
+private:
+    std::vector<CvLatentSvmDetectorCaskade*> detectors;
+    std::vector<std::string> classNames;
+};
+
+cv::Ptr<LSVMDetector> LSVMDetector::create(std::vector<std::string> const &filenames,
+                                     std::vector<std::string> const &classNames)
+{
+    return cv::makePtr<LSVMDetectorImpl>(filenames, classNames);
+}
+
+LSVMDetectorImpl::ObjectDetection::ObjectDetection() : score(0.f), classID(-1) {}
+
+LSVMDetectorImpl::ObjectDetection::ObjectDetection( const Rect& _rect, float _score, int _classID ) :
+    rect(_rect), score(_score), classID(_classID) {}
+
+
+LSVMDetectorImpl::LSVMDetectorImpl( const std::vector<std::string>& filenames, const std::vector<std::string>& _classNames )
+{
+    for( size_t i = 0; i < filenames.size(); i++ )
+    {
+        const std::string filename = filenames[i];
+        if( filename.length() < 5 || filename.substr(filename.length()-4, 4) != ".xml" )
+            continue;
+
+        CvLatentSvmDetectorCaskade* detector = cvLoadLatentSvmDetectorCaskade( filename.c_str() );
+        if( detector )
+        {
+            detectors.push_back( detector );
+            if( _classNames.empty() )
+            {
+                classNames.push_back( extractModelName(filenames[i]) );
+            }
+            else
+                classNames.push_back( _classNames[i] );
+        }
+    }
+}
+
+LSVMDetectorImpl::~LSVMDetectorImpl()
+{
+    for(size_t i = 0; i < detectors.size(); i++)
+      cv::lsvm::cvReleaseLatentSvmDetectorCaskade(&detectors[i]);
+}
+
+bool LSVMDetectorImpl::isEmpty() const
+{
+    return detectors.empty();
+}
+
+const std::vector<std::string>& LSVMDetectorImpl::getClassNames() const
+{
+    return classNames;
+}
+
+size_t LSVMDetectorImpl::getClassCount() const
+{
+    return classNames.size();
+}
+
+std::string extractModelName( const std::string& filename )
+{
+    size_t startPos = filename.rfind('/');
+    if( startPos == std::string::npos )
+        startPos = filename.rfind('\\');
+
+    if( startPos == std::string::npos )
+        startPos = 0;
+    else
+        startPos++;
+
+    const int extentionSize = 4; //.xml
+
+    int substrLength = (int)(filename.size() - startPos - extentionSize);
+
+    return filename.substr(startPos, substrLength);
+}
+
+void LSVMDetectorImpl::detect( cv::Mat const &image,
+                               std::vector<ObjectDetection> &objectDetections,
+                               float overlapThreshold)
+{
+    objectDetections.clear();
+    
+    for( size_t classID = 0; classID < detectors.size(); classID++ )
+    {
+        IplImage image_ipl = image;
+        CvMemStorage* storage = cvCreateMemStorage(0);
+        CvSeq* detections = cv::lsvm::cvLatentSvmDetectObjectsCaskade( &image_ipl, (CvLatentSvmDetectorCaskade*)(detectors[classID]), storage, overlapThreshold);
+
+        // convert results
+        objectDetections.reserve( objectDetections.size() + detections->total );
+        for( int detectionIdx = 0; detectionIdx < detections->total; detectionIdx++ )
+        {
+            CvObjectDetection detection = *(CvObjectDetection*)cvGetSeqElem( detections, detectionIdx );
+            objectDetections.push_back( ObjectDetection(Rect(detection.rect), detection.score, (int)classID) );
+        }
+
+        cvReleaseMemStorage( &storage );
+    }
+}
+
+} // namespace cv
+}

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_parser.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 <stdio.h>
+#include "string.h"
+#include "_lsvmc_parser.h"
+#include "_lsvmc_error.h"
+
+namespace cv
+{
+namespace lsvm
+{
+
+int isMODEL        (char *str);
+int isP            (char *str);
+int isSCORE        (char *str);
+int isCOMP         (char *str);
+int isRFILTER      (char *str);
+int isPFILTERs     (char *str);
+int isPFILTER      (char *str);
+int isSIZEX        (char *str);
+int isSIZEY        (char *str);
+int isWEIGHTS      (char *str);
+int isV            (char *str);
+int isVx           (char *str);
+int isVy           (char *str);
+int isD            (char *str);
+int isDx           (char *str);
+int isDy           (char *str);
+int isDxx          (char *str);
+int isDyy          (char *str);
+int isB            (char *str);
+int isWEIGHTS_PCA  (char *str);
+int isPCA          (char *str);
+int isPCAcoeff     (char *str);
+int isCASCADE_Th   (char *str);
+int isHYPOTHES_PCA (char *str);
+int isDEFORM_PCA   (char *str);
+int isHYPOTHES     (char *str);
+int isDEFORM       (char *str);
+int getTeg         (char *str);
+
+void addFilter(CvLSVMFilterObjectCaskade *** model, int *last, int *max);
+
+void parserCascadeThresholds  (FILE * xmlf, CvLSVMFilterObjectCaskade * model);
+
+void parserRFilter  (FILE * xmlf, int p, int pca, CvLSVMFilterObjectCaskade * model, float *b);
+
+void parserV  (FILE * xmlf, int /*p*/, CvLSVMFilterObjectCaskade * model);
+
+void parserD  (FILE * xmlf, int /*p*/, CvLSVMFilterObjectCaskade * model);
+
+void parserPFilter  (FILE * xmlf, int p, int pca, int /*N_path*/, CvLSVMFilterObjectCaskade * model);
+
+void parserPFilterS (FILE * xmlf, int p, int pca, CvLSVMFilterObjectCaskade *** model, int *last, int *max);
+
+void parserComp (FILE * xmlf, int p, int pca, int *N_comp, CvLSVMFilterObjectCaskade *** model, float *b, int *last, int *max);
+
+void parserModel(FILE * xmlf, CvLSVMFilterObjectCaskade *** model, int *last, int *max, int **comp, float **b, int *count, float * score, float** PCAcoeff);
+
+void LSVMparser(const char * filename,
+                CvLSVMFilterObjectCaskade *** model,
+                int *last,
+                int *max,
+                int **comp,
+                float **b,
+                int *count,
+                float * score,
+                float** PCAcoeff);
+
+int isMODEL    (char *str){
+    char stag [] = "<Model>";
+    char etag [] = "</Model>";
+    if(strcmp(stag, str) == 0)return  MODEL;
+    if(strcmp(etag, str) == 0)return EMODEL;
+    return 0;
+}
+int isP        (char *str){
+    char stag [] = "<P>";
+    char etag [] = "</P>";
+    if(strcmp(stag, str) == 0)return  P;
+    if(strcmp(etag, str) == 0)return EP;
+    return 0;
+}
+int isSCORE        (char *str){
+    char stag [] = "<ScoreThreshold>";
+    char etag [] = "</ScoreThreshold>";
+    if(strcmp(stag, str) == 0)return  SCORE;
+    if(strcmp(etag, str) == 0)return ESCORE;
+    return 0;
+}
+int isCOMP     (char *str){
+    char stag [] = "<Component>";
+    char etag [] = "</Component>";
+    if(strcmp(stag, str) == 0)return  COMP;
+    if(strcmp(etag, str) == 0)return ECOMP;
+    return 0;
+}
+int isRFILTER  (char *str){
+    char stag [] = "<RootFilter>";
+    char etag [] = "</RootFilter>";
+    if(strcmp(stag, str) == 0)return  RFILTER;
+    if(strcmp(etag, str) == 0)return ERFILTER;
+    return 0;
+}
+int isPFILTERs (char *str){
+    char stag [] = "<PartFilters>";
+    char etag [] = "</PartFilters>";
+    if(strcmp(stag, str) == 0)return  PFILTERs;
+    if(strcmp(etag, str) == 0)return EPFILTERs;
+    return 0;
+}
+int isPFILTER  (char *str){
+    char stag [] = "<PartFilter>";
+    char etag [] = "</PartFilter>";
+    if(strcmp(stag, str) == 0)return  PFILTER;
+    if(strcmp(etag, str) == 0)return EPFILTER;
+    return 0;
+}
+int isSIZEX    (char *str){
+    char stag [] = "<sizeX>";
+    char etag [] = "</sizeX>";
+    if(strcmp(stag, str) == 0)return  SIZEX;
+    if(strcmp(etag, str) == 0)return ESIZEX;
+    return 0;
+}
+int isSIZEY    (char *str){
+    char stag [] = "<sizeY>";
+    char etag [] = "</sizeY>";
+    if(strcmp(stag, str) == 0)return  SIZEY;
+    if(strcmp(etag, str) == 0)return ESIZEY;
+    return 0;
+}
+int isWEIGHTS  (char *str){
+    char stag [] = "<Weights>";
+    char etag [] = "</Weights>";
+    if(strcmp(stag, str) == 0)return  WEIGHTS;
+    if(strcmp(etag, str) == 0)return EWEIGHTS;
+    return 0;
+}
+int isV        (char *str){
+    char stag [] = "<V>";
+    char etag [] = "</V>";
+    if(strcmp(stag, str) == 0)return  TAGV;
+    if(strcmp(etag, str) == 0)return ETAGV;
+    return 0;
+}
+int isVx       (char *str){
+    char stag [] = "<Vx>";
+    char etag [] = "</Vx>";
+    if(strcmp(stag, str) == 0)return  Vx;
+    if(strcmp(etag, str) == 0)return EVx;
+    return 0;
+}
+int isVy       (char *str){
+    char stag [] = "<Vy>";
+    char etag [] = "</Vy>";
+    if(strcmp(stag, str) == 0)return  Vy;
+    if(strcmp(etag, str) == 0)return EVy;
+    return 0;
+}
+int isD        (char *str){
+    char stag [] = "<Penalty>";
+    char etag [] = "</Penalty>";
+    if(strcmp(stag, str) == 0)return  TAGD;
+    if(strcmp(etag, str) == 0)return ETAGD;
+    return 0;
+}
+int isDx       (char *str){
+    char stag [] = "<dx>";
+    char etag [] = "</dx>";
+    if(strcmp(stag, str) == 0)return  Dx;
+    if(strcmp(etag, str) == 0)return EDx;
+    return 0;
+}
+int isDy       (char *str){
+    char stag [] = "<dy>";
+    char etag [] = "</dy>";
+    if(strcmp(stag, str) == 0)return  Dy;
+    if(strcmp(etag, str) == 0)return EDy;
+    return 0;
+}
+int isDxx      (char *str){
+    char stag [] = "<dxx>";
+    char etag [] = "</dxx>";
+    if(strcmp(stag, str) == 0)return  Dxx;
+    if(strcmp(etag, str) == 0)return EDxx;
+    return 0;
+}
+int isDyy      (char *str){
+    char stag [] = "<dyy>";
+    char etag [] = "</dyy>";
+    if(strcmp(stag, str) == 0)return  Dyy;
+    if(strcmp(etag, str) == 0)return EDyy;
+    return 0;
+}
+int isB      (char *str){
+    char stag [] = "<LinearTerm>";
+    char etag [] = "</LinearTerm>";
+    if(strcmp(stag, str) == 0)return  BTAG;
+    if(strcmp(etag, str) == 0)return EBTAG;
+    return 0;
+}
+
+int isWEIGHTS_PCA  (char *str){
+    char stag [] = "<WeightsPCA>";
+    char etag [] = "</WeightsPCA>";
+    if(strcmp(stag, str) == 0)return  WEIGHTSPCA;
+    if(strcmp(etag, str) == 0)return EWEIGHTSPCA;
+    return 0;
+}
+
+int isPCA  (char *str){
+    char stag [] = "<PCA>";
+    char etag [] = "</PCA>";
+    if(strcmp(stag, str) == 0)return  PCA;
+    if(strcmp(etag, str) == 0)return EPCA;
+    return 0;
+}
+
+int isPCAcoeff  (char *str){
+    char stag [] = "<PCAcoeff>";
+    char etag [] = "</PCAcoeff>";
+    if(strcmp(stag, str) == 0)return  PCACOEFF;
+    if(strcmp(etag, str) == 0)return EPCACOEFF;
+    return 0;
+}
+
+int isCASCADE_Th  (char *str){
+    char stag [] = "<CascadeThresholds>";
+    char etag [] = "</CascadeThresholds>";
+    if(strcmp(stag, str) == 0)return  CASCADE_Th;
+    if(strcmp(etag, str) == 0)return ECASCADE_Th;
+    return 0;
+}
+
+int isHYPOTHES_PCA  (char *str){
+    char stag [] = "<HypothesisThresholdPCA>";
+    char etag [] = "</HypothesisThresholdPCA>";
+    if(strcmp(stag, str) == 0)return  HYPOTHES_PCA;
+    if(strcmp(etag, str) == 0)return EHYPOTHES_PCA;
+    return 0;
+}
+int isDEFORM_PCA  (char *str){
+    char stag [] = "<DeformationThresholdPCA>";
+    char etag [] = "</DeformationThresholdPCA>";
+    if(strcmp(stag, str) == 0)return  DEFORM_PCA;
+    if(strcmp(etag, str) == 0)return EDEFORM_PCA;
+    return 0;
+}
+int isHYPOTHES  (char *str){
+    char stag [] = "<HypothesisThreshold>";
+    char etag [] = "</HypothesisThreshold>";
+    if(strcmp(stag, str) == 0)return  HYPOTHES;
+    if(strcmp(etag, str) == 0)return EHYPOTHES;
+    return 0;
+}
+int isDEFORM  (char *str){
+    char stag [] = "<DeformationThreshold>";
+    char etag [] = "</DeformationThreshold>";
+    if(strcmp(stag, str) == 0)return  DEFORM;
+    if(strcmp(etag, str) == 0)return EDEFORM;
+    return 0;
+}
+
+int getTeg(char *str){
+    int sum = 0;
+    sum = isMODEL (str)+
+    isP        (str)+
+    isSCORE    (str)+
+    isCOMP     (str)+
+    isRFILTER  (str)+
+    isPFILTERs (str)+
+    isPFILTER  (str)+
+    isSIZEX    (str)+
+    isSIZEY    (str)+
+    isWEIGHTS  (str)+
+    isV        (str)+
+    isVx       (str)+
+    isVy       (str)+
+    isD        (str)+
+    isDx       (str)+
+    isDy       (str)+
+    isDxx      (str)+
+    isDyy      (str)+
+    isB        (str)+
+    isPCA         (str)+
+    isCASCADE_Th  (str)+
+    isHYPOTHES_PCA(str)+
+    isDEFORM_PCA  (str)+
+    isHYPOTHES    (str)+
+    isDEFORM      (str)+
+    isWEIGHTS_PCA (str)+
+    isPCAcoeff    (str)
+    ;
+
+    return sum;
+}
+
+void addFilter(CvLSVMFilterObjectCaskade *** model, int *last, int *max)
+{
+    CvLSVMFilterObjectCaskade ** nmodel;
+    int i;
+    (*last) ++;
+    if((*last) >= (*max)){
+        (*max) += 10;
+        nmodel = (CvLSVMFilterObjectCaskade **)malloc(sizeof(CvLSVMFilterObjectCaskade *) * (*max));
+        for(i = 0; i < *last; i++){
+            nmodel[i] = (* model)[i];
+        }
+        free(* model);
+        (*model) = nmodel;
+    }
+    (*model) [(*last)] = (CvLSVMFilterObjectCaskade *)malloc(sizeof(CvLSVMFilterObjectCaskade));
+    (*model) [(*last)]->Hypothesis      = 0.0f;
+    (*model) [(*last)]->Deformation     = 0.0f;
+    (*model) [(*last)]->Hypothesis_PCA  = 0.0f;
+    (*model) [(*last)]->Deformation_PCA = 0.0f;
+
+}
+
+//##############################################
+void parserCascadeThresholds  (FILE * xmlf, CvLSVMFilterObjectCaskade * model){
+    int st = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int i,j;
+    char buf[1024];
+    char tagBuf[1024];
+    
+    i   = 0;
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char) fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == ECASCADE_Th){
+                    return;
+                }
+                if(tagVal == HYPOTHES_PCA){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EHYPOTHES_PCA){
+                    st = 0;
+                    buf[i] = '\0';
+                    model->Hypothesis_PCA =(float) atof(buf);
+                }
+                if(tagVal == DEFORM_PCA){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EDEFORM_PCA){
+                    st = 0;
+                    buf[i] = '\0';
+                    model->Deformation_PCA =(float) atof(buf);
+                }
+                if(tagVal == HYPOTHES){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EHYPOTHES){
+                    st = 0;
+                    buf[i] = '\0';
+                    model->Hypothesis = (float)atof(buf);
+                }
+                if(tagVal == DEFORM){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EDEFORM){
+                    st = 0;
+                    buf[i] = '\0';
+                    model->Deformation = (float)atof(buf);
+                }
+                tag = 0;
+                i   = 0;                
+            }else{
+                if((tag == 0)&& (st == 1)){
+                    buf[i] = ch; i++;
+                }else{
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+//##############################################
+
+void parserRFilter  (FILE * xmlf, int p, int pca, CvLSVMFilterObjectCaskade * model, float *b){
+    int st = 0;
+    int sizeX = 0, sizeY = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int i,j,ii;
+    char buf[1024];
+    char tagBuf[1024];
+    double *data;
+    //printf("<RootFilter>\n");
+
+    model->V.x = 0;
+    model->V.y = 0;
+    model->V.l = 0;
+    model->fineFunction[0] = 0.0;
+    model->fineFunction[1] = 0.0;
+    model->fineFunction[2] = 0.0;
+    model->fineFunction[3] = 0.0;
+
+    i   = 0;
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char)fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == ERFILTER){
+                    //printf("</RootFilter>\n");
+                    return;
+                }
+                if(tagVal == SIZEX){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == ESIZEX){
+                    st = 0;
+                    buf[i] = '\0';
+                    sizeX = atoi(buf);
+                    model->sizeX = sizeX;
+                    //printf("<sizeX>%d</sizeX>\n", sizeX);
+                }
+                if(tagVal == SIZEY){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == ESIZEY){
+                    st = 0;
+                    buf[i] = '\0';
+                    sizeY = atoi(buf);
+                    model->sizeY = sizeY;
+                    //printf("<sizeY>%d</sizeY>\n", sizeY);
+                }
+                if(tagVal == WEIGHTS){
+                    data = (double *)malloc( sizeof(double) * p * sizeX * sizeY);
+                    CV_Assert(fread(data, sizeof(double), p * sizeX * sizeY, xmlf));
+                    model->H = (float *)malloc(sizeof(float)* p * sizeX * sizeY);
+                    for(ii = 0; ii < p * sizeX * sizeY; ii++){
+                        model->H[ii] = (float)data[ii];
+                    }
+                    free(data);
+                }
+                if(tagVal == WEIGHTSPCA){
+                    data = (double *)malloc( sizeof(double) * pca * sizeX * sizeY);
+                    CV_Assert(fread(data, sizeof(double), pca * sizeX * sizeY, xmlf));
+                    model->H_PCA = (float *)malloc(sizeof(float)* pca * sizeX * sizeY);
+                    for(ii = 0; ii < pca * sizeX * sizeY; ii++){
+                        model->H_PCA[ii] = (float)data[ii];
+                    }
+                    free(data);
+                }
+
+                if(tagVal == CASCADE_Th){
+                    parserCascadeThresholds  (xmlf, model);
+                }
+
+                if(tagVal == BTAG){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EBTAG){
+                    st = 0;
+                    buf[i] = '\0';
+                    *b =(float) atof(buf);
+                    //printf("<B>%f</B>\n", *b);
+                }
+
+                tag = 0;
+                i   = 0;                
+            }else{
+                if((tag == 0)&& (st == 1)){
+                    buf[i] = ch; i++;
+                }else{
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+
+void parserV  (FILE * xmlf, int /*p*/, CvLSVMFilterObjectCaskade * model){
+    int st = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int i,j;
+    char buf[1024];
+    char tagBuf[1024];
+    //printf("    <V>\n");
+
+    i   = 0;
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char) fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == ETAGV){
+                    //printf("    </V>\n");
+                    return;
+                }
+                if(tagVal == Vx){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EVx){
+                    st = 0;
+                    buf[i] = '\0';
+                    model->V.x = atoi(buf);
+                    //printf("        <Vx>%d</Vx>\n", model->V.x);
+                }
+                if(tagVal == Vy){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EVy){
+                    st = 0;
+                    buf[i] = '\0';
+                    model->V.y = atoi(buf);
+                    //printf("        <Vy>%d</Vy>\n", model->V.y);
+                }
+                tag = 0;
+                i   = 0;                
+            }else{
+                if((tag == 0)&& (st == 1)){
+                    buf[i] = ch; i++;
+                }else{
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+void parserD  (FILE * xmlf, int /*p*/, CvLSVMFilterObjectCaskade * model){
+    int st = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int i,j;
+    char buf[1024];
+    char tagBuf[1024];
+    //printf("    <D>\n");
+
+    i   = 0;
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char)fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == ETAGD){
+                    //printf("    </D>\n");
+                    return;
+                }
+                if(tagVal == Dx){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EDx){
+                    st = 0;
+                    buf[i] = '\0';
+                    
+                    model->fineFunction[0] = (float)atof(buf);
+                    //printf("        <Dx>%f</Dx>\n", model->fineFunction[0]);
+                }
+                if(tagVal == Dy){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EDy){
+                    st = 0;
+                    buf[i] = '\0';
+                    
+                    model->fineFunction[1] = (float)atof(buf);
+                    //printf("        <Dy>%f</Dy>\n", model->fineFunction[1]);
+                }
+                if(tagVal == Dxx){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EDxx){
+                    st = 0;
+                    buf[i] = '\0';
+                    
+                    model->fineFunction[2] = (float)atof(buf);
+                    //printf("        <Dxx>%f</Dxx>\n", model->fineFunction[2]);
+                }
+                if(tagVal == Dyy){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EDyy){
+                    st = 0;
+                    buf[i] = '\0';
+                    
+                    model->fineFunction[3] = (float)atof(buf);
+                    //printf("        <Dyy>%f</Dyy>\n", model->fineFunction[3]);
+                }
+
+                tag = 0;
+                i   = 0;                
+            }else{
+                if((tag == 0)&& (st == 1)){
+                    buf[i] = ch; i++;
+                }else{
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+
+void parserPFilter  (FILE * xmlf, int p, int pca, int /*N_path*/, CvLSVMFilterObjectCaskade * model){
+    int st = 0;
+    int sizeX = 0, sizeY = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int i,j, ii;
+    char buf[1024];
+    char tagBuf[1024];
+    double *data;
+    //printf("<PathFilter> (%d)\n", N_path);
+
+    model->V.x = 0;
+    model->V.y = 0;
+    model->V.l = 0;
+    model->fineFunction[0] = 0.0f;
+    model->fineFunction[1] = 0.0f;
+    model->fineFunction[2] = 0.0f;
+    model->fineFunction[3] = 0.0f;
+
+    i   = 0;
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char)fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == EPFILTER){
+                    //printf("</PathFilter>\n");
+                    return;
+                }
+
+                if(tagVal == TAGV){
+                    parserV(xmlf, p, model);
+                }
+                if(tagVal == TAGD){
+                    parserD(xmlf, p, model);
+                }
+                if(tagVal == SIZEX){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == ESIZEX){
+                    st = 0;
+                    buf[i] = '\0';
+                    sizeX = atoi(buf);
+                    model->sizeX = sizeX;
+                    //printf("<sizeX>%d</sizeX>\n", sizeX);
+                }
+                if(tagVal == SIZEY){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == ESIZEY){
+                    st = 0;
+                    buf[i] = '\0';
+                    sizeY = atoi(buf);
+                    model->sizeY = sizeY;
+                    //printf("<sizeY>%d</sizeY>\n", sizeY);
+                }
+                if(tagVal == WEIGHTS){
+                    data = (double *)malloc( sizeof(double) * p * sizeX * sizeY);
+                    CV_Assert(fread(data, sizeof(double), p * sizeX * sizeY, xmlf));
+                    model->H = (float *)malloc(sizeof(float)* p * sizeX * sizeY);
+                    for(ii = 0; ii < p * sizeX * sizeY; ii++){
+                        model->H[ii] = (float)data[ii];
+                    }
+                    free(data);
+                }
+                if(tagVal == WEIGHTSPCA){
+                    data = (double *)malloc( sizeof(double) * pca * sizeX * sizeY);
+                    CV_Assert(fread(data, sizeof(double), pca * sizeX * sizeY, xmlf));
+                    model->H_PCA = (float *)malloc(sizeof(float)* pca * sizeX * sizeY);
+                    for(ii = 0; ii < pca * sizeX * sizeY; ii++){
+                        model->H_PCA[ii] = (float)data[ii];
+                    }
+                    free(data);
+                }
+                if(tagVal == CASCADE_Th){
+                    parserCascadeThresholds  (xmlf, model);
+                }
+                if(tagVal == EWEIGHTS){
+                    //printf("WEIGHTS OK\n");
+                }
+                tag = 0;
+                i   = 0;                
+            }else{
+                if((tag == 0)&& (st == 1)){
+                    buf[i] = ch; i++;
+                }else{
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+void parserPFilterS (FILE * xmlf, int p, int pca, CvLSVMFilterObjectCaskade *** model, int *last, int *max){
+    int st = 0;
+    int N_path = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int j;
+    char tagBuf[1024];
+    //printf("<PartFilters>\n");
+
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char)fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == EPFILTERs){
+                    //printf("</PartFilters>\n");
+                    return;
+                }
+                if(tagVal == PFILTER){
+                    addFilter(model, last, max);
+                    parserPFilter  (xmlf, p, pca, N_path, (*model)[*last]);
+                    N_path++;
+                }
+                tag = 0;              
+            }else{
+                if((tag != 0) || (st != 1)){
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+void parserComp (FILE * xmlf, int p, int pca, int *N_comp, CvLSVMFilterObjectCaskade *** model, float *b, int *last, int *max){
+    int st = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int j;
+    char tagBuf[1024];
+    //printf("<Component> %d\n", *N_comp);
+
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char)fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == ECOMP){
+                    (*N_comp) ++;
+                    return;
+                }
+                if(tagVal == RFILTER){
+                    addFilter(model, last, max);
+                    parserRFilter   (xmlf, p, pca, (*model)[*last],b);
+                }
+                if(tagVal == PFILTERs){
+                    parserPFilterS  (xmlf, p, pca, model, last, max);
+                }
+                tag = 0;              
+            }else{
+                if((tag != 0) || (st != 1)){
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+void parserModel(FILE * xmlf, CvLSVMFilterObjectCaskade *** model, int *last, int *max, int **comp, float **b, int *count, float * score, float** PCAcoeff){
+    int p = 0, pca = 0;
+    int N_comp = 0;
+    int * cmp;
+    float *bb;
+    int st = 0;
+    int tag;
+    int tagVal;
+    char ch;
+    int i,j, ii = 0, jj;
+    char buf[1024];
+    char tagBuf[1024];
+    double *data;
+    //printf("<Model>\n");
+    
+    i   = 0;
+    j   = 0;
+    st  = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char)fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                
+                tagVal = getTeg(tagBuf);
+               
+                if(tagVal == EMODEL){
+                    //printf("</Model>\n");
+                    for(ii = 0; ii <= *last; ii++){
+                        (*model)[ii]->numFeatures = p;
+                    }
+                    * count = N_comp;
+                    return;
+                }
+                if(tagVal == COMP){
+                    if(N_comp == 0){
+                        cmp = (int   *)malloc(sizeof(int));
+                        bb  = (float *)malloc(sizeof(float));
+                        * comp = cmp;
+                        * b    = bb;
+                        * count = N_comp + 1; 
+                    } else {
+                        cmp = (int   *)malloc(sizeof(int)   * (N_comp + 1));
+                        bb  = (float *)malloc(sizeof(float) * (N_comp + 1));
+                        for(ii = 0; ii < N_comp; ii++){
+                            cmp[ii] = (* comp)[ii];
+                            bb [ii] = (* b   )[ii];
+                        }
+                        free(* comp);
+                        free(* b   );
+                        * comp = cmp;
+                        * b    = bb;
+                        * count = N_comp + 1; 
+                    }
+                    parserComp(xmlf, p, pca, &N_comp, model, &((*b)[N_comp]), last, max);
+                    cmp[N_comp - 1] = *last;
+                }
+                if(tagVal == P){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EP){
+                    st = 0;
+                    buf[i] = '\0';
+                    p = atoi(buf);
+                    //printf("<P>%d</P>\n", p);
+                }
+                if(tagVal == PCA){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == EPCA){
+                    st = 0;
+                    buf[i] = '\0';
+                    pca = atoi(buf);
+                    //printf("<PCA>%d</PCA>\n", p);
+                }
+                if(tagVal == SCORE){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == PCACOEFF){
+                    st = 0;
+                    i = 0;
+                    p--;
+                    data = (double *)malloc( sizeof(double) * p * p);
+                    (*PCAcoeff) = (float *)malloc( sizeof(float) * p * p);
+                    CV_Assert(fread(data, sizeof(double), p * p, xmlf));
+                    for(jj = 0; jj < p * p; jj++){
+                      (*PCAcoeff)[jj] = (float)data[jj];
+                    }
+                    free(data);
+                    p++;
+                }
+                if(tagVal == EPCACOEFF){
+                    st = 0;
+                    //printf("<PCA>%d</PCA>\n", p);
+                }
+                if(tagVal == SCORE){
+                    st = 1;
+                    i = 0;
+                }
+                if(tagVal == ESCORE){
+                    st = 0;
+                    buf[i] = '\0';
+                    *score = (float)atof(buf);
+                    //printf("<ScoreThreshold>%f</ScoreThreshold>\n", score);
+                }
+                tag = 0;
+                i   = 0;                
+            }else{
+                if((tag == 0)&& (st == 1)){
+                    buf[i] = ch; i++;
+                }else{
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+}
+
+void LSVMparser(const char * filename, 
+                CvLSVMFilterObjectCaskade *** model, 
+                int *last, 
+                int *max, 
+                int **comp, 
+                float **b, 
+                int *count, 
+                float * score,
+                float** PCAcoeff)
+{
+    int tag;
+    char ch;
+    int j;
+    FILE *xmlf;
+    char tagBuf[1024];
+
+    (*max) = 10;
+    (*last) = -1;
+    (*model) = (CvLSVMFilterObjectCaskade ** )malloc((sizeof(CvLSVMFilterObjectCaskade * )) * (*max));
+
+    //printf("parse : %s\n", filename);
+    xmlf = fopen(filename, "rb");
+    
+    j   = 0;
+    tag = 0;
+    while(!feof(xmlf)){
+        ch = (char) fgetc( xmlf );
+        if(ch == '<'){
+            tag = 1;
+            j   = 1;
+            tagBuf[j - 1] = ch;
+        }else {
+            if(ch == '>'){
+                tag = 0;
+                tagBuf[j    ] = ch;
+                tagBuf[j + 1] = '\0';
+                if(getTeg(tagBuf) == MODEL){
+                    parserModel(xmlf, model, last, max, comp, b, count, score, PCAcoeff);
+                }
+            }else{
+                if(tag != 0)
+                {
+                    tagBuf[j] = ch; j++;
+                }
+            }
+        }        
+    }
+    fclose(xmlf);
+}
+
+int loadModel(
+              const char *modelPath,
+             
+              CvLSVMFilterObjectCaskade ***filters,
+              int *kFilters, 
+              int *kComponents, 
+              int **kPartFilters, 
+              float **b, 
+              float *scoreThreshold,
+              float ** PCAcoeff){ 
+    int last;
+    int max;
+    int *comp;
+    int count;
+    int i;
+    float score;
+
+    LSVMparser(modelPath, filters, &last, &max, &comp, b, &count, &score, PCAcoeff);
+    (*kFilters)       = last + 1;
+    (*kComponents)    = count;
+    (*scoreThreshold) = (float) score;
+
+    (*kPartFilters) = (int *)malloc(sizeof(int) * count);
+
+    for(i = 1; i < count;i++){
+        (*kPartFilters)[i] = (comp[i] - comp[i - 1]) - 1;
+    }
+    (*kPartFilters)[0] = comp[0];
+
+
+    for(i = 0; i < (*kFilters);i++){
+        (*(filters))[i]->deltaX = 5;// maxX;
+        (*(filters))[i]->deltaY = 5;// maxY;
+    }
+
+    return 0;
+}
+}
+}

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/lsvmc_routine.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_routine.h"
+namespace cv
+{
+namespace lsvm
+{
+int allocFilterObject(CvLSVMFilterObjectCaskade **obj, const int sizeX,
+                      const int sizeY, const int numFeatures) 
+{
+    int i;
+    (*obj) = (CvLSVMFilterObjectCaskade *)malloc(sizeof(CvLSVMFilterObjectCaskade));
+    (*obj)->sizeX           = sizeX;
+    (*obj)->sizeY           = sizeY;
+    (*obj)->numFeatures     = numFeatures;
+    (*obj)->fineFunction[0] = 0.0f;
+    (*obj)->fineFunction[1] = 0.0f;
+    (*obj)->fineFunction[2] = 0.0f;
+    (*obj)->fineFunction[3] = 0.0f;
+    (*obj)->V.x         = 0;
+    (*obj)->V.y         = 0;
+    (*obj)->V.l         = 0;
+    (*obj)->H = (float *) malloc(sizeof (float) * 
+                                (sizeX * sizeY  * numFeatures));
+    for(i = 0; i < sizeX * sizeY * numFeatures; i++)
+    {
+        (*obj)->H[i] = 0.0f;
+    }
+    return LATENT_SVM_OK;
+}
+int freeFilterObject (CvLSVMFilterObjectCaskade **obj)
+{
+    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
+    free((*obj)->H);
+    free(*obj);
+    (*obj) = NULL;
+    return LATENT_SVM_OK;
+}
+
+int allocFeatureMapObject(CvLSVMFeatureMapCaskade **obj, const int sizeX, 
+                          const int sizeY, const int numFeatures)
+{
+    int i;
+    (*obj) = (CvLSVMFeatureMapCaskade *)malloc(sizeof(CvLSVMFeatureMapCaskade));
+    (*obj)->sizeX       = sizeX;
+    (*obj)->sizeY       = sizeY;
+    (*obj)->numFeatures = numFeatures;
+    (*obj)->map = (float *) malloc(sizeof (float) * 
+                                  (sizeX * sizeY  * numFeatures));
+    for(i = 0; i < sizeX * sizeY * numFeatures; i++)
+    {
+        (*obj)->map[i] = 0.0f;
+    }
+    return LATENT_SVM_OK;
+}
+int freeFeatureMapObject (CvLSVMFeatureMapCaskade **obj)
+{
+    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
+    free((*obj)->map);
+    free(*obj);
+    (*obj) = NULL;
+    return LATENT_SVM_OK;
+}
+
+int allocFeaturePyramidObject(CvLSVMFeaturePyramidCaskade **obj,
+                              const int numLevels) 
+{
+    (*obj) = (CvLSVMFeaturePyramidCaskade *)malloc(sizeof(CvLSVMFeaturePyramidCaskade));
+    (*obj)->numLevels = numLevels;
+    (*obj)->pyramid    = (CvLSVMFeatureMapCaskade **)malloc(
+                         sizeof(CvLSVMFeatureMapCaskade *) * numLevels);
+    return LATENT_SVM_OK;
+}
+
+int freeFeaturePyramidObject (CvLSVMFeaturePyramidCaskade **obj)
+{
+    int i; 
+    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
+    for(i = 0; i < (*obj)->numLevels; i++)
+    {
+        freeFeatureMapObject(&((*obj)->pyramid[i]));
+    }
+    free((*obj)->pyramid);
+    free(*obj);
+    (*obj) = NULL;
+    return LATENT_SVM_OK;
+}
+}
+}

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/src/precomp.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.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#ifdef HAVE_CVCONFIG_H
+#include "cvconfig.h"
+#endif
+
+#ifdef __cplusplus
+#include <map>
+#include <deque>
+#endif
+
+#include "opencv2/latentsvm.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/core/core_c.h"
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/highgui/highgui_c.h"
+
+
+#ifdef HAVE_TEGRA_OPTIMIZATION
+#include "opencv2/objdetect/objdetect_tegra.hpp"
+#endif
+
+#endif

modules/latentsvm/test/test_latentsvmdetector_cascade.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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., 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 "test_precomp.hpp"
+
+#include <string>
+
+#ifdef HAVE_CVCONFIG_H
+#include "cvconfig.h"
+#endif
+
+#ifdef HAVE_TBB
+#include "tbb/task_scheduler_init.h"
+#endif
+
+using namespace cv;
+
+const float score_thr = 0.05f;
+
+class LatentSVMDetectorCaskadeTest : public cvtest::BaseTest
+{
+protected:
+    void run(int);
+};
+
+static void writeDetections( FileStorage& fs, const std::string& nodeName, const std::vector<lsvm::LSVMDetector::ObjectDetection>& detections )
+{
+    fs << nodeName << "[";
+    for( size_t i = 0; i < detections.size(); i++ ) //FIXME operator <<
+    {
+        lsvm::LSVMDetector::ObjectDetection const &d = detections[i];
+        fs << d.rect.x << d.rect.y << d.rect.width << d.rect.height
+           << d.score << d.classID;
+    }
+    fs << "]";
+}
+
+static void readDetections( FileStorage fs, const std::string& nodeName, 
+                           std::vector<lsvm::LSVMDetector::ObjectDetection>& detections )
+{
+    detections.clear();
+
+    FileNode fn = fs.root()[nodeName];
+    FileNodeIterator fni = fn.begin();
+    while( fni != fn.end() )
+    {
+        lsvm::LSVMDetector::ObjectDetection d;
+        fni >> d.rect.x >> d.rect.y >> d.rect.width >> d.rect.height
+            >> d.score >> d.classID;
+        detections.push_back( d );
+    }
+}
+
+static inline bool isEqualCaskad( const lsvm::LSVMDetector::ObjectDetection& d1,
+                           const lsvm::LSVMDetector::ObjectDetection& d2, int eps, float threshold)
+{
+    return (
+           std::abs(d1.rect.x - d2.rect.x) <= eps
+           && std::abs(d1.rect.y - d2.rect.y) <= eps
+           && std::abs(d1.rect.width - d2.rect.width) <= eps
+           && std::abs(d1.rect.height - d2.rect.height) <= eps
+           && (d1.classID == d2.classID)
+           && std::abs(d1.score - d2.score) <= threshold
+           );
+}
+
+
+bool compareResults( const std::vector<lsvm::LSVMDetector::ObjectDetection>& calc,
+                    const std::vector<lsvm::LSVMDetector::ObjectDetection>& valid, int eps, float threshold)
+{
+    if( calc.size() != valid.size() )
+        return false;
+
+    for( size_t i = 0; i < calc.size(); i++ )
+    {
+        lsvm::LSVMDetector::ObjectDetection const &c = calc[i];
+        lsvm::LSVMDetector::ObjectDetection const &v = valid[i];
+
+        if( !isEqualCaskad(c, v, eps, threshold) )
+        {
+            std::cerr << "Expected: " << v.rect << " class=" << v.classID << " score=" << v.score << std::endl;
+            std::cerr << "Actual:   " << c.rect << " class=" << c.classID << " score=" << c.score << std::endl;
+            return false;
+        }
+    }
+    return true;
+}
+
+void LatentSVMDetectorCaskadeTest::run( int /* start_from */)
+{
+    std::string img_path_cat = std::string(ts->get_data_path()) + "cat.png";
+    std::string img_path_cars = std::string(ts->get_data_path()) + "cars.png";
+
+    std::string model_path_cat = std::string(ts->get_data_path()) + "models_VOC2007_cascade/cat.xml";
+    std::string model_path_car = std::string(ts->get_data_path()) + "models_VOC2007_cascade/car.xml";
+
+    std::string true_res_path = std::string(ts->get_data_path()) + "results_cascade.xml";
+
+
+#ifdef HAVE_TBB
+    int numThreads = 2;
+#endif
+
+    Mat image_cat = imread( img_path_cat );
+    Mat image_cars = imread( img_path_cars );
+    if( image_cat.empty() || image_cars.empty() )
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+        return;
+    }
+
+    // We will test 2 cases:
+    // detector1 - to test case of one class 'cat'
+    // detector12 - to test case of two (several) classes 'cat' and car
+
+    // Load detectors
+    cv::Ptr<lsvm::LSVMDetector> detector1 = lsvm::LSVMDetector::create(std::vector<std::string>(1,model_path_cat));
+
+    std::vector<std::string> models_pathes(2);
+    models_pathes[0] = model_path_cat;
+    models_pathes[1] = model_path_car;
+    cv::Ptr<lsvm::LSVMDetector> detector12 = lsvm::LSVMDetector::create(models_pathes);
+
+    if( detector1->isEmpty() || detector12->isEmpty() || detector12->getClassCount() != 2 )
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+        return;
+    }
+
+    // 1. Test method detect
+    // Run detectors
+    std::vector<lsvm::LSVMDetector::ObjectDetection> detections1_cat, detections12_cat, detections12_cars;
+    detector1->detect( image_cat, detections1_cat, 0.5);
+    detector12->detect( image_cat, detections12_cat, 0.5);
+    detector12->detect( image_cars, detections12_cars, 0.5);
+
+    // Load true results
+    FileStorage fs( true_res_path, FileStorage::READ );
+    if( fs.isOpened() )
+    {
+        std::vector<lsvm::LSVMDetector::ObjectDetection> true_detections1_cat, true_detections12_cat, true_detections12_cars;
+        readDetections( fs, "detections1_cat", true_detections1_cat );
+        readDetections( fs, "detections12_cat", true_detections12_cat );
+        readDetections( fs, "detections12_cars", true_detections12_cars );
+
+        if( !compareResults(detections1_cat, true_detections1_cat, 1, score_thr) )
+        {
+            std::cerr << "Results of detector1 are invalid on image cat.png" << std::endl;
+            ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH );
+        }
+        if( !compareResults(detections12_cat, true_detections12_cat, 1, score_thr) )
+        {
+            std::cerr << "Results of detector12 are invalid on image cat.png" << std::endl;
+            ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH );
+        }
+        if( !compareResults(detections12_cars, true_detections12_cars, 1, score_thr) )
+        {
+            std::cerr << "Results of detector12 are invalid on image cars.png" << std::endl;
+            ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH );
+        }
+    }
+    else
+    {
+        fs.open( true_res_path, FileStorage::WRITE );
+        if( fs.isOpened() )
+        {
+            writeDetections( fs, "detections1_cat", detections1_cat );
+            writeDetections( fs, "detections12_cat", detections12_cat );
+            writeDetections( fs, "detections12_cars", detections12_cars );
+        }
+        else
+            std::cerr << "File " << true_res_path << " cann't be opened to save test results" << std::endl;
+    }
+
+    ts->set_failed_test_info( cvtest::TS::OK);
+}
+
+TEST(Objdetect_LatentSVMDetectorCaskade_cpp, regression) { LatentSVMDetectorCaskadeTest test; test.safe_run(); }

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

modules/latentsvm/testdata/latentsvm/mat2xml.m

+function [] = mat2xml(fname_in, fname_out)
+load(fname_in);
+num_feat = 31;
+rootfilters = [];
+for i = 1:length(model.rootfilters)
+  rootfilters{i} = model.rootfilters{i}.w;
+end
+partfilters = [];
+for i = 1:length(model.partfilters)
+  partfilters{i} = model.partfilters{i}.w;
+end
+for c = 1:model.numcomponents
+  ridx{c} = model.components{c}.rootindex;
+  oidx{c} = model.components{c}.offsetindex;
+  root{c} = model.rootfilters{ridx{c}}.w;
+  rsize{c} = [size(root{c},1) size(root{c},2)];
+  numparts{c} = length(model.components{c}.parts);
+  for j = 1:numparts{c}
+    pidx{c,j} = model.components{c}.parts{j}.partindex;
+    didx{c,j} = model.components{c}.parts{j}.defindex;
+    part{c,j} = model.partfilters{pidx{c,j}}.w;
+    psize{c,j} = [size(part{c,j},1) size(part{c,j},2)];
+    % reverse map from partfilter index to (component, part#)
+    % rpidx{pidx{c,j}} = [c j];
+  end
+end
+
+f = fopen(fname_out, 'wb');
+fprintf(f, '<Model>\n');
+fprintf(f, '\t<!-- Number of components -->\n');
+fprintf(f, '\t<NumComponents>%d</NumComponents>\n', model.numcomponents);
+fprintf(f, '\t<!-- Number of features -->\n');
+fprintf(f, '\t<P>%d</P>\n', num_feat);
+fprintf(f, '\t<!-- Score threshold -->\n');
+fprintf(f, '\t<ScoreThreshold>%.16f</ScoreThreshold>\n', model.thresh);
+for c = 1:model.numcomponents
+    fprintf(f, '\t<Component>\n');
+    fprintf(f, '\t\t<!-- Root filter description -->\n');
+    fprintf(f, '\t\t<RootFilter>\n');
+    fprintf(f, '\t\t\t<!-- Dimensions -->\n');
+    rootfilter = root{c};
+    fprintf(f, '\t\t\t<sizeX>%d</sizeX>\n', rsize{c}(2));
+    fprintf(f, '\t\t\t<sizeY>%d</sizeY>\n', rsize{c}(1));
+    fprintf(f, '\t\t\t<!-- Weights (binary representation) -->\n');
+    fprintf(f, '\t\t\t<Weights>');
+    for jj = 1:rsize{c}(1)
+        for ii = 1:rsize{c}(2)
+            for kk = 1:num_feat
+                fwrite(f, rootfilter(jj, ii, kk), 'double');
+            end
+        end
+    end
+    fprintf(f, '\t\t\t</Weights>\n');
+    fprintf(f, '\t\t\t<!-- Linear term in score function -->\n');
+    fprintf(f, '\t\t\t<LinearTerm>%.16f</LinearTerm>\n', model.offsets{1,c}.w);
+    fprintf(f, '\t\t</RootFilter>\n\n');
+    fprintf(f, '\t\t<!-- Part filters description -->\n');
+    fprintf(f, '\t\t<PartFilters>\n');
+    fprintf(f, '\t\t\t<NumPartFilters>%d</NumPartFilters>\n', numparts{c});
+
+    for j=1:numparts{c}
+        fprintf(f, '\t\t\t<!-- Part filter %d description -->\n', j);
+        fprintf(f, '\t\t\t<PartFilter>\n');
+        partfilter = part{c,j};
+        anchor = model.defs{didx{c,j}}.anchor;
+        def = model.defs{didx{c,j}}.w;
+        
+        fprintf(f, '\t\t\t\t<!-- Dimensions -->\n');
+        fprintf(f, '\t\t\t\t<sizeX>%d</sizeX>\n', psize{c,j}(2));
+        fprintf(f, '\t\t\t\t<sizeY>%d</sizeY>\n', psize{c,j}(1));
+        fprintf(f, '\t\t\t\t<!-- Weights (binary representation) -->\n');
+        fprintf(f, '\t\t\t\t<Weights>');
+        for jj = 1:psize{c,j}(1)
+            for ii = 1:psize{c,j}(2)
+                for kk = 1:num_feat
+                    fwrite(f, partfilter(jj, ii, kk), 'double');
+                end
+            end
+        end
+        fprintf(f, '\t\t\t\t</Weights>\n');
+        fprintf(f, '\t\t\t\t<!-- Part filter offset -->\n');
+        fprintf(f, '\t\t\t\t<V>\n');
+        fprintf(f, '\t\t\t\t\t<Vx>%d</Vx>\n', anchor(1));
+        fprintf(f, '\t\t\t\t\t<Vy>%d</Vy>\n', anchor(2));
+        fprintf(f, '\t\t\t\t</V>\n');
+        fprintf(f, '\t\t\t\t<!-- Quadratic penalty function coefficients -->\n');
+        fprintf(f, '\t\t\t\t<Penalty>\n');
+        fprintf(f, '\t\t\t\t\t<dx>%.16f</dx>\n', def(2));
+        fprintf(f, '\t\t\t\t\t<dy>%.16f</dy>\n', def(4));
+        fprintf(f, '\t\t\t\t\t<dxx>%.16f</dxx>\n', def(1));
+        fprintf(f, '\t\t\t\t\t<dyy>%.16f</dyy>\n', def(3));
+        fprintf(f, '\t\t\t\t</Penalty>\n');
+         fprintf(f, '\t\t\t</PartFilter>\n');
+    end
+    fprintf(f, '\t\t</PartFilters>\n');
+    fprintf(f, '\t</Component>\n');
+end
+fprintf(f, '</Model>');
+fclose(f);

modules/latentsvm/testdata/latentsvm/results_cascade.xml

+<?xml version="1.0"?>
+<opencv_storage>
+<detections1_cat>
+  0 0 340 485 -0.837739 0</detections1_cat>
+<detections12_cat>
+  0 0 340 485 -0.837739 0 129 0 181 155 -0.795819 1</detections12_cat>
+<detections12_cars>
+218 24 218 121 2.36436 1 0 285 233 129 1.93423 1 0 21 190 105 1.7496 1 202 183 202 
+73 1.57262 1 0 171 171 68 1.49932 1 238 312 165 91 0.504801 1 0 181 226 90 0.404986 
+1 0 0 240 171 0.158534 1 207 155 233 129 -0.1988589 1 195 278 250 139 -0.50933 1
+ 89 0 328 119 -0.570692 1 0 295 422 154 -0.922104 1</detections12_cars>
+</opencv_storage>

modules/line_descriptor/include/opencv2/line_descriptor/descriptor.hpp

@@ -50,7 +50,7 @@
 #include <iostream>
 
 #include "opencv2/core/utility.hpp"
-#include "opencv2/core/private.hpp"
+//#include "opencv2/core/private.hpp"
 #include <opencv2/imgproc.hpp>
 #include <opencv2/features2d.hpp>
 #include <opencv2/highgui.hpp>