added dpm module

modules/dpm/CMakeLists.txt

+set(the_description "Object Detection")
+
+#uncomment the following line to enable parallel computing
+#add_definitions(-DHAVE_TBB)
+
+ocv_define_module(dpm opencv_core opencv_imgproc opencv_objdetect OPTIONAL opencv_highgui WRAP python)
+
+ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4512) # disable warning on Win64

modules/dpm/README.md

+Cascade object detection with deformable part models
+====================================================
+The object detector described below has been initially proposed by P.F. Felzenszwalb in [1]. 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 [2]. 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 DPM cascade detector.
+
+Usage
+-----
+```
+// load model from model_path
+cv::Ptr<DPMDetector> detector = DPMDetector::create(vector<string>(1, model_path));
+// read image from image_path
+Mat image = imread(image_path);
+
+// detection
+vector<DPMDetector::ObjectDetection> ds;
+detector->detect(image, ds);
+```
+
+Examples
+----------
+```
+// detect using web camera
+./example_dpm_cascade_detect_camera <model_path>
+
+// detect for an image sequence
+./example_dpm_cascade_detect_sequence <model_path> <image_dir>
+```
+
+References
+----------
+[1]: P. Felzenszwalb, R. Girshick, D. McAllester, D. Ramanan Object Detection with Discriminatively Trained Part Based Models IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol. 32, No. 9, Sep. 2010.
+
+[2]: P. Felzenszwalb, R. Girshick, D. McAllester Cascade Object Detection with Deformable Part Models IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2010.

modules/latentsvm/include/opencv2/latentsvm.hpp → modules/dpm/include/opencv2/dpm.hpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -37,7 +37,8 @@
 // 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:
+// Implementation authors:
+// Jiaolong Xu - jiaolongxu@gmail.com
 // Evgeniy Kozinov - evgeniy.kozinov@gmail.com
 // Valentina Kustikova - valentina.kustikova@gmail.com
 // Nikolai Zolotykh - Nikolai.Zolotykh@gmail.com
@@ -55,7 +56,7 @@
 #include <vector>
 #include <string>
 
-/** @defgroup latentsvm Latent SVM
+/** @defgroup dpm Deformable Part-based Models
 
 Discriminatively Trained Part Based Models for Object Detection
 ---------------------------------------------------------------
@@ -85,19 +86,19 @@ Using this hierarchy, low scoring hypotheses can be pruned after looking at the
 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.
+In OpenCV there is an C++ implementation of DPM cascade detector.
 
 */
 
 namespace cv
 {
 
-namespace lsvm
+namespace dpm
 {
 
-/** @brief This is a C++ abstract class, it provides external user API to work with Latent SVM.
+/** @brief This is a C++ abstract class, it provides external user API to work with DPM.
  */
-class CV_EXPORTS_W LSVMDetector
+class CV_EXPORTS_W DPMDetector
 {
 public:
 
@@ -116,10 +117,8 @@ public:
     (models) and corresponding confidence levels.
     @param image An image.
     @param objects The detections: rectangulars, scores and class IDs.
-    @param overlapThreshold Threshold for the non-maximum suppression algorithm.
-     */
-    virtual void detect(cv::Mat const &image, CV_OUT std::vector<ObjectDetection> &objects,
-                         float overlapThreshold=0.5f ) = 0;
+    */
+    virtual void detect(cv::Mat &image, CV_OUT std::vector<ObjectDetection> &objects) = 0;
 
     /** @brief Return the class (model) names that were passed in constructor or method load or extracted from
     models filenames in those methods.
@@ -130,20 +129,20 @@ public:
      */
     virtual size_t getClassCount() const = 0;
 
-        /** @brief Load the trained models from given .xml files and return cv::Ptr\<LSVMDetector\>.
+    /** @brief Load the trained models from given .xml files and return cv::Ptr\<DPMDetector\>.
     @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/`.
+    model. See examples of such files here `/opencv_extra/testdata/cv/dpm/VOC2007_Cascade/`.
     @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".
      */
-    static cv::Ptr<LSVMDetector> create(std::vector<std::string> const &filenames,
-                                        std::vector<std::string> const &classNames = std::vector<std::string>());
+    static cv::Ptr<DPMDetector> create(std::vector<std::string> const &filenames,
+            std::vector<std::string> const &classNames = std::vector<std::string>());
 
-    virtual ~LSVMDetector(){}
+    virtual ~DPMDetector(){}
 };
 
-} // namespace lsvm
+} // namespace dpm
 } // namespace cv
 
 #endif

modules/latentsvm/src/lsvmc_routine.cpp → modules/dpm/samples/cascade_detect_camera.cpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -37,93 +37,118 @@
 // 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.
 //
+// Author: Jiaolong Xu <jiaolongxu AT gmail.com>
 //M*/
 
-#include "precomp.hpp"
-#include "_lsvmc_routine.h"
-namespace cv
-{
-namespace lsvm
+#include <opencv2/dpm.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/videoio/videoio_c.h>
+
+#include <stdio.h>
+#include <iostream>
+
+using namespace cv;
+using namespace cv::dpm;
+using namespace std;
+
+static void help()
 {
-int allocFilterObject(CvLSVMFilterObjectCascade **obj, const int sizeX,
-                      const int sizeY, const int numFeatures) 
+    cout << "\nThis is a demo of \"Deformable Part-based Model (DPM) cascade detection API\" using web camera.\n"
+       "Call:\n"
+       "./example_dpm_cascade_detect_camera <model_path>\n"
+       << endl;
+}
+
+void drawBoxes(Mat &frame,
+        vector<DPMDetector::ObjectDetection> ds,
+        Scalar color,
+        string text);
+
+int main( int argc, char** argv )
 {
-    int i;
-    (*obj) = (CvLSVMFilterObjectCascade *)malloc(sizeof(CvLSVMFilterObjectCascade));
-    (*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++)
+    const char* keys =
     {
-        (*obj)->H[i] = 0.0f;
+        "{@model_path    | | Path of the DPM cascade model}"
+    };
+
+    CommandLineParser parser(argc, argv, keys);
+    string model_path(parser.get<string>(0));
+
+    if( model_path.empty() )
+    {
+        help();
+        return -1;
     }
-    return LATENT_SVM_OK;
-}
-int freeFilterObject (CvLSVMFilterObjectCascade **obj)
-{
-    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
-    free((*obj)->H);
-    free(*obj);
-    (*obj) = NULL;
-    return LATENT_SVM_OK;
-}
 
-int allocFeatureMapObject(CvLSVMFeatureMapCascade **obj, const int sizeX, 
-                          const int sizeY, const int numFeatures)
-{
-    int i;
-    (*obj) = (CvLSVMFeatureMapCascade *)malloc(sizeof(CvLSVMFeatureMapCascade));
-    (*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++)
+    cv::Ptr<DPMDetector> detector = \
+    DPMDetector::create(vector<string>(1, model_path));
+
+    // use web camera
+    VideoCapture capture(0);
+    capture.set(CV_CAP_PROP_FRAME_WIDTH, 320);
+    capture.set(CV_CAP_PROP_FRAME_HEIGHT, 240);
+
+    if ( !capture.isOpened() )
     {
-        (*obj)->map[i] = 0.0f;
+        cerr << "Fail to open default camera (0)!" << endl;
+        return -1;
     }
-    return LATENT_SVM_OK;
-}
-int freeFeatureMapObject (CvLSVMFeatureMapCascade **obj)
-{
-    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
-    free((*obj)->map);
-    free(*obj);
-    (*obj) = NULL;
-    return LATENT_SVM_OK;
-}
 
-int allocFeaturePyramidObject(CvLSVMFeaturePyramidCascade **obj,
-                              const int numLevels) 
-{
-    (*obj) = (CvLSVMFeaturePyramidCascade *)malloc(sizeof(CvLSVMFeaturePyramidCascade));
-    (*obj)->numLevels = numLevels;
-    (*obj)->pyramid    = (CvLSVMFeatureMapCascade **)malloc(
-                         sizeof(CvLSVMFeatureMapCascade *) * numLevels);
-    return LATENT_SVM_OK;
+#ifdef HAVE_TBB
+    cout << "Running with TBB" << endl;
+#else
+#ifdef _OPENMP
+    cout << "Running with OpenMP" << endl;
+#else
+    cout << "Running without OpenMP and without TBB" << endl;
+#endif
+#endif
+
+    Mat frame;
+    namedWindow("DPM Cascade Detection", 1);
+    // the color of the rectangle
+    Scalar color(0, 255, 255); // yellow
+
+    while( capture.read(frame) )
+    {
+        vector<DPMDetector::ObjectDetection> ds;
+
+        Mat image;
+        frame.copyTo(image);
+
+        double t = (double) getTickCount();
+        // detection
+        detector->detect(image, ds);
+        // compute frame per second (fps)
+        t = ((double) getTickCount() - t)/getTickFrequency();//elapsed time
+
+        // draw boxes
+        string text = format("%0.1f fps", 1.0/t);
+        drawBoxes(frame, ds, color, text);
+
+        imshow("DPM Cascade Detection", frame);
+
+        if ( waitKey(30) >= 0)
+            break;
+    }
+
+    return 0;
 }
 
-int freeFeaturePyramidObject (CvLSVMFeaturePyramidCascade **obj)
+void drawBoxes(Mat &frame,
+        vector<DPMDetector::ObjectDetection> ds,
+        Scalar color,
+        string text)
 {
-    int i; 
-    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
-    for(i = 0; i < (*obj)->numLevels; i++)
+    for (unsigned int i = 0; i < ds.size(); i++)
     {
-        freeFeatureMapObject(&((*obj)->pyramid[i]));
+        rectangle(frame, ds[i].rect, color, 2);
     }
-    free((*obj)->pyramid);
-    free(*obj);
-    (*obj) = NULL;
-    return LATENT_SVM_OK;
-}
-}
+
+    // draw text on image
+    Scalar textColor(0,0,250);
+    putText(frame, text, Point(10,50), FONT_HERSHEY_PLAIN, 2, textColor, 2);
 }

modules/dpm/samples/cascade_detect_sequence.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) 2015, Itseez 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 Itseez Inc 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.
+//
+// Author: Jiaolong Xu <jiaolongxu AT gmail.com>
+//M*/
+
+#include <opencv2/dpm.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+
+using namespace cv;
+using namespace cv::dpm;
+using namespace std;
+
+int save_results(const string id, const vector<DPMDetector::ObjectDetection> ds, ofstream &out);
+
+static void help()
+{
+    cout << "\nThis example shows object detection on image sequences using \"Deformable Part-based Model (DPM) cascade detection API\n"
+       "Call:\n"
+       "./example_dpm_cascade_detect_sequence <model_path> <image_dir>\n"
+       "The image names has to be provided in \"files.txt\" under <image_dir>.\n"
+       << endl;
+}
+
+static bool readImageLists( const string &file, vector<string> &imgFileList)
+{
+    ifstream in(file.c_str(), ios::binary);
+
+    if (in.is_open())
+    {
+        while (in)
+        {
+            string line;
+            getline(in, line);
+            imgFileList.push_back(line);
+        }
+        return true;
+    }
+    else
+    {
+        cerr << "Invalid image index file: " << file  << endl;
+        return false;
+    }
+}
+
+void drawBoxes(Mat &frame,
+        vector<DPMDetector::ObjectDetection> ds,
+        Scalar color,
+        string text);
+
+int main( int argc, char** argv )
+{
+    const char* keys =
+    {
+        "{@model_path    | | Path of the DPM cascade model}"
+        "{@image_dir     | | Directory of the images      }"
+    };
+
+    CommandLineParser parser(argc, argv, keys);
+    string model_path(parser.get<string>(0));
+    string image_dir(parser.get<string>(1));
+    string image_list = image_dir + "/files.txt";
+
+    if( model_path.empty() || image_dir.empty() )
+    {
+        help();
+        return -1;
+    }
+
+    vector<string> imgFileList;
+    if ( !readImageLists(image_list, imgFileList) )
+        return -1;
+
+#ifdef HAVE_TBB
+    cout << "Running with TBB" << endl;
+#else
+#ifdef _OPENMP
+    cout << "Running with OpenMP" << endl;
+#else
+    cout << "Running without OpenMP and without TBB" << endl;
+#endif
+#endif
+
+    cv::Ptr<DPMDetector> detector = \
+    DPMDetector::create(vector<string>(1, model_path));
+
+    namedWindow("DPM Cascade Detection", 1);
+    // the color of the rectangle
+    Scalar color(0, 255, 255); // yellow
+    Mat frame;
+
+    for (size_t i = 0; i < imgFileList.size(); i++)
+    {
+        double t = (double) getTickCount();
+        vector<DPMDetector::ObjectDetection> ds;
+
+        Mat image = imread(image_dir + "/" + imgFileList[i]);
+        frame = image.clone();
+
+        if (image.empty()) {
+            cerr << "\nInvalid image:\n" << imgFileList[i] << endl;
+            return -1;
+        }
+
+        // detection
+        detector->detect(image, ds);
+        // compute frame per second (fps)
+        t = ((double) getTickCount() - t)/getTickFrequency();//elapsed time
+
+        // draw boxes
+        string text = format("%0.1f fps", 1.0/t);
+        drawBoxes(frame, ds, color, text);
+
+        // show detections
+        imshow("DPM Cascade Detection", frame);
+
+        if ( waitKey(30) >= 0)
+            break;
+    }
+
+    return 0;
+}
+
+void drawBoxes(Mat &frame, \
+        vector<DPMDetector::ObjectDetection> ds, Scalar color, string text)
+{
+    for (unsigned int i = 0; i < ds.size(); i++)
+    {
+        rectangle(frame, ds[i].rect, color, 2);
+    }
+
+    // draw text on image
+    Scalar textColor(0,0,250);
+    putText(frame, text, Point(10,50), FONT_HERSHEY_PLAIN, 2, textColor, 2);
+}

modules/dpm/src/dpm_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) 2015, Itseez 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 Itseez Inc 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 "dpm_cascade.hpp"
+#include "dpm_nms.hpp"
+
+#include <limits>
+#include <fstream>
+#include <iostream>
+#include <stdio.h>
+
+using namespace std;
+
+namespace cv
+{
+namespace dpm
+{
+
+void DPMCascade::loadCascadeModel(const string &modelPath)
+{
+    // load cascade model from xml
+    bool is_success = model.deserialize(modelPath);
+
+    if (!is_success)
+    {
+        string errorMessage = format("Unable to parse the model: %s", modelPath.c_str());
+        CV_Error(CV_StsBadArg, errorMessage);
+    }
+
+    model.initModel();
+}
+
+void DPMCascade::initDPMCascade()
+{
+    // compute the size of temporary storage needed by cascade
+    int nlevels = (int) pyramid.size();
+    int numPartFilters = model.getNumPartFilters();
+    int numDefParams = model.getNumDefParams();
+    featDimsProd.resize(nlevels);
+    tempStorageSize = 0;
+
+    for (int i = 0; i < nlevels; i++)
+    {
+        int w = pyramid[i].cols/feature.dimHOG;
+        int h = pyramid[i].rows;
+        featDimsProd[i] = w*h;
+        tempStorageSize += w*h;
+    }
+
+    tempStorageSize *= numPartFilters;
+
+    convValues.resize(tempStorageSize);
+    pcaConvValues.resize(tempStorageSize);
+    dtValues.resize(tempStorageSize);
+    pcaDtValues.resize(tempStorageSize);
+
+    fill(convValues.begin(), convValues.end(), -numeric_limits<double>::infinity());
+    fill(pcaConvValues.begin(), pcaConvValues.end(), -numeric_limits<double>::infinity());
+    fill(dtValues.begin(), dtValues.end(), -numeric_limits<double>::infinity());
+    fill(pcaDtValues.begin(), pcaDtValues.end(), -numeric_limits<double>::infinity());
+
+    // each pyramid (convolution and distance transform) is stored
+    // in a 1D array. Since pyramid levels have different sizes,
+    // we build an array of offset values in order to index by
+    // level. The last offset is the total length of the pyramid
+    // storage array.
+    convLevelOffset.resize(nlevels + 1);
+    dtLevelOffset.resize(nlevels + 1);
+    convLevelOffset[0] = 0;
+    dtLevelOffset[0] = 0;
+
+    for (int i = 1; i < nlevels + 1; i++)
+    {
+        convLevelOffset[i] = convLevelOffset[i-1] + numPartFilters*featDimsProd[i-1];
+        dtLevelOffset[i] = dtLevelOffset[i-1] + numDefParams*featDimsProd[i-1];
+    }
+
+    // cache of precomputed deformation costs
+    defCostCacheX.resize(numDefParams);
+    defCostCacheY.resize(numDefParams);
+
+    for (int i = 0; i < numDefParams; i++)
+    {
+        vector< double > def = model.defs[i];
+        CV_Assert((int) def.size() >= 4);
+
+        defCostCacheX[i].resize(2*halfWindowSize + 1);
+        defCostCacheY[i].resize(2*halfWindowSize + 1);
+
+        for (int j = 0; j < 2*halfWindowSize + 1; j++)
+        {
+            int delta = j - halfWindowSize;
+            int deltaSquare = delta*delta;
+            defCostCacheX[i][j] = -def[0]*deltaSquare - def[1]*delta;
+            defCostCacheY[i][j] = -def[2]*deltaSquare - def[3]*delta;
+        }
+    }
+
+    dtArgmaxX.resize(dtLevelOffset[nlevels]);
+    pcaDtArgmaxX.resize(dtLevelOffset[nlevels]);
+    dtArgmaxY.resize(dtLevelOffset[nlevels]);
+    pcaDtArgmaxY.resize(dtLevelOffset[nlevels]);
+}
+
+vector< vector<double> > DPMCascade::detect(Mat &image)
+{
+    if (image.channels() == 1)
+        cvtColor(image, image, COLOR_GRAY2BGR);
+
+    if (image.depth() != CV_64F)
+        image.convertTo(image, CV_64FC3);
+
+    // compute features
+    computeFeatures(image);
+
+    // pre-allocate storage
+    initDPMCascade();
+
+    // cascade process
+    vector< vector<double> > detections;
+    process(detections);
+
+    // non-maximum suppression
+    NonMaximumSuppression nms;
+    nms.process(detections, 0.5);
+
+    return detections;
+}
+
+void DPMCascade::computeFeatures(const Mat &im)
+{
+    // initialize feature pyramid
+    PyramidParameter params;
+    params.padx = model.maxSizeX;
+    params.pady = model.maxSizeY;
+    params.interval = model.interval;
+    params.binSize = model.sBin;
+
+    feature = Feature(params);
+
+    // compute pyramid
+    feature.computeFeaturePyramid(im, pyramid);
+
+    // compute projected pyramid
+    feature.projectFeaturePyramid(model.pcaCoeff, pyramid, pcaPyramid);
+}
+
+void DPMCascade::computeLocationScores(vector< vector< double > >  &locationScores)
+{
+    vector< vector < double > > locationWeight = model.locationWeight;
+    CV_Assert((int)locationWeight.size() == model.numComponents);
+
+    Mat locationFeature;
+    int nlevels = (int) pyramid.size();
+    feature.computeLocationFeatures(nlevels, locationFeature);
+
+    locationScores.resize(model.numComponents);
+
+    for (int comp = 0; comp < model.numComponents; comp++)
+    {
+        locationScores[comp].resize(locationFeature.cols);
+
+        for (int level = 0; level < locationFeature.cols; level++)
+        {
+            double val = 0;
+            for (int k = 0; k < locationFeature.rows; k++)
+                val += locationWeight[comp][k]*
+                    locationFeature.at<double>(k, level);
+
+            locationScores[comp][level] = val;
+        }
+    }
+}
+
+void DPMCascade::computeRootPCAScores(vector< vector< Mat > > &rootScores)
+{
+    PyramidParameter params = feature.getPyramidParameters();
+    rootScores.resize(model.numComponents);
+    int nlevels = (int) pyramid.size();
+    int interval = params.interval;
+
+    for (int comp = 0; comp < model.numComponents; comp++)
+    {
+        rootScores[comp].resize(nlevels);
+#ifdef HAVE_TBB // parallel computing
+        ParalComputeRootPCAScores paralTask(pcaPyramid, model.rootPCAFilters[comp],
+                model.pcaDim, rootScores[comp]);
+        parallel_for_(Range(interval, nlevels), paralTask);
+#else
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (int level = interval; level < nlevels; level++)
+        {
+            Mat feat = pcaPyramid[level];
+            Mat filter = model.rootPCAFilters[comp];
+
+            // compute size of output
+            int height = feat.rows - filter.rows + 1;
+            int width = (feat.cols - filter.cols) / model.pcaDim + 1;
+
+            if (height < 1 || width < 1)
+                CV_Error(CV_StsBadArg,
+                        "Invalid input, filter size should be smaller than feature size.");
+
+            Mat result = Mat::zeros(Size(width, height), CV_64F);
+            convolutionEngine.convolve(feat, filter, model.pcaDim, result);
+            rootScores[comp][level] = result;
+        }
+#endif
+    }
+}
+
+#ifdef HAVE_TBB
+ParalComputeRootPCAScores::ParalComputeRootPCAScores(
+        const vector< Mat > &pcaPyrad,
+        const Mat &f,
+        int dim,
+        vector< Mat > &sc):
+    pcaPyramid(pcaPyrad),
+    filter(f),
+    pcaDim(dim),
+    scores(sc)
+{
+}
+
+void ParalComputeRootPCAScores::operator() (const Range &range) const
+{
+    for (int level = range.start; level != range.end; level++)
+    {
+        Mat feat = pcaPyramid[level];
+
+        // compute size of output
+        int height = feat.rows - filter.rows + 1;
+        int width = (feat.cols - filter.cols) / pcaDim + 1;
+
+        Mat result = Mat::zeros(Size(width, height), CV_64F);
+        // convolution engine
+        ConvolutionEngine convEngine;
+        convEngine.convolve(feat, filter, pcaDim, result);
+        scores[level] = result;
+    }
+}
+#endif
+
+void DPMCascade::process( vector< vector<double> > &dets)
+{
+    PyramidParameter params = feature.getPyramidParameters();
+    int interval = params.interval;
+    int padx = params.padx;
+    int pady = params.pady;
+    vector<double> scales = params.scales;
+
+    int nlevels = (int)pyramid.size() - interval;
+    CV_Assert(nlevels > 0);
+
+    // keep track of the PCA scores for each PCA filter
+    vector< vector< double > > pcaScore(model.numComponents);
+    for (int comp = 0; comp < model.numComponents; comp++)
+        pcaScore[comp].resize(model.numParts[comp]+1);
+
+    // compute location scores
+    vector< vector< double > > locationScores;
+    computeLocationScores(locationScores);
+
+    // compute root PCA scores
+    vector< vector< Mat > > rootPCAScores;
+    computeRootPCAScores(rootPCAScores);
+
+    // process each model component and pyramid level
+    for (int comp = 0; comp < model.numComponents; comp++)
+    {
+        for (int plevel = 0; plevel < nlevels; plevel++)
+        {
+            // root filter pyramid level
+            int rlevel = plevel + interval;
+            double bias = model.bias[comp] + locationScores[comp][rlevel];
+            // get the scores of the first PCA filter
+            Mat rtscore = rootPCAScores[comp][rlevel];
+            // process each location in the current pyramid level
+            for (int rx = (int)ceil(padx/2.0); rx < rtscore.cols - (int)ceil(padx/2.0); rx++)
+            {
+                for (int ry = (int)ceil(pady/2.0); ry < rtscore.rows - (int)ceil(pady/2.0); ry++)
+                {
+                    // get stage 0 score
+                    double score = rtscore.at<double>(ry, rx) + bias;
+                    // record PCA score
+                    pcaScore[comp][0] = score - bias;
+                    // cascade stage 1 through 2*numparts + 2
+                    int stage = 1;
+                    int numstages = 2*model.numParts[comp] + 2;
+                    for(; stage < numstages; stage++)
+                    {
+                        double t = model.prunThreshold[comp][2*stage-1];
+                        // check for hypothesis pruning
+                        if (score < t)
+                            break;
+
+                        // pca == 1 if place filters
+                        // pca == 0 if place non-pca filters
+                        bool isPCA = (stage < model.numParts[comp] + 1 ? true : false);
+                        // get the part index
+                        // root parts have index -1, none-root part are indexed 0:numParts-1
+                        int part = model.partOrder[comp][stage] - 1;// partOrder
+
+                        if (part == -1)
+                        {
+                            // calculate the root non-pca score
+                            // and replace the PCA score
+                            double rscore = 0.0;
+                            if (isPCA)
+                            {
+                                rscore = convolutionEngine.convolve(pcaPyramid[rlevel],
+                                        model.rootPCAFilters[comp],
+                                        model.pcaDim, rx, ry);
+                            }
+                            else
+                            {
+                                rscore = convolutionEngine.convolve(pyramid[rlevel],
+                                        model.rootFilters[comp],
+                                        model.numFeatures, rx, ry);
+                            }
+                            score += rscore - pcaScore[comp][0];
+                        }
+                        else
+                        {
+                            // place a non-root filter
+                            int pId = model.pFind[comp][part];
+                            int px = 2*rx + (int)model.anchors[pId][0];
+                            int py = 2*ry + (int)model.anchors[pId][1];
+
+                            // look up the filter and deformation model
+                            double defThreshold =
+                                model.prunThreshold[comp][2*stage] - score;
+
+                            double ps = computePartScore(plevel, pId, px, py,
+                                    isPCA, defThreshold);
+
+                            if (isPCA)
+                            {
+                                // record PCA filter score
+                                pcaScore[comp][part+1] = ps;
+                                // update the hypothesis score
+                                score += ps;
+                            }
+                            else
+                            {
+                                // update the hypothesis score by replacing
+                                // the PCA score
+                                score += ps - pcaScore[comp][part+1];
+                            } // isPCA == false
+                        } // part != -1
+
+                    } // stages
+
+                    // check if the hypothesis passed all stages with a
+                    // final score over the global threshold
+                    if (stage == numstages && score >= model.scoreThresh)
+                    {
+                        vector<double> coords;
+                        // compute and record image coordinates of the detection window
+                        double scale = model.sBin/scales[rlevel];
+                        double x1 = (rx-padx)*scale;
+                        double y1 = (ry-pady)*scale;
+                        double x2 = x1 + model.rootFilterDims[comp].width*scale - 1;
+                        double y2 = y1 + model.rootFilterDims[comp].height*scale - 1;
+
+                        coords.push_back(x1);
+                        coords.push_back(y1);
+                        coords.push_back(x2);
+                        coords.push_back(y2);
+
+                        // compute and record image coordinates of the part filters
+                        scale = model.sBin/scales[plevel];
+                        int featWidth = pyramid[plevel].cols/feature.dimHOG;
+                        for (int p = 0; p < model.numParts[comp]; p++)
+                        {
+                            int pId = model.pFind[comp][p];
+                            int probx = 2*rx + (int)model.anchors[pId][0];
+                            int proby = 2*ry + (int)model.anchors[pId][1];
+                            int offset = dtLevelOffset[plevel] +
+                                pId*featDimsProd[plevel] +
+                                (proby - pady)*featWidth +
+                                probx - padx;
+                            int px = dtArgmaxX[offset] + padx;
+                            int py = dtArgmaxY[offset] + pady;
+                            x1 = (px - 2*padx)*scale;
+                            y1 = (py - 2*pady)*scale;
+                            x2 = x1 + model.partFilterDims[p].width*scale - 1;
+                            y2 = y1 + model.partFilterDims[p].height*scale - 1;
+                            coords.push_back(x1);
+                            coords.push_back(y1);
+                            coords.push_back(x2);
+                            coords.push_back(y2);
+                        }
+
+                        // record component number and score
+                        coords.push_back(comp + 1);
+                        coords.push_back(score);
+
+                        dets.push_back(coords);
+                    }
+                } // ry
+            } // rx
+        } // for each pyramid level
+    } // for each component
+}
+
+double DPMCascade::computePartScore(int plevel, int pId, int px, int py, bool isPCA, double defThreshold)
+{
+    // remove virtual padding
+    PyramidParameter params = feature.getPyramidParameters();
+    px -= params.padx;
+    py -= params.pady;
+
+    // check if already computed
+    int levelOffset = dtLevelOffset[plevel];
+    int locationOffset = pId*featDimsProd[plevel]
+        + py*pyramid[plevel].cols/feature.dimHOG
+        + px;
+    int dtBaseOffset = levelOffset + locationOffset;
+
+    double val;
+
+    if (isPCA)
+        val = pcaDtValues[dtBaseOffset];
+    else
+        val = dtValues[dtBaseOffset];
+
+    if (val > -numeric_limits<double>::infinity())
+        return val;
+
+    // Nope, define the bounds of the convolution and
+    // distance transform region
+    int xstart = px - halfWindowSize;
+    xstart = (xstart < 0 ? 0 : xstart);
+    int xend = px + halfWindowSize;
+
+    int ystart = py - halfWindowSize;
+    ystart = (ystart < 0 ? 0 : ystart);
+    int yend = py + halfWindowSize;
+
+    int featWidth = pyramid[plevel].cols/feature.dimHOG;
+    int featHeight = pyramid[plevel].rows;
+    int filterWidth = model.partFilters[pId].cols/feature.dimHOG;
+    int filterHeight = model.partFilters[pId].rows;
+
+    xend = (filterWidth + xend > featWidth)
+        ? featWidth - filterWidth
+        : xend;
+    yend = (filterHeight + yend > featHeight)
+        ? featHeight - filterHeight
+        : yend;
+
+    // do convolution and distance transform in region
+    // [xstar, xend, ystart, yend]
+    levelOffset = convLevelOffset[plevel];
+    locationOffset = pId*featDimsProd[plevel];
+    int convBaseOffset = levelOffset + locationOffset;
+
+    for (int y = ystart; y <= yend; y++)
+    {
+        int loc = convBaseOffset + y*featWidth + xstart - 1;
+        for (int x = xstart; x <= xend; x++)
+        {
+            loc++;
+            // skip if already computed
+            if (isPCA)
+            {
+                if (pcaConvValues[loc] > -numeric_limits<double>::infinity())
+                    continue;
+            }
+            else if(convValues[loc] > -numeric_limits<double>::infinity())
+                continue;
+
+            // check for deformation pruning
+            double defCost = defCostCacheX[pId][px - x + halfWindowSize]
+                + defCostCacheY[pId][py - y + halfWindowSize];
+
+            if (defCost < defThreshold)
+                continue;
+
+            if (isPCA)
+            {
+                pcaConvValues[loc] = convolutionEngine.convolve
+                    (pcaPyramid[plevel], model.partPCAFilters[pId],
+                     model.pcaDim, x, y);
+            }
+            else
+            {
+                convValues[loc] = convolutionEngine.convolve
+                    (pyramid[plevel], model.partFilters[pId],
+                     model.numFeatures, x, y);
+            }
+        } // y
+    } // x
+
+    // do distance transform over the region.
+    // the region is small enought that brut force DT
+    // is the fastest method
+    double max = -numeric_limits<double>::infinity();
+    int xargmax = 0;
+    int yargmax = 0;
+
+    for (int y = ystart; y <= yend; y++)
+    {
+        int loc = convBaseOffset + y*featWidth + xstart - 1;
+        for (int x = xstart; x <= xend; x++)
+        {
+            loc++;
+            double v;
+
+            if (isPCA)
+                v = pcaConvValues[loc];
+            else
+                v = convValues[loc];
+
+            v += defCostCacheX[pId][px - x + halfWindowSize]
+                + defCostCacheY[pId][py - y + halfWindowSize];
+
+            if (v > max)
+            {
+                max = v;
+                xargmax = x;
+                yargmax = y;
+            } // if v
+        } // for x
+    } // for y
+
+    // record max and argmax for DT
+    if (isPCA)
+    {
+        pcaDtArgmaxX[dtBaseOffset] = xargmax;
+        pcaDtArgmaxY[dtBaseOffset] = yargmax;
+        pcaDtValues[dtBaseOffset] = max;
+    }
+    else
+    {
+        dtArgmaxX[dtBaseOffset] = xargmax;
+        dtArgmaxY[dtBaseOffset] = yargmax;
+        dtValues[dtBaseOffset] = max;
+    }
+
+    return max;
+}
+
+} // namespace dpm
+} // namespace cv

modules/latentsvm/src/_lsvmc_matching.h → modules/dpm/src/dpm_cascade.hpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,92 +39,120 @@
 //
 //M*/
 
-/*****************************************************************************/
-/*                      Matching procedure API                               */
-/*****************************************************************************/
-//
-#ifndef _LSVM_MATCHING_H_
-#define _LSVM_MATCHING_H_
+#ifndef __DPM_CASCADE__
+#define __DPM_CASCADE__
+
+#include "dpm_model.hpp"
+#include "dpm_feature.hpp"
+#include "dpm_convolution.hpp"
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/core.hpp"
 
-#include "_lsvmc_latentsvm.h"
-#include "_lsvmc_error.h"
-#include "_lsvmc_routine.h"
+#include <string>
+#include <vector>
 
 namespace cv
 {
-namespace lsvm
+namespace dpm
 {
+/** @brief This class is the main process of DPM cascade
+ */
+class DPMCascade
+{
+    private:
+        // pyramid level offset for covolution
+        std::vector< int > convLevelOffset;
+        // pyramid level offset for distance transform
+        std::vector< int > dtLevelOffset;
+        // convolution values
+        std::vector< double > convValues;
+        std::vector< double > pcaConvValues;
+        // distance transform values
+        std::vector< double > dtValues;
+        std::vector< double > pcaDtValues;
+        // distance transform argmax, x dimension
+        std::vector< int > dtArgmaxX;
+        std::vector< int > pcaDtArgmaxX;
+        // distance transform argmax, y dimension
+        std::vector< int > dtArgmaxY;
+        std::vector< int > pcaDtArgmaxY;
+        // half-width of distance transform window
+        static const int halfWindowSize = 4;
+        // the amount of temporary storage of cascade
+        int tempStorageSize;
+        // precomputed deformation costs
+        std::vector< std::vector< double > > defCostCacheX;
+        std::vector< std::vector< double > > defCostCacheY;
+        // DPM cascade model
+        CascadeModel model;
+        // feature process
+        Feature feature;
+        // feature pyramid
+        std::vector< Mat > pyramid;
+        // projected (PCA) pyramid;
+        std::vector< Mat > pcaPyramid;
+        // number of positions in each pyramid level
+        std::vector< int > featDimsProd;
+        // convolution engine
+        ConvolutionEngine convolutionEngine;
 
+    public:
+        // constructor
+        DPMCascade () {}
+        // destructor
+        virtual ~DPMCascade () {}
 
-/*
-// 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(CvLSVMFeatureMapCascade *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 CvLSVMFilterObjectCascade **filters, int kComponents,
-                     const int *kPartFilters, 
-                     unsigned int *maxXBorder, unsigned int *maxYBorder);
-//}
-
-int getMaxFilterDims(const CvLSVMFilterObjectCascade **filters, int kComponents,
-                     const int *kPartFilters, 
-                     unsigned int *maxXBorder, unsigned int *maxYBorder);
-}
-}
+        // load cascade mode and initialize cascade
+        void loadCascadeModel(const std::string &modelPath);
+
+        // compute feature pyramid and projected feature pyramid
+        void computeFeatures(const Mat &im);
+
+        // compute root PCA scores
+        void computeRootPCAScores(std::vector< std::vector< Mat > > &rootScores);
+
+        // lookup or compute the score of a part at a location
+        double computePartScore(int plevel, int pId, int px, int py, bool isPCA, double defThreshold);
+
+        // compute location scores
+        void computeLocationScores(std::vector< std::vector< double > > &locctionScores);
+
+        // initialization pre-allocate storage
+        void initDPMCascade();
+
+        // cascade process
+        void process(std::vector< std::vector<double> > &detections);
+
+        // detect object from image
+        std::vector< std::vector<double> > detect(Mat &image);
+};
+
+#ifdef HAVE_TBB
+/** @brief This class convolves root PCA feature pyramid
+ * and root PCA filters in parallel using Intel Threading
+ * Building Blocks (TBB)
+ */
+class ParalComputeRootPCAScores : public ParallelLoopBody
+{
+    public:
+        // constructor
+        ParalComputeRootPCAScores(const std::vector< Mat > &pcaPyramid, const Mat &filter,\
+                int dim, std::vector< Mat > &scores);
+
+        // parallel loop body
+        void operator() (const Range &range) const;
+
+        ParalComputeRootPCAScores(const ParalComputeRootPCAScores &pComp);
+
+    private:
+        const std::vector< Mat > &pcaPyramid;
+        const Mat &filter;
+        int pcaDim;
+        std::vector< Mat > &scores;
+};
 #endif
+} // namespace dpm
+} // namespace cv
+
+#endif // __DPM_CASCADE_

modules/dpm/src/dpm_cascade_detector.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) 2015, Itseez 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 Itseez Inc 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 "dpm_cascade.hpp"
+
+using namespace std;
+
+namespace cv
+{
+namespace dpm
+{
+
+class DPMDetectorImpl : public DPMDetector
+{
+public:
+
+    DPMDetectorImpl( const vector<string>& filenames, const vector<string>& classNames=vector<string>() );
+    ~DPMDetectorImpl();
+
+    bool isEmpty() const;
+
+    void detect(Mat &image, CV_OUT vector<ObjectDetection>& objects);
+
+    const vector<string>& getClassNames() const;
+    size_t getClassCount() const;
+    string extractModelName( const string& filename );
+
+private:
+    vector< Ptr<DPMCascade> > detectors;
+    vector<string> classNames;
+};
+
+Ptr<DPMDetector> DPMDetector::create(vector<string> const &filenames,
+                                     vector<string> const &classNames)
+{
+    return makePtr<DPMDetectorImpl>(filenames, classNames);
+}
+
+DPMDetectorImpl::ObjectDetection::ObjectDetection()
+    : score(0.f), classID(-1) {}
+
+DPMDetectorImpl::ObjectDetection::ObjectDetection( const Rect& _rect, float _score, int _classID )
+    : rect(_rect), score(_score), classID(_classID) {}
+
+
+DPMDetectorImpl::DPMDetectorImpl( const vector<string>& filenames,
+        const vector<string>& _classNames )
+{
+    for( size_t i = 0; i < filenames.size(); i++ )
+    {
+        const string filename = filenames[i];
+        if( filename.length() < 5 || filename.substr(filename.length()-4, 4) != ".xml" )
+            continue;
+
+        Ptr<DPMCascade> detector = makePtr<DPMCascade>();
+
+        // initialization
+        detector->loadCascadeModel( filename.c_str() );
+
+        if( detector )
+        {
+            detectors.push_back( detector );
+            if( _classNames.empty() )
+            {
+                classNames.push_back( extractModelName(filename));
+            }
+            else
+                classNames.push_back( _classNames[i] );
+        }
+    }
+}
+
+DPMDetectorImpl::~DPMDetectorImpl()
+{
+}
+
+bool DPMDetectorImpl::isEmpty() const
+{
+    return detectors.empty();
+}
+
+const vector<string>& DPMDetectorImpl::getClassNames() const
+{
+    return classNames;
+}
+
+size_t DPMDetectorImpl::getClassCount() const
+{
+    return classNames.size();
+}
+
+string DPMDetectorImpl::extractModelName( const string& filename )
+{
+    size_t startPos = filename.rfind('/');
+    if( startPos == string::npos )
+        startPos = filename.rfind('\\');
+
+    if( startPos == string::npos )
+        startPos = 0;
+    else
+        startPos++;
+
+    const int extentionSize = 4; //.xml
+
+    int substrLength = (int)(filename.size() - startPos - extentionSize);
+
+    return filename.substr(startPos, substrLength);
+}
+
+void DPMDetectorImpl::detect( Mat &image,
+        vector<ObjectDetection> &objectDetections)
+{
+    objectDetections.clear();
+
+    for( size_t classID = 0; classID < detectors.size(); classID++ )
+    {
+        // detect objects
+        vector< vector<double> > detections;
+        detections = detectors[classID]->detect(image);
+
+        for (unsigned int i = 0; i < detections.size(); i++)
+        {
+            ObjectDetection ds = ObjectDetection();
+            int s = (int)detections[i].size() - 1;
+            ds.score = (float)detections[i][s];
+            int x1 = (int)detections[i][0];
+            int y1 = (int)detections[i][1];
+            int w = (int)detections[i][2] - x1 + 1;
+            int h = (int)detections[i][3] - y1 + 1;
+            ds.rect = Rect(x1, y1, w, h);
+            ds.classID = (int)classID;
+
+            objectDetections.push_back(ds);
+        }
+    }
+}
+
+} // namespace cv
+}

modules/latentsvm/src/precomp.hpp → modules/dpm/src/dpm_convolution.cpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,29 +39,43 @@
 //
 //M*/
 
-#ifndef __OPENCV_PRECOMP_H__
-#define __OPENCV_PRECOMP_H__
+#include "dpm_convolution.hpp"
 
-#ifdef HAVE_CVCONFIG_H
-#include "cvconfig.h"
-#endif
+namespace cv
+{
+namespace dpm
+{
+double ConvolutionEngine::convolve(const Mat &feat, const Mat &filter,
+        int dimHOG, int x, int y)
+{
+    double val = 0;
+    for (int xp = 0; xp < filter.cols; xp++)
+    {
+        for (int yp = 0; yp < filter.rows; yp++)
+            val += filter.at<double>(yp, xp)
+                * feat.at<double>(y + yp, x * dimHOG + xp);
+    }
 
-#ifdef __cplusplus
-#include <map>
-#include <deque>
-#endif
+    return val;
+}
 
-#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
+void ConvolutionEngine::convolve(const Mat &feat, const Mat &filter,
+        int dimHOG, Mat &result)
+{
+    for (int x = 0; x < result.cols; x++)
+    {
+        for (int y = 0; y < result.rows; y++)
+        {
+            double val = 0;
+            for (int xp = 0; xp < filter.cols; xp++)
+            {
+                for (int yp = 0; yp < filter.rows; yp++)
+                    val += feat.at<double>(y + yp, x*dimHOG + xp)
+                        * filter.at<double>(yp, xp);
+            } // xp
+            result.at<double>(y, x) = val;
+        } // y
+    } // x
+}
+} // namespace cv
+} // namespace dpm

modules/latentsvm/src/_lsvmc_function.h → modules/dpm/src/dpm_convolution.hpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,20 +39,36 @@
 //
 //M*/
 
-#ifndef FUNCTION_SC
-#define FUNCTION_SC
+#ifndef __DPM_CONVOLUTION__
+#define __DPM_CONVOLUTION__
 
-#include "_lsvmc_types.h"
+#include "opencv2/core.hpp"
+#include <vector>
 
 namespace cv
 {
-namespace lsvm
+namespace dpm
 {
+/** @brief This class contains DPM model parameters
+ */
+class ConvolutionEngine
+{
+    public:
+        // constructor
+        ConvolutionEngine() {}
+
+        // destructor
+        ~ConvolutionEngine() {}
+
+        // compute convolution value at a fixed location
+        double convolve(const Mat &feat, const Mat &filter,
+                int dimHOG, int x, int y);
 
-float calcM         (int k,int di,int dj, const CvLSVMFeaturePyramidCascade * H, const CvLSVMFilterObjectCascade *filter);
-float calcM_PCA     (int k,int di,int dj, const CvLSVMFeaturePyramidCascade * H, const CvLSVMFilterObjectCascade *filter);
-float calcM_PCA_cash(int k,int di,int dj, const CvLSVMFeaturePyramidCascade * H, const CvLSVMFilterObjectCascade *filter, float * cashM, int * maskM, int step);
-float calcFine (const CvLSVMFilterObjectCascade *filter, int di, int dj);
-}
-}
-#endif
+        // compute convolution of a feature map and multiple filters
+        // sum the filter convolution values into results
+        void convolve(const Mat &feat, const Mat &filter,
+                int dimHOG, Mat &result);
+};
+} // namespace dpm
+} // namespace cv
+#endif //__DPM_CONVOLUTION__

modules/dpm/src/dpm_feature.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) 2015, Itseez 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 Itseez Inc 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 "dpm_feature.hpp"
+
+using namespace std;
+
+namespace cv
+{
+namespace dpm
+{
+Feature::Feature()
+{
+}
+
+Feature::Feature (PyramidParameter p):params(p)
+{
+}
+
+void Feature::computeFeaturePyramid(const Mat &imageM, vector< Mat > &pyramid)
+{
+#ifdef HAVE_TBB
+    ParalComputePyramid paralTask(imageM, pyramid, params);
+    paralTask.initialize();
+    // perform parallel computing
+    parallel_for_(Range(0, params.interval), paralTask);
+#else
+    CV_Assert(params.interval > 0);
+    // scale factor between two levels
+    params.sfactor = pow(2.0, 1.0/params.interval);
+    const Size_<double> imSize = imageM.size();
+    params.maxScale = 1 + (int)floor(log(min(imSize.width, imSize.height)/
+                (float)(params.binSize*5.0))/log(params.sfactor));
+
+    if (params.maxScale < params.interval)
+    {
+        CV_Error(CV_StsBadArg, "The image is too small to create a pyramid");
+        return;
+    }
+
+    pyramid.resize(params.maxScale + params.interval);
+    params.scales.resize(params.maxScale + params.interval);
+
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+    for (int i = 0; i < params.interval; i++)
+    {
+        const double scale = (double)(1.0f/pow(params.sfactor, i));
+        Mat imScaled;
+        resize(imageM, imScaled, imSize * scale);
+        // First octave at twice the image resolution
+        computeHOG32D(imScaled, pyramid[i], params.binSize/2,
+                params.padx + 1, params.pady + 1);
+
+        params.scales[i] = 2*scale;
+
+        // Second octave at the original resolution
+        if (i + params.interval <= params.maxScale)
+            computeHOG32D(imScaled, pyramid[i+params.interval],
+                    params.binSize, params.padx + 1, params.pady + 1);
+
+        params.scales[i+params.interval] = scale;
+
+        // Remaining octaves
+        for ( int j = i + params.interval; j < params.maxScale; j += params.interval)
+        {
+            Mat imScaled2;
+            Size_<double> imScaledSize = imScaled.size();
+            resize(imScaled, imScaled2, imScaledSize*0.5);
+            imScaled = imScaled2;
+            computeHOG32D(imScaled2, pyramid[j+params.interval],
+                    params.binSize, params.padx + 1, params.pady + 1);
+            params.scales[j+params.interval] = params.scales[j]*0.5;
+        }
+    }
+#endif
+}
+
+#ifdef HAVE_TBB
+ParalComputePyramid::ParalComputePyramid(const Mat &inputImage, \
+        vector< Mat > &outputPyramid,\
+        PyramidParameter &p):
+    imageM(inputImage), pyramid(outputPyramid), params(p)
+{
+}
+
+void ParalComputePyramid::initialize()
+{
+    CV_Assert(params.interval > 0);
+
+    // scale factor between two levels
+    params.sfactor = pow(2.0, 1.0/params.interval);
+    imSize = imageM.size();
+    params.maxScale = 1 + (int)floor(log(min(imSize.width, imSize.height)/(float)(params.binSize*5.0))/log(params.sfactor));
+
+    if (params.maxScale < params.interval)
+    {
+        CV_Error(CV_StsBadArg, "The image is too small to create a pyramid");
+        return;
+    }
+
+    pyramid.resize(params.maxScale + params.interval);
+    params.scales.resize(params.maxScale + params.interval);
+}
+
+void ParalComputePyramid::operator() (const Range &range) const
+{
+    for (int i = range.start; i != range.end; i++)
+    {
+        const double scale = (double)(1.0f/pow(params.sfactor, i));
+        Mat imScaled;
+        resize(imageM, imScaled, imSize * scale);
+
+        params.scales[i] = 2*scale;
+
+        // First octave at twice the image resolution
+        Feature::computeHOG32D(imScaled, pyramid[i],
+                params.binSize/2, params.padx + 1, params.pady + 1);
+
+        // Second octave at the original resolution
+        if (i + params.interval <= params.maxScale)
+            Feature::computeHOG32D(imScaled, pyramid[i+params.interval],
+                    params.binSize, params.padx + 1, params.pady + 1);
+
+        params.scales[i+params.interval] = scale;
+
+        // Remaining octaves
+        for ( int j = i + params.interval; j < params.maxScale; j += params.interval)
+        {
+            Mat imScaled2;
+            Size_<double> imScaledSize = imScaled.size();
+            resize(imScaled, imScaled2, imScaledSize*0.5);
+            imScaled = imScaled2;
+            Feature::computeHOG32D(imScaled2, pyramid[j+params.interval],
+                    params.binSize, params.padx + 1, params.pady + 1);
+            params.scales[j+params.interval] = params.scales[j]*0.5;
+        }
+    }
+}
+#endif
+
+void Feature::computeHOG32D(const Mat &imageM, Mat &featM, const int sbin, const int pad_x, const int pad_y)
+{
+    CV_Assert(pad_x >= 0);
+    CV_Assert(pad_y >= 0);
+    CV_Assert(imageM.channels() == 3);
+    CV_Assert(imageM.depth() == CV_64F);
+
+    // epsilon to avoid division by zero
+    const double eps = 0.0001;
+    // number of orientations
+    const int numOrient = 18;
+    // unit vectors to compute gradient orientation
+    const double uu[9] = {1.000, 0.9397, 0.7660, 0.5000, 0.1736, -0.1736, -0.5000, -0.7660, -0.9397};
+    const double vv[9] = {0.000, 0.3420, 0.6428, 0.8660, 0.9848,  0.9848,  0.8660,  0.6428,  0.3420};
+
+    // image size
+    const Size imageSize = imageM.size();
+    // block size
+    int bW = (int)round((double)imageSize.width/(double)sbin);
+    int bH = (int)round((double)imageSize.height/(double)sbin);
+    const Size blockSize(bW, bH);
+    // size of HOG features
+    int oW = max(blockSize.width-2, 0) + 2*pad_x;
+    int oH = max(blockSize.height-2, 0) + 2*pad_y;
+    Size outSize = Size(oW, oH);
+    // size of visible
+    const Size visible = blockSize*sbin;
+
+    // initialize historgram, norm, output feature matrices
+    Mat histM = Mat::zeros(Size(blockSize.width*numOrient, blockSize.height), CV_64F);
+    Mat normM = Mat::zeros(Size(blockSize.width, blockSize.height), CV_64F);
+    featM = Mat::zeros(Size(outSize.width*dimHOG, outSize.height), CV_64F);
+
+    // get the stride of each matrix
+    const size_t imStride = imageM.step1();
+    const size_t histStride = histM.step1();
+    const size_t normStride = normM.step1();
+    const size_t featStride = featM.step1();
+
+    // calculate the zero offset
+    const double* im = imageM.ptr<double>(0);
+    double* const hist = histM.ptr<double>(0);
+    double* const norm = normM.ptr<double>(0);
+    double* const feat = featM.ptr<double>(0);
+
+    for (int y = 1; y < visible.height - 1; y++)
+    {
+        for (int x = 1; x < visible.width - 1; x++)
+        {
+            // OpenCV uses an interleaved format: BGR-BGR-BGR
+            const double* s = im + 3*min(x, imageM.cols-2) + min(y, imageM.rows-2)*imStride;
+
+            // blue image channel
+            double dyb = *(s+imStride) - *(s-imStride);
+            double dxb = *(s+3) - *(s-3);
+            double vb = dxb*dxb + dyb*dyb;
+
+            // green image channel
+            s += 1;
+            double dyg = *(s+imStride) - *(s-imStride);
+            double dxg = *(s+3) - *(s-3);
+            double vg = dxg*dxg + dyg*dyg;
+
+            // red image channel
+            s += 1;
+            double dy = *(s+imStride) - *(s-imStride);
+            double dx = *(s+3) - *(s-3);
+            double v = dx*dx + dy*dy;
+
+            // pick the channel with the strongest gradient
+            if (vg > v) { v = vg; dx = dxg; dy = dyg; }
+            if (vb > v) { v = vb; dx = dxb; dy = dyb; }
+
+            // snap to one of the 18 orientations
+            double best_dot = 0;
+            int best_o = 0;
+            for (int o = 0; o < (int)numOrient/2; o++)
+            {
+                double dot =  uu[o]*dx + vv[o]*dy;
+                if (dot > best_dot)
+                {
+                    best_dot = dot;
+                    best_o = o;
+                }
+                else if (-dot > best_dot)
+                {
+                    best_dot = -dot;
+                    best_o = o + (int)(numOrient/2);
+                }
+            }
+
+            // add to 4 historgrams around pixel using bilinear interpolation
+            double yp =  ((double)y+0.5)/(double)sbin - 0.5;
+            double xp =  ((double)x+0.5)/(double)sbin - 0.5;
+            int iyp = (int)floor(yp);
+            int ixp = (int)floor(xp);
+            double vy0 = yp - iyp;
+            double vx0 = xp - ixp;
+            double vy1 = 1.0 - vy0;
+            double vx1 = 1.0 - vx0;
+            v = sqrt(v);
+
+            // fill the value into the 4 neighborhood cells
+            if (iyp >= 0 && ixp >= 0)
+                *(hist + iyp*histStride + ixp*numOrient + best_o) += vy1*vx1*v;
+
+            if (iyp >= 0 && ixp+1 < blockSize.width)
+                *(hist + iyp*histStride + (ixp+1)*numOrient + best_o) += vx0*vy1*v;
+
+            if (iyp+1 < blockSize.height && ixp >= 0)
+                *(hist + (iyp+1)*histStride + ixp*numOrient + best_o) += vy0*vx1*v;
+
+            if (iyp+1 < blockSize.height && ixp+1 < blockSize.width)
+                *(hist + (iyp+1)*histStride + (ixp+1)*numOrient + best_o) += vy0*vx0*v;
+
+        } // for y
+    } // for x
+
+    // compute the energy in each block by summing over orientation
+    for (int y = 0; y < blockSize.height; y++)
+    {
+        const double* src = hist + y*histStride;
+        double* dst = norm + y*normStride;
+        double const* const dst_end = dst + blockSize.width;
+        // for each cell
+        while (dst < dst_end)
+        {
+            *dst = 0;
+            for (int o = 0; o < (int)(numOrient/2); o++)
+            {
+                *dst += (*src + *(src + numOrient/2))*
+                    (*src + *(src + numOrient/2));
+                src++;
+            }
+            dst++;
+            src += numOrient/2;
+        }
+    }
+
+    // compute the features
+    for (int y = pad_y; y < outSize.height - pad_y; y++)
+    {
+        for (int x = pad_x; x < outSize.width - pad_x; x++)
+        {
+            double* dst = feat + y*featStride + x*dimHOG;
+            double* p, n1, n2, n3, n4;
+            const double* src;
+
+            p = norm + (y - pad_y + 1)*normStride + (x - pad_x + 1);
+            n1 = 1.0f / sqrt(*p + *(p + 1) + *(p + normStride) + *(p + normStride + 1) + eps);
+            p = norm + (y - pad_y)*normStride + (x - pad_x + 1);
+            n2 = 1.0f / sqrt(*p + *(p + 1) + *(p + normStride) + *(p + normStride + 1) + eps);
+            p = norm + (y- pad_y + 1)*normStride + x - pad_x;
+            n3 = 1.0f / sqrt(*p + *(p + 1) + *(p + normStride) + *(p + normStride + 1) + eps);
+            p = norm + (y - pad_y)*normStride + x - pad_x;
+            n4 = 1.0f / sqrt(*p + *(p + 1) + *(p + normStride) + *(p + normStride + 1) + eps);
+
+            double t1 = 0.0, t2 = 0.0, t3 = 0.0, t4 = 0.0;
+
+            // contrast-sesitive features
+            src = hist + (y - pad_y + 1)*histStride + (x - pad_x + 1)*numOrient;
+            for (int o = 0; o < numOrient; o++)
+            {
+                double val = *src;
+                double h1 = min(val*n1, 0.2);
+                double h2 = min(val*n2, 0.2);
+                double h3 = min(val*n3, 0.2);
+                double h4 = min(val*n4, 0.2);
+                *(dst++) = 0.5 * (h1 + h2 + h3 + h4);
+                src++;
+                t1 += h1;
+                t2 += h2;
+                t3 += h3;
+                t4 += h4;
+            }
+
+            // contrast-insensitive features
+            src =  hist + (y - pad_y + 1)*histStride + (x - pad_x + 1)*numOrient;
+            for (int o = 0; o < numOrient/2; o++)
+            {
+                double sum = *src + *(src + numOrient/2);
+                double h1 = min(sum * n1, 0.2);
+                double h2 = min(sum * n2, 0.2);
+                double h3 = min(sum * n3, 0.2);
+                double h4 = min(sum * n4, 0.2);
+                *(dst++) = 0.5 * (h1 + h2 + h3 + h4);
+                src++;
+            }
+
+            // texture features
+            *(dst++) = 0.2357 * t1;
+            *(dst++) = 0.2357 * t2;
+            *(dst++) = 0.2357 * t3;
+            *(dst++) = 0.2357 * t4;
+
+            // truncation feature
+            *dst = 0;
+        }// for x
+    }// for y
+
+    // Truncation features
+    for (int m = 0; m < featM.rows; m++)
+    {
+        for (int n = 0; n < featM.cols; n += dimHOG)
+        {
+            if (m > pad_y - 1 && m < featM.rows - pad_y && n > pad_x*dimHOG - 1 && n < featM.cols - pad_x*dimHOG)
+                continue;
+
+            featM.at<double>(m, n + dimHOG - 1) = 1;
+        } // for x
+    }// for y
+}
+
+void Feature::projectFeaturePyramid(const Mat &pcaCoeff, const std::vector< Mat > &pyramid, std::vector< Mat > &projPyramid)
+{
+    CV_Assert(dimHOG == pcaCoeff.rows);
+    dimPCA = pcaCoeff.cols;
+
+    projPyramid.resize(pyramid.size());
+
+    // loop for each level of the pyramid
+    for (unsigned int i = 0; i < pyramid.size(); i++)
+    {
+        Mat orgM = pyramid[i];
+        // note that the features are stored in 32-32-32
+        int width = orgM.cols/dimHOG;
+        int height = orgM.rows;
+        // initialize the project feature matrix
+        Mat projM = Mat::zeros(height, width*dimPCA, CV_64F);
+        //get the pointer of the matrix
+        double* const featOrg = orgM.ptr<double>(0);
+        double* const featProj = projM.ptr<double>(0);
+
+        // get the stride of each matrix
+        const size_t orgStride = orgM.step1();
+        const size_t projStride = projM.step1();
+
+        for (int y = 0; y < height; y++)
+        {
+            for (int x = 0; x < width; x++)
+            {
+                double* proj = featProj + y*projStride + x*dimPCA;
+                // for each pca dimension
+                for (int c = 0; c < dimPCA; c++)
+                {
+                    double* org = featOrg + y*orgStride + x*dimHOG;
+                    // dot product 32d HOG feature with the coefficient vector
+                    for (int r = 0; r < dimHOG; r++)
+                    {
+                        *proj += *org * pcaCoeff.at<double>(r, c);
+                        org++;
+                    }
+                    proj++;
+                }
+
+            } // for x
+        } // for y
+        projPyramid[i] = projM;
+    } // for each level of the pyramid
+}
+
+void Feature::computeLocationFeatures(const int numLevels, Mat &locFeature)
+{
+    locFeature = Mat::zeros(Size(numLevels, 3), CV_64F);
+
+    int b = 0;
+    int e = min(numLevels, params.interval);
+
+    for (int x = b; x < e; x++)
+        locFeature.at<double>(0, x) = 1;
+
+    b = e;
+    e = min(numLevels, 2*e);
+
+    for (int x = b; x < e; x++)
+        locFeature.at<double>(1, x) = 1;
+
+    b = e;
+    e = min(numLevels, 3*e);
+
+    for (int x = b; x < e; x++)
+        locFeature.at<double>(2, x) = 1;
+}
+} // namespace dpm
+} // namespace cv

modules/latentsvm/src/_lsvmc_routine.h → modules/dpm/src/dpm_feature.hpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,38 +39,135 @@
 //
 //M*/
 
-#ifndef _LSVM_ROUTINE_H_
-#define _LSVM_ROUTINE_H_
+#ifndef __DPM_FEATURE__
+#define __DPM_FEATURE__
 
-#include "_lsvmc_types.h"
-#include "_lsvmc_error.h"
+#include "opencv2/core.hpp"
+#include "opencv2/core/core_c.h"
+#include "opencv2/imgproc.hpp"
+
+#include <string>
+#include <vector>
 
 namespace cv
 {
-namespace lsvm
+namespace dpm
+{
+// parameters of the feature pyramid
+class PyramidParameter
 {
+    public:
+        // number of levels per octave in feature pyramid
+        int interval;
+        // HOG cell size
+        int binSize;
+        // horizontal padding (in cells)
+        int padx;
+        // vertical padding (in cells)
+        int pady;
+        // scale factor
+        double sfactor;
+        // maximum number of scales in the pyramid
+        int maxScale;
+        // scale of each level
+        std::vector< double > scales;
+
+    public:
+        PyramidParameter()
+        {
+            // default parameters
+            interval = 10;
+            binSize = 8;
+            padx = 0;
+            pady = 0;
+            sfactor = 1.0;
+            maxScale = 0;
+        }
+
+        ~PyramidParameter() {}
+};
+
+/** @brief This class contains DPM model parameters
+ */
+class Feature
+{
+    public:
+        // dimension of the HOG features in a sigle cell
+        static const int dimHOG = 32;
+        // top dimPCA PCA eigenvectors
+        int dimPCA;
+
+        // set pyramid parameter
+        void setPyramidParameters(PyramidParameter val)
+        {
+            params = val;
+        }
+
+        // returns pyramid parameters
+        PyramidParameter getPyramidParameters()
+        {
+            return params;
+        }
+
+        // constructor
+        Feature ();
 
+        // constructor with parameters
+        Feature (PyramidParameter p);
 
-//////////////////////////////////////////////////////////////
-// 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(CvLSVMFilterObjectCascade **obj, const int sizeX, const int sizeY, 
-                      const int p);
-int freeFilterObject (CvLSVMFilterObjectCascade **obj);
+        // destrcutor
+        ~Feature () {}
 
-int allocFeatureMapObject(CvLSVMFeatureMapCascade **obj, const int sizeX, const int sizeY,
-                          const int p);
-int freeFeatureMapObject (CvLSVMFeatureMapCascade **obj);
+        // compute feature pyramid
+        void computeFeaturePyramid(const Mat &imageM, std::vector< Mat > &pyramid);
 
-int allocFeaturePyramidObject(CvLSVMFeaturePyramidCascade **obj, 
-                              const int countLevel);
+        // project the feature pyramid with PCA coefficient matrix
+        void projectFeaturePyramid(const Mat &pcaCoeff, const std::vector< Mat > &pyramid, std::vector< Mat > &projPyramid);
 
-int freeFeaturePyramidObject (CvLSVMFeaturePyramidCascade **obj);
+        // compute 32 dimension HOG as described in
+        // "Object Detection with Discriminatively Trained Part-based Models"
+        // by Felzenszwalb, Girshick, McAllester and Ramanan, PAMI 2010
+        static void computeHOG32D(const Mat &imageM, Mat &featM, const int sbin, const int padx, const int pady);
 
-}
-}
+        // compute location features
+        void computeLocationFeatures(const int numLevels, Mat &locFeature);
+
+    private:
+        PyramidParameter params;
+
+};
+
+#ifdef HAVE_TBB
+/** @brief This class computes feature pyramid in parallel
+ * using Intel Threading Building Blocks (TBB)
+ */
+class ParalComputePyramid : public ParallelLoopBody
+{
+    public:
+        // constructor
+        ParalComputePyramid(const Mat &inputImage, \
+                std::vector< Mat > &outputPyramid,\
+                PyramidParameter &p);
+
+        // initializate parameters
+        void initialize();
+
+        // parallel loop body
+        void operator() (const Range &range) const;
+
+    private:
+        // image to compute feature pyramid
+        const Mat &imageM;
+        // image size
+        Size_<double> imSize;
+        // output feature pyramid
+        std::vector< Mat > &pyramid;
+        // pyramid parameters
+        PyramidParameter &params;
+};
 #endif
+
+} // namespace dpm
+} // namespace cv
+
+#endif // __DPM_FEATURE_

modules/latentsvm/src/_lsvmc_types.h → modules/dpm/src/dpm_model.cpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,148 +39,169 @@
 //
 //M*/
 
-#ifndef SVM_TYPE
-#define SVM_TYPE
+#include "dpm_model.hpp"
 
-#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
+namespace dpm
 {
-//////////////////////////////////////////////////////////////
-// 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
+void CascadeModel::initModel()
 {
-    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;
-} CvLSVMFeatureMapCascade;
-
-// 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;
-    CvLSVMFeatureMapCascade **pyramid;
-} CvLSVMFeaturePyramidCascade;
-
-// 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
+    CV_Assert(numComponents == (int)rootFilters.size());
+    // map: pFind[component][part] => part filter index
+    pFind.resize(numComponents);
+    int np = (int) partFilters.size();
+    rootFilterDims.resize(numComponents);
+    partFilterDims.resize(np);
+
+    int w, h; // width and height of the filter
+    int pIndex = 0; // part index
+
+    for (int comp  = 0; comp < numComponents; comp++)
+    {
+        w = rootFilters[comp].cols/numFeatures;
+        h = rootFilters[comp].rows;
+        rootFilterDims[comp] = Size(w, h);
+        pFind[comp].resize(numParts[comp]);
+
+        for (int part = 0; part < numParts[comp]; part++)
+        {
+            w = partFilters[pIndex].cols/numFeatures;
+            h = partFilters[pIndex].rows;
+            partFilterDims[pIndex] = Size(w, h);
+            pFind[comp][part] = pIndex;
+            pIndex++;
+        }
+    }
+
+    CV_Assert(pIndex == np);
+    CV_Assert(pIndex == (int)anchors.size());
+    CV_Assert(pIndex == (int)defs.size());
+}
+
+bool CascadeModel::serialize(const std::string &filename) const
 {
-    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 CvLSVMFilterObjectCascade{
-    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;
-} CvLSVMFilterObjectCascade;
-
-// 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 CvLatentSvmDetectorCascade
+    // open the storage container for writing
+    FileStorage fs;
+    fs.open(filename, FileStorage::WRITE);
+
+    // write the primitives
+    fs << "SBin" << sBin;
+    fs << "Interval" << interval;
+    fs << "MaxSizeX" << maxSizeX;
+    fs << "MaxSizeY" << maxSizeY;
+    fs << "NumComponents" << numComponents;
+    fs << "NumFeatures" << numFeatures;
+    fs << "PCADim" << pcaDim;
+    fs << "ScoreThreshold" << scoreThresh;
+    fs << "PCAcoeff" << pcaCoeff;
+    fs << "Bias" << bias;
+
+    // write the filters
+    fs << "RootFilters" << rootFilters;
+    fs << "RootPCAFilters" << rootPCAFilters;
+    fs << "PartFilters" << partFilters;
+    fs << "PartPCAFilters" << partPCAFilters;
+
+    // write the pruning threshold
+    fs << "PrunThreshold" << "[";
+    for (unsigned int i = 0; i < prunThreshold.size(); i++)
+        fs << prunThreshold[i];
+    fs << "]";
+
+    // write anchor points
+    fs << "Anchor" << "[";
+    for (unsigned int i = 0; i < anchors.size(); i++)
+        fs << anchors[i];
+    fs << "]";
+
+    // write deformation
+    fs << "Deformation" << "[";
+    for (unsigned int i = 0; i < defs.size(); i++)
+        fs << defs[i];
+    fs << "]";
+
+    // write number of parts
+    fs << "NumParts" << numParts;
+
+    // write part order
+    fs << "PartOrder" << "[";
+    for (unsigned int i = 0; i < partOrder.size(); i++)
+        fs << partOrder[i];
+    fs << "]";
+
+    // write location weight
+    fs << "LocationWeight" << "[";
+    for (unsigned int i = 0; i < locationWeight.size(); i++)
+        fs << locationWeight[i];
+    fs << "]";
+
+    fs.release();
+
+    return true;
+}
+
+bool CascadeModel::deserialize(const std::string &filename)
 {
-    int num_filters;
-    int num_components;
-    int* num_part_filters;
-    CvLSVMFilterObjectCascade** filters;
-    float* b;
-    float score_threshold;
-    float *pca;
-    int pca_size;
-} CvLatentSvmDetectorCascade;
+    FileStorage fs;
+    bool is_ok = fs.open(filename, FileStorage::READ);
+
+    if (!is_ok) return false;
+
+    fs["SBin"] >> sBin;
+    fs["Interval"] >> interval;
+    fs["MaxSizeX"] >> maxSizeX;
+    fs["MaxSizeY"] >> maxSizeY;
+    fs["NumComponents"] >> numComponents;
+    fs["NumFeatures"] >> numFeatures;
+    fs["PCADim"] >> pcaDim;
+    fs["ScoreThreshold"] >> scoreThresh;
+    fs["PCAcoeff"] >> pcaCoeff;
+    fs["Bias"] >> bias;
+    fs["RootFilters"] >> rootFilters;
+    fs["RootPCAFilters"] >> rootPCAFilters;
+    fs["PartFilters"] >> partFilters;
+    fs["PartPCAFilters"] >> partPCAFilters;
+
+    // read pruning threshold
+    FileNode nodePrun = fs["PrunThreshold"];
+    prunThreshold.resize(nodePrun.size());
+    for (unsigned int i = 0; i < prunThreshold.size(); i++)
+        nodePrun[i] >> prunThreshold[i];
+
+    // read anchor points
+    FileNode nodeAnchor = fs["Anchor"];
+    anchors.resize(nodeAnchor.size());
+    for (unsigned int i = 0; i < anchors.size(); i++)
+        nodeAnchor[i] >> anchors[i];
+
+    // read deformation
+    FileNode nodeDef = fs["Deformation"];
+    defs.resize(nodeDef.size());
+    for (unsigned int i = 0; i < nodeDef.size(); i++)
+        nodeDef[i] >> defs[i];
+
+    // read number of parts in each component
+    fs["NumParts"] >> numParts;
+
+    // read part order
+    FileNode nodeOrder = fs["PartOrder"];
+    partOrder.resize(nodeOrder.size());
+    for (unsigned int i = 0; i < nodeOrder.size(); i++)
+        nodeOrder[i] >> partOrder[i];
+
+    // read location weight
+    FileNode nodeLoc = fs["LocationWeight"];
+    locationWeight.resize(nodeLoc.size());
+    for (unsigned int i = 0; i < locationWeight.size(); i++)
+        nodeLoc[i] >> locationWeight[i];
+
+    // close the file store
+    fs.release();
+
+    return true;
+}
+
 }
 }
-#endif

modules/latentsvm/src/_lsvmc_parser.h → modules/dpm/src/dpm_model.hpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,90 +39,110 @@
 //
 //M*/
 
-#ifndef LSVM_PARSER
-#define LSVM_PARSER
+#ifndef __DPM_MODEL__
+#define __DPM_MODEL__
 
-#include "_lsvmc_types.h"
+#include "opencv2/core.hpp"
 
-#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
+#include <string>
+#include <vector>
 
-#define PCA          5
-#define WEIGHTSPCA   162
-#define CASCADE_Th   163
-#define HYPOTHES_PCA 164
-#define DEFORM_PCA   165
-#define HYPOTHES     166
-#define DEFORM       167
+namespace cv
+{
+namespace dpm
+{
+/** @brief This class contains DPM model parameters
+ */
+class Model
+{
+    public:
+        // size of HOG feature cell (e.g., 8 pixels)
+        int sBin;
+        // number of levels per octave in feature pyramid
+        int interval;
+        // maximum width of the detection window
+        int maxSizeX;
+        // maximum height of the detection window
+        int maxSizeY;
+        // dimension of HOG features
+        int numFeatures;
+        // number of components in the model
+        int numComponents;
+        // number of parts per component
+        std::vector<int> numParts;
+        // size of root filters
+        std::vector< Size > rootFilterDims;
+        // size of part filters
+        std::vector< Size > partFilterDims;
+        // root filters
+        std::vector< Mat > rootFilters;
+        // part filters
+        std::vector< Mat > partFilters;
+        // global detecion threshold
+        float scoreThresh;
+        // component indexed array of part orderings
+        std::vector< std::vector<int> > partOrder;
+        // component indexed offset (a.k.a. bias) values
+        std::vector<float> bias;
+        // location/scale weight
+        std::vector< std::vector< double > >  locationWeight;
+        // idea relative positions for each deformation model
+        std::vector< std::vector< double > >  anchors;
+        // array of deformation models
+        std::vector< std::vector< double > > defs;
 
-#define PCACOEFF     6
+        // map: pFind[component][part] => part filter index
+        std::vector< std::vector<int> > pFind;
 
-#define STEP_END 1000
+    private:
+        // number of part filters and deformation model
+        int numPartFilters;
+        int numDefParams;
 
-#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)
+    public:
+        Model () {}
+        virtual ~Model () {}
 
-#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)
+        // get number of part filters
+        int getNumPartFilters()
+        {
+            return (int) partFilters.size();
+        }
 
-#define EPCACOEFF     (STEP_END + PCACOEFF)
+        // get number of deformation parameters
+        int getNumDefParams()
+        {
+            return (int) defs.size();
+        }
 
-namespace cv
-{
-namespace lsvm
+        virtual void initModel() {};
+        virtual bool serialize(const std::string &filename) const = 0;
+        virtual bool deserialize(const std::string &filename) = 0;
+};
+
+class CascadeModel : public Model
 {
+    public:
+        // PCA coefficient matrix
+        Mat pcaCoeff;
+        // number of dimensions used for the PCA projection
+        int pcaDim;
+        // component indexed arrays of pruning threshold
+        std::vector< std::vector< double > >  prunThreshold;
+        // root pca filters
+        std::vector< Mat > rootPCAFilters;
+        // part PCA filters
+        std::vector< Mat > partPCAFilters;
+    public:
+        CascadeModel() {}
+        ~CascadeModel() {}
+
+        void initModel();
+        bool serialize(const std::string &filename) const;
+        bool deserialize(const std::string &filename);
+};
+
+} // namespace lsvm
+} // namespace cv
 
-    int loadModel(
-             // input parametr
-              const char *modelPath,// model path
-             
-              // output parametrs
-              CvLSVMFilterObjectCascade ***filters,
-              int *kFilters, 
-              int *kComponents, 
-              int **kPartFilters, 
-              float **b,
-              float *scoreThreshold,
-              float ** PCAcoeff);
-}
-}
-#endif
+#endif // __DPM_MODEL_

modules/latentsvm/src/lsvmc_function.cpp → modules/dpm/src/dpm_nms.cpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,89 +39,114 @@
 //
 //M*/
 
-#include "precomp.hpp"
-#include "_lsvmc_function.h"
+#include "dpm_nms.hpp"
+
+using namespace std;
+
 namespace cv
 {
-namespace lsvm
+namespace dpm
 {
 
-float calcM    (int k,int di,int dj, const CvLSVMFeaturePyramidCascade * H, const CvLSVMFilterObjectCascade *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];            
+void NonMaximumSuppression::sort(const vector< double > x, vector< int > &indices)
+{
+    for (unsigned int i = 0; i < x.size(); i++)
+    {
+        for (unsigned int j = i + 1; j < x.size(); j++)
+        {
+            if (x[indices[j]] < x[indices[i]])
+            {
+                int tmp = indices[i];
+                indices[i] = indices[j];
+                indices[j] = tmp;
+            }
         }
     }
-    return m;
 }
-float calcM_PCA(int k,int di,int dj, const CvLSVMFeaturePyramidCascade * H, const CvLSVMFilterObjectCascade *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 CvLSVMFeaturePyramidCascade * H, const CvLSVMFilterObjectCascade *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;
+void NonMaximumSuppression::process(vector< vector< double > > &detections, double overlapThreshold)
+{
+    int numBoxes = (int) detections.size();
+
+    if (numBoxes <= 0)
+        return;
+
+    vector< double > area(numBoxes);
+    vector< double > score(numBoxes);
+    vector< int > indices(numBoxes);
+
+    for (int i = 0; i < numBoxes; i++)
+    {
+        indices[i] = i;
+        int s = (int)detections[i].size();
+        double x1 = detections[i][0];
+        double y1 = detections[i][1];
+        double x2 = detections[i][2];
+        double y2 = detections[i][3];
+        double sc = detections[i][s-1];
+        score[i] = sc;
+        area[i] = (x2 - x1 + 1) * ( y2 - y1 + 1);
+    }
 
-    pos = dj * step + di;
+    // sort boxes by score
+    sort(score, indices);
+    vector< int > pick;
+    vector< int > suppress;
 
-    if(!((maskM[pos / (sizeof(int) * 8)]) & (1 << pos % (sizeof(int) * 8))))
+    while (indices.size() > 0)
     {
-        for(j = dj; j < dj + filter->sizeY; j++)
+        int last = (int) indices.size() - 1;
+        int i = indices[last];
+        pick.push_back(i);
+        suppress.clear();
+        suppress.push_back(last);
+
+        for (int k = 0; k <= last - 1; k++)
         {
-            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)
+            int j = indices[k];
+            double xx1 = max(detections[i][0], detections[j][0]);
+            double yy1 = max(detections[i][1], detections[j][1]);
+            double xx2 = min(detections[i][2], detections[j][2]);
+            double yy2 = min(detections[i][3], detections[j][3]);
+
+            double w = xx2 - xx1 + 1;
+            double h = yy2 - yy1 + 1;
+
+            if (w > 0 && h > 0)
             {
-                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];
+                // compute overlap
+                double o = w*h / area[j];
+                if (o > overlapThreshold)
+                    suppress.push_back(k);
             }
-            
-            for (i = (n >> 2) << 2; i < n; ++i) //?
+        } // k
+
+        // remove suppressed indices
+        vector< int > newIndices;
+        for (unsigned int n = 0; n < indices.size(); n++)
+        {
+            bool isSuppressed = false;
+            for (unsigned int r = 0; r < suppress.size(); r++)
             {
-                res += a[i] * b[i];
+                if (n == (unsigned int)suppress[r])
+                {
+                    isSuppressed = true;
+                    break;
+                }
             }
 
-            res += tmp1 + tmp2 + tmp3 + tmp4;
-
-            m += res;
+            if (!isSuppressed)
+                newIndices.push_back(indices[n]);
         }
+        indices = newIndices;
+    } // while
 
-        cashM[pos                    ]  = m;
-        maskM[pos / (sizeof(int) * 8)] |= 1 << pos % (sizeof(int) * 8);
-    }
-    else
-    {
-        m = cashM[pos];
-    }
-    return m;
-}
-float calcFine (const CvLSVMFilterObjectCascade *filter, int di, int dj){
-    return filter->fineFunction[0] * di      + filter->fineFunction[1] * dj + 
-           filter->fineFunction[2] * di * di + filter->fineFunction[3] * dj * dj;
-}
-}
+    vector< vector< double > > newDetections(pick.size());
+    for (unsigned int i = 0; i < pick.size(); i++)
+        newDetections[i] = detections[pick[i]];
+
+    detections = newDetections;
 }
+
+} // dpm
+} // cv

modules/latentsvm/src/lsvmc_resizeimg.cpp → modules/dpm/src/dpm_nms.hpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -38,34 +38,29 @@
 // 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>
+#ifndef __DPM_NMS__
+#define __DPM_NMS__
+#include <vector>
 
 namespace cv
 {
-namespace lsvm
+namespace dpm
 {
-
-IplImage* resize_opencv(IplImage* img, float scale)
+/** @brief Non-maximum suppression
+ * Greedily select high-scoring detections and skip
+ * detections that are significantly covered by a
+ * previously selected detection.
+ */
+class NonMaximumSuppression
 {
-    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);
+    public:
+        NonMaximumSuppression() {}
+        ~NonMaximumSuppression() {}
 
-    imgTmp = cvCreateImage(cvSize(tW , tH), img->depth, img->nChannels);
-    cvResize(img, imgTmp, CV_INTER_AREA);
+        void sort(const std::vector< double > x, std::vector< int > &indices);
 
-    return imgTmp;
-}
-}
-}
+        void process(std::vector< std::vector< double > > &detections, double overlapThreshold);
+};
+} // dpm
+} // cv
+#endif // __DPM_NMS__

modules/latentsvm/src/precomp.cpp → modules/dpm/src/precomp.cpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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

modules/latentsvm/src/_lsvmc_resizeimg.h → modules/dpm/src/precomp.hpp

@@ -10,7 +10,7 @@
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2010-2013, University of Nizhny Novgorod, all rights reserved.
+// Copyright (C) 2015, Itseez 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,
@@ -29,7 +29,7 @@
 // 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,
+// In no event shall the Itseez Inc 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
@@ -39,18 +39,17 @@
 //
 //M*/
 
-#ifndef _LSVM_RESIZEIMG_H_
-#define _LSVM_RESIZEIMG_H_
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
 
-#include "_lsvmc_types.h"
+#ifdef HAVE_CVCONFIG_H
+#include "cvconfig.h"
+#endif
 
-namespace cv
-{
-namespace lsvm
-{
+#include "opencv2/dpm.hpp"
 
-IplImage * resize_opencv (IplImage * img, float scale);
-}
-}
+#ifdef HAVE_TEGRA_OPTIMIZATION
+#include "opencv2/objdetect/objdetect_tegra.hpp"
+#endif
 
 #endif

modules/latentsvm/CMakeLists.txt

-set(the_description "Object Detection")
-ocv_define_module(latentsvm opencv_core opencv_imgproc opencv_objdetect OPTIONAL opencv_highgui WRAP python)

modules/latentsvm/README.md

-Implementation of the LatentSVM detector algorithm
-==================================================

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_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(CvLSVMFeaturePyramidCascade* H, int maxX, int maxY);
-
-/*
-// Creation PCA feature pyramid
-//
-// API
-// featurePyramid* createPCA_FeaturePyramid(featurePyramid* H);
-
-// INPUT
-// H                 - feature pyramid     
-// OUTPUT
-// RESULT
-// PCA feature pyramid
-*/
-CvLSVMFeaturePyramidCascade* createPCA_FeaturePyramid(CvLSVMFeaturePyramidCascade* H, 
-                                               CvLatentSvmDetectorCascade* detector, 
-                                               int maxX, int maxY);
-
-/*
-// Getting feature pyramid  
-//
-// API
-// int getFeaturePyramid(IplImage * image, const CvLSVMFilterObjectCascade **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, CvLSVMFeaturePyramidCascade **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, CvLSVMFeatureMapCascade **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(CvLSVMFeatureMapCascade *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(CvLSVMFeatureMapCascade *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
-*/
-CvLSVMFeaturePyramidCascade* createFeaturePyramidWithBorder(IplImage *image,
-                                               int maxXBorder, int maxYBorder);
-
-/*
-// Computation root filters displacement and values of score function
-//
-// API
-// int searchObjectThresholdSomeComponents(const featurePyramid *H,
-                                           const CvLSVMFilterObjectCascade **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 CvLSVMFeaturePyramidCascade *H,
-										const CvLSVMFeaturePyramidCascade *H_PCA,
-                                        const CvLSVMFilterObjectCascade **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 CvLSVMFilterObjectCascade *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 CvLSVMFilterObjectCascade *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 CvLSVMFilterObjectCascade *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 CvLSVMFilterObjectCascade **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_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, CvLSVMFeaturePyramidCascade **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, CvLSVMFeatureMapCascade **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(CvLSVMFeatureMapCascade *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(CvLSVMFeatureMapCascade *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, CvLSVMFeaturePyramidCascade **maps)
-{
-    CvLSVMFeatureMapCascade *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;
-    CvLSVMFeaturePyramidCascade **maps;
-
-    void operator() (const Range& range) const
-    {
-        CvLSVMFeatureMapCascade *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, CvLSVMFeaturePyramidCascade **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 CvLSVMFilterObjectCascade **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, CvLSVMFeaturePyramidCascade **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_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 CvLSVMFeaturePyramidCascade *H,
-                          const CvLSVMFeaturePyramidCascade *H_PCA,
-                          const CvLSVMFilterObjectCascade **all_F, int n,
-                          float b,
-                          int maxXBorder, int maxYBorder,
-                          float scoreThreshold,
-                          CvPoint **points, int **levels, int *kPoints,
-                          float **score, CvPoint ***partsDisplacement);
-
-void FeaturePyramid32(CvLSVMFeaturePyramidCascade* H, int maxX, int maxY){
-    CvLSVMFeatureMapCascade *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;
-            }
-        }
-    }
-}
-
-CvLSVMFeaturePyramidCascade* createPCA_FeaturePyramid(CvLSVMFeaturePyramidCascade* H, CvLatentSvmDetectorCascade* detector, int maxX, int maxY){
-    CvLSVMFeaturePyramidCascade *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
-*/
-CvLSVMFeaturePyramidCascade* createFeaturePyramidWithBorder(IplImage *image,
-                                               int maxXBorder, int maxYBorder)
-{
-    int opResult;
-    int bx, by;
-    int level;
-    CvLSVMFeaturePyramidCascade *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 CvLSVMFilterObjectCascade **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 CvLSVMFeaturePyramidCascade *H,
-                          const CvLSVMFeaturePyramidCascade *H_PCA,
-                          const CvLSVMFilterObjectCascade **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 CvLSVMFilterObjectCascade *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 CvLSVMFilterObjectCascade *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 CvLSVMFilterObjectCascade *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 CvLSVMFilterObjectCascade **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 CvLSVMFilterObjectCascade **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 CvLSVMFilterObjectCascade **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 CvLSVMFeaturePyramidCascade *H;
-    const CvLSVMFeaturePyramidCascade *H_PCA;
-    const CvLSVMFilterObjectCascade **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 CvLSVMFeaturePyramidCascade *_H,
-    const CvLSVMFeaturePyramidCascade *_H_PCA,
-    const CvLSVMFilterObjectCascade **_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 CvLSVMFilterObjectCascade **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 CvLSVMFeaturePyramidCascade *H,
-                                        const CvLSVMFeaturePyramidCascade *H_PCA,
-                                        const CvLSVMFilterObjectCascade **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;
-
-CvLatentSvmDetectorCascade* cvLoadLatentSvmDetectorCascade(const char* filename);
-void cvReleaseLatentSvmDetectorCascade(CvLatentSvmDetectorCascade** detector);
-CvSeq* cvLatentSvmDetectObjectsCascade(IplImage* image,
-                                CvLatentSvmDetectorCascade* detector,
-                                CvMemStorage* storage,
-                                float overlap_threshold);
-
-/*
-// load trained detector from a file
-//
-// API
-// CvLatentSvmDetectorCascade* 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
-*/
-CvLatentSvmDetectorCascade* cvLoadLatentSvmDetectorCascade(const char* filename)
-{
-    CvLatentSvmDetectorCascade* detector = 0;
-    CvLSVMFilterObjectCascade** 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 = (CvLatentSvmDetectorCascade*)malloc(sizeof(CvLatentSvmDetectorCascade));
-    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 CvLatentSvmDetectorCascade structure
-//
-// API
-// void cvReleaseLatentSvmDetector(CvLatentSvmDetectorCascade** detector);
-// INPUT
-// detector             - CvLatentSvmDetectorCascade structure to be released
-// OUTPUT
-*/
-void cvReleaseLatentSvmDetectorCascade(CvLatentSvmDetectorCascade** 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,
-//                                  CvLatentSvmDetectorCascade* 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* cvLatentSvmDetectObjectsCascade(IplImage* image,
-                                CvLatentSvmDetectorCascade* detector,
-                                CvMemStorage* storage,
-                                float overlap_threshold)
-{
-    CvLSVMFeaturePyramidCascade *H = 0;
-	CvLSVMFeaturePyramidCascade *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 CvLSVMFilterObjectCascade**)(detector->filters), detector->num_components,
-                     detector->num_part_filters, &maxXBorder, &maxYBorder);
-    // Create feature pyramid with nullable border
-    H = createFeaturePyramidWithBorder(image, maxXBorder, maxYBorder);
-	
-	// Create PCA feature pyramid
-    H_PCA = createPCA_FeaturePyramid(H, detector, maxXBorder, maxYBorder);
-    
-    FeaturePyramid32(H, maxXBorder, maxYBorder);
-	
-    // Search object
-    error = searchObjectThresholdSomeComponents(H, H_PCA,(const CvLSVMFilterObjectCascade**)(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<CvLatentSvmDetectorCascade*> 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;
-
-        CvLatentSvmDetectorCascade* detector = cvLoadLatentSvmDetectorCascade( 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::cvReleaseLatentSvmDetectorCascade(&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::cvLatentSvmDetectObjectsCascade( &image_ipl, (CvLatentSvmDetectorCascade*)(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(CvLSVMFeatureMapCascade *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 CvLSVMFilterObjectCascade **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 CvLSVMFilterObjectCascade **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(CvLSVMFilterObjectCascade *** model, int *last, int *max);
-
-void parserCascadeThresholds  (FILE * xmlf, CvLSVMFilterObjectCascade * model);
-
-void parserRFilter  (FILE * xmlf, int p, int pca, CvLSVMFilterObjectCascade * model, float *b);
-
-void parserV  (FILE * xmlf, int /*p*/, CvLSVMFilterObjectCascade * model);
-
-void parserD  (FILE * xmlf, int /*p*/, CvLSVMFilterObjectCascade * model);
-
-void parserPFilter  (FILE * xmlf, int p, int pca, int /*N_path*/, CvLSVMFilterObjectCascade * model);
-
-void parserPFilterS (FILE * xmlf, int p, int pca, CvLSVMFilterObjectCascade *** model, int *last, int *max);
-
-void parserComp (FILE * xmlf, int p, int pca, int *N_comp, CvLSVMFilterObjectCascade *** model, float *b, int *last, int *max);
-
-void parserModel(FILE * xmlf, CvLSVMFilterObjectCascade *** model, int *last, int *max, int **comp, float **b, int *count, float * score, float** PCAcoeff);
-
-void LSVMparser(const char * filename,
-                CvLSVMFilterObjectCascade *** 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(CvLSVMFilterObjectCascade *** model, int *last, int *max)
-{
-    CvLSVMFilterObjectCascade ** nmodel;
-    int i;
-    (*last) ++;
-    if((*last) >= (*max)){
-        (*max) += 10;
-        nmodel = (CvLSVMFilterObjectCascade **)malloc(sizeof(CvLSVMFilterObjectCascade *) * (*max));
-        for(i = 0; i < *last; i++){
-            nmodel[i] = (* model)[i];
-        }
-        free(* model);
-        (*model) = nmodel;
-    }
-    (*model) [(*last)] = (CvLSVMFilterObjectCascade *)malloc(sizeof(CvLSVMFilterObjectCascade));
-    (*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, CvLSVMFilterObjectCascade * 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, CvLSVMFilterObjectCascade * 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*/, CvLSVMFilterObjectCascade * 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*/, CvLSVMFilterObjectCascade * 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*/, CvLSVMFilterObjectCascade * 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, CvLSVMFilterObjectCascade *** 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, CvLSVMFilterObjectCascade *** 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, CvLSVMFilterObjectCascade *** 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, 
-                CvLSVMFilterObjectCascade *** 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) = (CvLSVMFilterObjectCascade ** )malloc((sizeof(CvLSVMFilterObjectCascade * )) * (*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,
-             
-              CvLSVMFilterObjectCascade ***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/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 LatentSVMDetectorCascadeTest : 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 LatentSVMDetectorCascadeTest::run( int /* start_from */)
-{
-    std::string test_data_path = ts->get_data_path() + "latentsvmdetector/";
-    std::string img_path_cat = test_data_path  + "cat.png";
-    std::string img_path_cars = test_data_path + "cars.png";
-
-    std::string model_path_cat = test_data_path + "models_VOC2007_cascade/cat.xml";
-    std::string model_path_car = test_data_path + "models_VOC2007_cascade/car.xml";
-
-    std::string true_res_path = test_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_LatentSVMDetectorCascade_cpp, regression) { LatentSVMDetectorCascadeTest test; test.safe_run(); }

modules/latentsvm/test/test_main.cpp

-#include "test_precomp.hpp"
-
-CV_TEST_MAIN("cv")

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>