renamed filterObject -> CvLSVMFilterObject, position -> CvLSVMFilterPosition etc.

diff --git a/modules/objdetect/include/opencv2/objdetect/objdetect.hpp b/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
index 8a64c27..ae86b61 100644 (file)
--- a/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
+++ b/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
@@ -153,7 +153,7 @@ typedef struct
     unsigned int x;
     unsigned int y;
     unsigned int l;
-} position;
+} CvLSVMFilterPosition;
 
 // DataType: STRUCT filterObject
 // Description of the filter, which corresponds to the part of the object
@@ -173,14 +173,14 @@ typedef struct
 //                   size of row in feature vectors 
 //                   (yp = (int) (p / xp); p = xp * yp)
 typedef struct{
-    position V;
+    CvLSVMFilterPosition V;
     float fineFunction[4];
     unsigned int sizeX;
     unsigned int sizeY;
     unsigned int p;
     unsigned int xp;
     float *H;
-} filterObject;
+} CvLSVMFilterObject;
 
 // data type: STRUCT CvLatentSvmDetector
 // structure contains internal representation of trained Latent SVM detector
@@ -195,7 +195,7 @@ typedef struct CvLatentSvmDetector
        int num_filters;
        int num_components;
        int* num_part_filters;
-       filterObject** filters;
+       CvLSVMFilterObject** filters;
        float* b;
        float score_threshold;
 }

diff --git a/modules/objdetect/src/_latentsvm.h b/modules/objdetect/src/_latentsvm.h
index c49c2aa..e7cfc9c 100644 (file)
--- a/modules/objdetect/src/_latentsvm.h
+++ b/modules/objdetect/src/_latentsvm.h
@@ -40,7 +40,7 @@
 int getFeaturePyramid(IplImage * image, \r
                       const int lambda, const int k, \r
                       const int startX, const int startY, \r
-                      const int W, const int H, featurePyramid **maps);\r
+                      const int W, const int H, CvLSVMFeaturePyramid **maps);\r
 \r
 /*\r
 // Getting feature map for the selected subimage  \r
@@ -55,7 +55,7 @@ int getFeaturePyramid(IplImage * image,
 // RESULT\r
 // Error status\r
 */\r
-int getFeatureMaps_dp(const IplImage * image, const int k, featureMap **map);\r
+int getFeatureMaps_dp(const IplImage * image, const int k, CvLSVMFeatureMap **map);\r
 \r
 \r
 /*\r
@@ -71,7 +71,7 @@ int getFeatureMaps_dp(const IplImage * image, const int k, featureMap **map);
 // RESULT\r
 // Error status\r
 */\r
-int normalizationAndTruncationFeatureMaps(featureMap *map, const float alfa);\r
+int normalizationAndTruncationFeatureMaps(CvLSVMFeatureMap *map, const float alfa);\r
 \r
 /*\r
 // Feature map reduction\r
@@ -87,7 +87,7 @@ int normalizationAndTruncationFeatureMaps(featureMap *map, const float alfa);
 // RESULT\r
 // Error status\r
 */\r
-int PCAFeatureMaps(featureMap *map);\r
+int PCAFeatureMaps(CvLSVMFeatureMap *map);\r
 \r
 //////////////////////////////////////////////////////////////\r
 // search object\r
@@ -172,7 +172,7 @@ int clippingBoxes(int width, int height,
 #ifdef __cplusplus\r
 extern "C"\r
 #endif\r
-featurePyramid* createFeaturePyramidWithBorder(IplImage *image,\r
+CvLSVMFeaturePyramid* createFeaturePyramidWithBorder(IplImage *image,\r
                                                int maxXBorder, int maxYBorder);\r
 \r
 /*\r
@@ -204,7 +204,7 @@ featurePyramid* createFeaturePyramidWithBorder(IplImage *image,
 // RESULT\r
 // Error status\r
 */\r
-int searchObject(const featurePyramid *H, const filterObject **all_F, int n, \r
+int searchObject(const CvLSVMFeaturePyramid *H, const CvLSVMFilterObject **all_F, int n, \r
                  float b, \r
                  int maxXBorder,\r
                  int maxYBorder, \r
@@ -242,8 +242,8 @@ int searchObject(const featurePyramid *H, const filterObject **all_F, int n,
 // RESULT\r
 // Error status\r
 */\r
-int searchObjectThreshold(const featurePyramid *H, \r
-                          const filterObject **all_F, int n,\r
+int searchObjectThreshold(const CvLSVMFeaturePyramid *H, \r
+                          const CvLSVMFilterObject **all_F, int n,\r
                           float b, \r
                           int maxXBorder, int maxYBorder, \r
                           float scoreThreshold,\r
@@ -278,8 +278,8 @@ int searchObjectThreshold(const featurePyramid *H,
 #ifdef __cplusplus\r
 extern "C"\r
 #endif\r
-int searchObjectThresholdSomeComponents(const featurePyramid *H,\r
-                                        const filterObject **filters, \r
+int searchObjectThresholdSomeComponents(const CvLSVMFeaturePyramid *H,\r
+                                        const CvLSVMFilterObject **filters, \r
                                         int kComponents, const int *kPartFilters,\r
                                         const float *b, float scoreThreshold,\r
                                         CvPoint **points, CvPoint **oppPoints,\r
@@ -336,7 +336,7 @@ int getOppositePoint(CvPoint point,
 // Error status\r
 */\r
 int showRootFilterBoxes(IplImage *image,\r
-                        const filterObject *filter, \r
+                        const CvLSVMFilterObject *filter, \r
                         CvPoint *points, int *levels, int kPoints,\r
                         CvScalar color, int thickness, \r
                         int line_type, int shift);\r
@@ -367,7 +367,7 @@ int showRootFilterBoxes(IplImage *image,
 // Error status\r
 */\r
 int showPartFilterBoxes(IplImage *image,\r
-                        const filterObject **filters,\r
+                        const CvLSVMFilterObject **filters,\r
                         int n, CvPoint **partsDisplacement, \r
                         int *levels, int kPoints,\r
                         CvScalar color, int thickness, \r

diff --git a/modules/objdetect/src/_lsvm_matching.h b/modules/objdetect/src/_lsvm_matching.h
index 85e5dc5..2c60cee 100644 (file)
--- a/modules/objdetect/src/_lsvm_matching.h
+++ b/modules/objdetect/src/_lsvm_matching.h
@@ -25,7 +25,7 @@
 // RESULT
 // Error status
 */
-int convolution(const filterObject *Fi, const featureMap *map, float *f);
+int convolution(const CvLSVMFilterObject *Fi, const CvLSVMFeatureMap *map, float *f);
 
 /*
 // Computation multiplication of FFT images
@@ -97,9 +97,9 @@ int addNullableBars(float *rot2PIFilter, int dimX, int dimY,
 // RESULT
 // Error status
 */
-int getFFTImageFilterObject(const filterObject *filter, 
+int getFFTImageFilterObject(const CvLSVMFilterObject *filter, 
                             int mapDimX, int mapDimY,
-                            fftImage **image);
+                            CvLSVMFftImage **image);
 
 /*
 // Computation FFT image for feature map
@@ -111,7 +111,7 @@ int getFFTImageFilterObject(const filterObject *filter,
 // RESULT
 // Error status
 */
-int getFFTImageFeatureMap(const featureMap *map, fftImage **image);
+int getFFTImageFeatureMap(const CvLSVMFeatureMap *map, CvLSVMFftImage **image);
 
 /*
 // Function for convolution computation using FFT
@@ -128,7 +128,7 @@ int getFFTImageFeatureMap(const featureMap *map, fftImage **image);
 // RESULT
 // Error status
 */
-int convFFTConv2d(const fftImage *featMapImage, const fftImage *filterImage, 
+int convFFTConv2d(const CvLSVMFftImage *featMapImage, const CvLSVMFftImage *filterImage, 
                   int filterDimX, int filterDimY, float **conv);
 
 /*
@@ -149,7 +149,7 @@ int convFFTConv2d(const fftImage *featMapImage, const fftImage *filterImage,
 // RESULT
 // Error status
 */
-int filterDispositionLevel(const filterObject *Fi, const featureMap *pyramid,
+int filterDispositionLevel(const CvLSVMFilterObject *Fi, const CvLSVMFeatureMap *pyramid,
                            float **scoreFi, 
                            int **pointsX, int **pointsY);
 
@@ -171,7 +171,7 @@ int filterDispositionLevel(const filterObject *Fi, const featureMap *pyramid,
 // RESULT
 // Error status
 */
-int filterDispositionLevelFFT(const filterObject *Fi, const fftImage *featMapImage,
+int filterDispositionLevelFFT(const CvLSVMFilterObject *Fi, const CvLSVMFftImage *featMapImage,
                               float **scoreFi, 
                               int **pointsX, int **pointsY);
 
@@ -204,7 +204,7 @@ int computeBorderSize(int maxXBorder, int maxYBorder, int *bx, int *by);
 // RESULT
 // Error status
 */
-int addNullableBorder(featureMap *map, int bx, int by);
+int addNullableBorder(CvLSVMFeatureMap *map, int bx, int by);
 
 /*
 // Computation the maximum of the score function at the level
@@ -234,8 +234,8 @@ int addNullableBorder(featureMap *map, int bx, int by);
 // RESULT
 // Error status
 */
-int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n, 
-                                 const featurePyramid *H, 
+int maxFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n, 
+                                 const CvLSVMFeaturePyramid *H, 
                                  int level, float b, 
                                  int maxXBorder, int maxYBorder,                                 
                                  float *score, CvPoint **points, int *kPoints,
@@ -271,8 +271,8 @@ int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 // RESULT
 // Error status
 */
-int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n, 
-                                       const featurePyramid *H, 
+int thresholdFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n, 
+                                       const CvLSVMFeaturePyramid *H, 
                                        int level, float b, 
                                        int maxXBorder, int maxYBorder,
                                        float scoreThreshold,
@@ -306,8 +306,8 @@ int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 // RESULT
 // Error status
 */
-int maxFunctionalScore(const filterObject **all_F, int n, 
-                       const featurePyramid *H, float b, 
+int maxFunctionalScore(const CvLSVMFilterObject **all_F, int n, 
+                       const CvLSVMFeaturePyramid *H, float b, 
                        int maxXBorder, int maxYBorder,
                        float *score, 
                        CvPoint **points, int **levels, int *kPoints,
@@ -343,8 +343,8 @@ int maxFunctionalScore(const filterObject **all_F, int n,
 // RESULT
 // Error status
 */
-int thresholdFunctionalScore(const filterObject **all_F, int n, 
-                             const featurePyramid *H, 
+int thresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n, 
+                             const CvLSVMFeaturePyramid *H, 
                              float b, 
                              int maxXBorder, int maxYBorder,
                              float scoreThreshold,
@@ -389,7 +389,7 @@ int nonMaximumSuppression(int numBoxes, const CvPoint *points,
 #ifdef __cplusplus
 extern "C"
 #endif
-int getMaxFilterDims(const filterObject **filters, int kComponents,
+int getMaxFilterDims(const CvLSVMFilterObject **filters, int kComponents,
                      const int *kPartFilters, 
                      unsigned int *maxXBorder, unsigned int *maxYBorder);
 //}

diff --git a/modules/objdetect/src/_lsvm_routine.h b/modules/objdetect/src/_lsvm_routine.h
index 05c8333..815389d 100644 (file)
--- a/modules/objdetect/src/_lsvm_routine.h
+++ b/modules/objdetect/src/_lsvm_routine.h
@@ -12,24 +12,24 @@
 // with all fields including arrays
 // Error status is return value
 //////////////////////////////////////////////////////////////
-int allocFilterObject(filterObject **obj, const int sizeX, const int sizeY, 
+int allocFilterObject(CvLSVMFilterObject **obj, const int sizeX, const int sizeY, 
                       const int p, const int xp);
-int freeFilterObject (filterObject **obj);
+int freeFilterObject (CvLSVMFilterObject **obj);
 
-int allocFeatureMapObject(featureMap **obj, const int sizeX, const int sizeY,
+int allocFeatureMapObject(CvLSVMFeatureMap **obj, const int sizeX, const int sizeY,
                           const int p, const int xp);
-int freeFeatureMapObject (featureMap **obj);
+int freeFeatureMapObject (CvLSVMFeatureMap **obj);
 
 #ifdef __cplusplus
 extern "C"
 #endif
-int allocFeaturePyramidObject(featurePyramid **obj, 
+int allocFeaturePyramidObject(CvLSVMFeaturePyramid **obj, 
                               const int lambda, const int countLevel);
 
 #ifdef __cplusplus
 extern "C"
 #endif
-int freeFeaturePyramidObject (featurePyramid **obj);
-int allocFFTImage(fftImage **image, int p, int dimX, int dimY);
-int freeFFTImage(fftImage **image);
+int freeFeaturePyramidObject (CvLSVMFeaturePyramid **obj);
+int allocFFTImage(CvLSVMFftImage **image, int p, int dimX, int dimY);
+int freeFFTImage(CvLSVMFftImage **image);
 #endif
\ No newline at end of file

diff --git a/modules/objdetect/src/_lsvm_types.h b/modules/objdetect/src/_lsvm_types.h
index 5479f45..28ad1b6 100644 (file)
--- a/modules/objdetect/src/_lsvm_types.h
+++ b/modules/objdetect/src/_lsvm_types.h
@@ -1,17 +1,19 @@
 #ifndef SVM_TYPE
 #define SVM_TYPE
 
+#include "float.h"
+
 //#define FFT_CONV
 
 // Çíà÷åíèå ÷èñëà PI
-#define PI    3.1415926535897932384626433832795  
+#define PI    CV_PI
 
 // Òî÷íîñòü ñðàâíåíèÿ ïàðû âåùåñòâåííûõ ÷èñåë
 #define EPS 0.000001
 
 // Ìèíèìàëüíîå è ìàêñèìàëüíîå çíà÷åíèå äëÿ âåùåñòâåííîãî òèïà äàííûõ
-#define F_MAX 3.402823466e+38
-#define F_MIN -3.402823465e+38
+#define F_MAX FLT_MAX
+#define F_MIN -FLT_MAX
 
 // The number of elements in bin
 // The number of sectors in gradient histogram building
@@ -46,7 +48,7 @@ typedef struct{
     int p;
     int xp;
     float *Map;
-} featureMap;
+} CvLSVMFeatureMap;
 
 // DataType: STRUCT featurePyramid
 //
@@ -56,8 +58,8 @@ typedef struct{
 typedef struct{
     int countLevel;
     int lambda;
-    featureMap **pyramid;
-} featurePyramid;
+    CvLSVMFeatureMap **pyramid;
+} CvLSVMFeaturePyramid;
 
 // DataType: STRUCT filterDisposition
 // The structure stores preliminary results in optimization process
@@ -70,7 +72,7 @@ typedef struct{
     float *score;
     int *x;
     int *y;
-} filterDisposition;
+} CvLSVMFilterDisposition;
 
 // DataType: STRUCT fftImage
 // The structure stores FFT image
@@ -84,6 +86,6 @@ typedef struct{
     unsigned int dimX;
     unsigned int dimY;
     float **channels;
-} fftImage;
+} CvLSVMFftImage;
 
 #endif

diff --git a/modules/objdetect/src/_lsvmparser.h b/modules/objdetect/src/_lsvmparser.h
index 58804b7..7f92678 100644 (file)
--- a/modules/objdetect/src/_lsvmparser.h
+++ b/modules/objdetect/src/_lsvmparser.h
@@ -46,7 +46,8 @@
 #define EBTAG     (STEP_END + BTAG)
 
 //extern "C" {
-    int LSVMparser(const char * filename, filterObject *** model, int *last, int *max, int **comp, float **b, int *count, float * score);
+    int LSVMparser(const char * filename, CvLSVMFilterObject *** model, int *last, int *max,
+                   int **comp, float **b, int *count, float * score);
 #ifdef __cplusplus
 extern "C"
 #endif
@@ -54,7 +55,7 @@ extern "C"
              
               const char *modelPath,
              
-              filterObject ***filters,
+              CvLSVMFilterObject ***filters,
               int *kFilters,
               int *kComponents,
               int **kPartFilters,

diff --git a/modules/objdetect/src/featurepyramid.cpp b/modules/objdetect/src/featurepyramid.cpp
index b05874f..e5e314c 100644 (file)
--- a/modules/objdetect/src/featurepyramid.cpp
+++ b/modules/objdetect/src/featurepyramid.cpp
@@ -29,7 +29,7 @@ int sign(float r){
 // RESULT\r
 // Error status\r
 */\r
-int getFeatureMaps_dp(const IplImage * image,const int k, featureMap **map)\r
+int getFeatureMaps_dp(const IplImage * image,const int k, CvLSVMFeatureMap **map)\r
 {\r
     int sizeX, sizeY;\r
     int p, px, strsz;\r
@@ -226,7 +226,7 @@ int getFeatureMaps_dp(const IplImage * image,const int k, featureMap **map)
 // RESULT\r
 // Error status\r
 */\r
-int normalizationAndTruncationFeatureMaps(featureMap *map, const float alfa)\r
+int normalizationAndTruncationFeatureMaps(CvLSVMFeatureMap *map, const float alfa)\r
 {\r
     int i,j, ii;\r
     int sizeX, sizeY, p, pos, pp, xp, pos1, pos2;\r
@@ -351,7 +351,7 @@ int normalizationAndTruncationFeatureMaps(featureMap *map, const float alfa)
 // RESULT\r
 // Error status\r
 */\r
-int PCAFeatureMaps(featureMap *map)\r
+int PCAFeatureMaps(CvLSVMFeatureMap *map)\r
 { \r
     int i,j, ii, jj, k;\r
     int sizeX, sizeY, p,  pp, xp, yp, pos1, pos2;\r
@@ -447,7 +447,7 @@ int PCAFeatureMaps(featureMap *map)
 int getFeaturePyramid(IplImage * image,\r
                       const int lambda, const int k, \r
                       const int startX, const int startY, \r
-                      const int W, const int H, featurePyramid **maps)\r
+                      const int W, const int H, CvLSVMFeaturePyramid **maps)\r
 {\r
     IplImage *img2, *imgTmp, *imgResize;\r
     float   step, tmp;\r
@@ -455,7 +455,7 @@ int getFeaturePyramid(IplImage * image,
     int      maxcall;\r
     int i;\r
     int err;\r
-    featureMap *map;\r
+    CvLSVMFeatureMap *map;\r
     \r
     //geting subimage\r
     cvSetImageROI(image, cvRect(startX, startY, W, H));\r
@@ -534,7 +534,7 @@ int getFeaturePyramid(IplImage * image,
 // RESULT\r
 // Error status\r
 */\r
-int addBordersToFeatureMaps(featureMap *map, const int bX, const int bY){\r
+int addBordersToFeatureMaps(CvLSVMFeatureMap *map, const int bX, const int bY){\r
     int i,j, jj;\r
     int sizeX, sizeY, p, pos1, pos2;\r
     float * new_data;\r

diff --git a/modules/objdetect/src/latentsvm.cpp b/modules/objdetect/src/latentsvm.cpp
index 0b5a5fc..5a08514 100644 (file)
--- a/modules/objdetect/src/latentsvm.cpp
+++ b/modules/objdetect/src/latentsvm.cpp
@@ -118,13 +118,13 @@ int clippingBoxes(int width, int height,
 // RESULT\r
 // Feature pyramid with nullable border\r
 */\r
-featurePyramid* createFeaturePyramidWithBorder(IplImage *image,\r
+CvLSVMFeaturePyramid* createFeaturePyramidWithBorder(IplImage *image,\r
                                                int maxXBorder, int maxYBorder)\r
 {\r
     int opResult;\r
     int bx, by;\r
     int level;\r
-    featurePyramid *H;\r
+    CvLSVMFeaturePyramid *H;\r
 \r
     // Obtaining feature pyramid\r
     opResult = getFeaturePyramid(image, LAMBDA, SIDE_LENGTH, 0, 0, \r
@@ -175,7 +175,7 @@ featurePyramid* createFeaturePyramidWithBorder(IplImage *image,
 // RESULT\r
 // Error status\r
 */\r
-int searchObject(const featurePyramid *H, const filterObject **all_F, \r
+int searchObject(const CvLSVMFeaturePyramid *H, const CvLSVMFilterObject **all_F, \r
                  int n, float b, \r
                  int maxXBorder,\r
                  int maxYBorder,  \r
@@ -265,8 +265,8 @@ int estimateBoxes(CvPoint *points, int *levels, int kPoints,
 // RESULT\r
 // Error status\r
 */\r
-int searchObjectThreshold(const featurePyramid *H, \r
-                          const filterObject **all_F, int n,\r
+int searchObjectThreshold(const CvLSVMFeaturePyramid *H, \r
+                          const CvLSVMFilterObject **all_F, int n,\r
                           float b, \r
                           int maxXBorder, int maxYBorder, \r
                           float scoreThreshold,\r
@@ -356,7 +356,7 @@ int getOppositePoint(CvPoint point,
 // Error status\r
 */\r
 int showRootFilterBoxes(IplImage *image,\r
-                        const filterObject *filter, \r
+                        const CvLSVMFilterObject *filter, \r
                         CvPoint *points, int *levels, int kPoints,\r
                         CvScalar color, int thickness, \r
                         int line_type, int shift)\r
@@ -404,7 +404,7 @@ int showRootFilterBoxes(IplImage *image,
 // Error status\r
 */\r
 int showPartFilterBoxes(IplImage *image,\r
-                        const filterObject **filters,\r
+                        const CvLSVMFilterObject **filters,\r
                         int n, CvPoint **partsDisplacement, \r
                         int *levels, int kPoints,\r
                         CvScalar color, int thickness, \r
@@ -484,7 +484,7 @@ int showBoxes(IplImage *img,
 // RESULT\r
 // Error status\r
 */\r
-int getMaxFilterDims(const filterObject **filters, int kComponents,\r
+int getMaxFilterDims(const CvLSVMFilterObject **filters, int kComponents,\r
                      const int *kPartFilters, \r
                      unsigned int *maxXBorder, unsigned int *maxYBorder)\r
 {\r
@@ -532,8 +532,8 @@ int getMaxFilterDims(const filterObject **filters, int kComponents,
 // RESULT\r
 // Error status\r
 */\r
-int searchObjectThresholdSomeComponents(const featurePyramid *H,\r
-                                        const filterObject **filters, \r
+int searchObjectThresholdSomeComponents(const CvLSVMFeaturePyramid *H,\r
+                                        const CvLSVMFilterObject **filters, \r
                                         int kComponents, const int *kPartFilters,\r
                                         const float *b, float scoreThreshold,\r
                                         CvPoint **points, CvPoint **oppPoints,\r

diff --git a/modules/objdetect/src/latentsvmdetector.cpp b/modules/objdetect/src/latentsvmdetector.cpp
index 336a360..f0f1d79 100644 (file)
--- a/modules/objdetect/src/latentsvmdetector.cpp
+++ b/modules/objdetect/src/latentsvmdetector.cpp
@@ -16,7 +16,7 @@
 CvLatentSvmDetector* cvLoadLatentSvmDetector(const char* filename)\r
 {\r
        CvLatentSvmDetector* detector = 0;\r
-       filterObject** filters = 0;\r
+       CvLSVMFilterObject** filters = 0;\r
        int kFilters = 0;\r
        int kComponents = 0;\r
        int* kPartFilters = 0;\r
@@ -84,7 +84,7 @@ CvSeq* cvLatentSvmDetectObjects(IplImage* image,
                                                                CvMemStorage* storage, \r
                                                                float overlap_threshold)\r
 {\r
-       featurePyramid *H = 0;\r
+       CvLSVMFeaturePyramid *H = 0;\r
     CvPoint *points = 0, *oppPoints = 0;\r
     int kPoints = 0;\r
     float *score = 0;    \r
@@ -97,11 +97,11 @@ CvSeq* cvLatentSvmDetectObjects(IplImage* image,
 \r
     cvConvertImage(image, image, CV_CVTIMG_SWAP_RB);\r
     // Getting maximum filter dimensions\r
-       getMaxFilterDims((const filterObject**)(detector->filters), detector->num_components, detector->num_part_filters, &maxXBorder, &maxYBorder);\r
+       getMaxFilterDims((const CvLSVMFilterObject**)(detector->filters), detector->num_components, detector->num_part_filters, &maxXBorder, &maxYBorder);\r
     // Create feature pyramid with nullable border\r
     H = createFeaturePyramidWithBorder(image, maxXBorder, maxYBorder);\r
     // Search object\r
-    searchObjectThresholdSomeComponents(H, (const filterObject**)(detector->filters), detector->num_components, \r
+    searchObjectThresholdSomeComponents(H, (const CvLSVMFilterObject**)(detector->filters), detector->num_components, \r
                detector->num_part_filters, detector->b, detector->score_threshold, \r
                 &points, &oppPoints, &score, &kPoints);\r
     // Clipping boxes\r

diff --git a/modules/objdetect/src/lsvmparser.cpp b/modules/objdetect/src/lsvmparser.cpp
index a87416f..30f0591 100644 (file)
--- a/modules/objdetect/src/lsvmparser.cpp
+++ b/modules/objdetect/src/lsvmparser.cpp
@@ -163,23 +163,23 @@ int getTeg(char *str){
     return sum;\r
 }\r
 \r
-void addFilter(filterObject *** model, int *last, int *max){\r
-    filterObject ** nmodel;\r
+void addFilter(CvLSVMFilterObject *** model, int *last, int *max){\r
+    CvLSVMFilterObject ** nmodel;\r
     int i;\r
     (*last) ++;\r
     if((*last) >= (*max)){\r
         (*max) += 10;\r
-        nmodel = (filterObject **)malloc(sizeof(filterObject *) * (*max));\r
+        nmodel = (CvLSVMFilterObject **)malloc(sizeof(CvLSVMFilterObject *) * (*max));\r
         for(i = 0; i < *last; i++){\r
             nmodel[i] = (* model)[i];\r
         }\r
         free(* model);\r
         (*model) = nmodel;\r
     }\r
-    (*model) [(*last)] = (filterObject *)malloc(sizeof(filterObject));\r
+    (*model) [(*last)] = (CvLSVMFilterObject *)malloc(sizeof(CvLSVMFilterObject));\r
 }\r
 \r
-void parserRFilter  (FILE * xmlf, int p, filterObject * model, float *b){\r
+void parserRFilter  (FILE * xmlf, int p, CvLSVMFilterObject * model, float *b){\r
     int st = 0;\r
     int sizeX, sizeY;\r
     int tag;\r
@@ -278,7 +278,7 @@ void parserRFilter  (FILE * xmlf, int p, filterObject * model, float *b){
     }\r
 }\r
 \r
-void parserV  (FILE * xmlf, int p, filterObject * model){\r
+void parserV  (FILE * xmlf, int p, CvLSVMFilterObject * model){\r
     int st = 0;\r
     int tag;\r
     int tagVal;\r
@@ -341,7 +341,7 @@ void parserV  (FILE * xmlf, int p, filterObject * model){
         }        \r
     }\r
 }\r
-void parserD  (FILE * xmlf, int p, filterObject * model){\r
+void parserD  (FILE * xmlf, int p, CvLSVMFilterObject * model){\r
     int st = 0;\r
     int tag;\r
     int tagVal;\r
@@ -430,7 +430,7 @@ void parserD  (FILE * xmlf, int p, filterObject * model){
     }\r
 }\r
 \r
-void parserPFilter  (FILE * xmlf, int p, int N_path, filterObject * model){\r
+void parserPFilter  (FILE * xmlf, int p, int N_path, CvLSVMFilterObject * model){\r
     int st = 0;\r
     int sizeX, sizeY;\r
     int tag;\r
@@ -524,7 +524,7 @@ void parserPFilter  (FILE * xmlf, int p, int N_path, filterObject * model){
         }        \r
     }\r
 }\r
-void parserPFilterS (FILE * xmlf, int p, filterObject *** model, int *last, int *max){\r
+void parserPFilterS (FILE * xmlf, int p, CvLSVMFilterObject *** model, int *last, int *max){\r
     int st = 0;\r
     int N_path = 0;\r
     int tag;\r
@@ -573,7 +573,7 @@ void parserPFilterS (FILE * xmlf, int p, filterObject *** model, int *last, int
         }        \r
     }\r
 }\r
-void parserComp (FILE * xmlf, int p, int *N_comp, filterObject *** model, float *b, int *last, int *max){\r
+void parserComp (FILE * xmlf, int p, int *N_comp, CvLSVMFilterObject *** model, float *b, int *last, int *max){\r
     int st = 0;\r
     int tag;\r
     int tagVal;\r
@@ -623,7 +623,7 @@ void parserComp (FILE * xmlf, int p, int *N_comp, filterObject *** model, float
         }        \r
     }\r
 }\r
-void parserModel(FILE * xmlf, filterObject *** model, int *last, int *max, int **comp, float **b, int *count, float * score){\r
+void parserModel(FILE * xmlf, CvLSVMFilterObject *** model, int *last, int *max, int **comp, float **b, int *count, float * score){\r
     int p = 0;\r
     int N_comp = 0;\r
     int * cmp;\r
@@ -720,7 +720,7 @@ void parserModel(FILE * xmlf, filterObject *** model, int *last, int *max, int *
     }\r
 }\r
 \r
-int LSVMparser(const char * filename, filterObject *** model, int *last, int *max, int **comp, float **b, int *count, float * score){\r
+int LSVMparser(const char * filename, CvLSVMFilterObject *** model, int *last, int *max, int **comp, float **b, int *count, float * score){\r
     int st = 0;\r
     int tag;\r
     char ch;\r
@@ -731,7 +731,7 @@ int LSVMparser(const char * filename, filterObject *** model, int *last, int *ma
 \r
     (*max) = 10;\r
     (*last) = -1;\r
-    (*model) = (filterObject ** )malloc((sizeof(filterObject * )) * (*max));\r
+    (*model) = (CvLSVMFilterObject ** )malloc((sizeof(CvLSVMFilterObject * )) * (*max));\r
 \r
     //printf("parse : %s\n", filename);\r
 \r
@@ -773,8 +773,7 @@ int LSVMparser(const char * filename, filterObject *** model, int *last, int *ma
 \r
 int loadModel(\r
               const char *modelPath,\r
-             \r
-              filterObject ***filters,\r
+              CvLSVMFilterObject ***filters,\r
               int *kFilters, \r
               int *kComponents, \r
               int **kPartFilters, \r

diff --git a/modules/objdetect/src/matching.cpp b/modules/objdetect/src/matching.cpp
index 6396178..94170f9 100644 (file)
--- a/modules/objdetect/src/matching.cpp
+++ b/modules/objdetect/src/matching.cpp
@@ -21,7 +21,7 @@
 // RESULT\r
 // Error status\r
 */\r
-int convolution(const filterObject *Fi, const featureMap *map, float *f)\r
+int convolution(const CvLSVMFilterObject *Fi, const CvLSVMFeatureMap *map, float *f)\r
 {\r
     int n1, m1, n2, m2, p, size, diff1, diff2;\r
     int i1, i2, j1, j2, k; \r
@@ -161,7 +161,7 @@ int addNullableBars(float *rot2PIFilter, int dimX, int dimY,
 // Computation FFT image for filter object\r
 //\r
 // API\r
-// int getFFTImageFilterObject(const filterObject *filter, \r
+// int getFFTImageFilterObject(const CvLSVMFilterObject *filter, \r
                                int mapDimX, int mapDimY,\r
                                fftImage **image);\r
 // INPUT\r
@@ -172,9 +172,9 @@ int addNullableBars(float *rot2PIFilter, int dimX, int dimY,
 // RESULT\r
 // Error status\r
 */\r
-int getFFTImageFilterObject(const filterObject *filter, \r
+int getFFTImageFilterObject(const CvLSVMFilterObject *filter, \r
                             int mapDimX, int mapDimY,\r
-                            fftImage **image)\r
+                            CvLSVMFftImage **image)\r
 {\r
     unsigned int i, mapSize, filterSize;\r
     int res;\r
@@ -211,7 +211,7 @@ int getFFTImageFilterObject(const filterObject *filter,
 // RESULT\r
 // Error status\r
 */\r
-int getFFTImageFeatureMap(const featureMap *map, fftImage **image)\r
+int getFFTImageFeatureMap(const CvLSVMFeatureMap *map, CvLSVMFftImage **image)\r
 {\r
     int i, j, size;\r
     float *buf;    \r
@@ -246,7 +246,7 @@ int getFFTImageFeatureMap(const featureMap *map, fftImage **image)
 // RESULT\r
 // Error status\r
 */\r
-int convFFTConv2d(const fftImage *featMapImage, const fftImage *filterImage, \r
+int convFFTConv2d(const CvLSVMFftImage *featMapImage, const CvLSVMFftImage *filterImage, \r
                   int filterDimX, int filterDimY, float **conv)\r
 {\r
     int i, j, size, diffX, diffY, index;\r
@@ -289,7 +289,7 @@ int convFFTConv2d(const fftImage *featMapImage, const fftImage *filterImage,
 // Computation objective function D according the original paper\r
 //\r
 // API\r
-// int filterDispositionLevel(const filterObject *Fi, const featurePyramid *H, \r
+// int filterDispositionLevel(const CvLSVMFilterObject *Fi, const featurePyramid *H, \r
                               int level, float **scoreFi, \r
                               int **pointsX, int **pointsY);\r
 // INPUT\r
@@ -304,7 +304,7 @@ int convFFTConv2d(const fftImage *featMapImage, const fftImage *filterImage,
 // RESULT\r
 // Error status\r
 */\r
-int filterDispositionLevel(const filterObject *Fi, const featureMap *pyramid,\r
+int filterDispositionLevel(const CvLSVMFilterObject *Fi, const CvLSVMFeatureMap *pyramid,\r
                            float **scoreFi, \r
                            int **pointsX, int **pointsY)\r
 {\r
@@ -375,7 +375,7 @@ int filterDispositionLevel(const filterObject *Fi, const featureMap *pyramid,
 // Computation objective function D according the original paper using FFT\r
 //\r
 // API\r
-// int filterDispositionLevelFFT(const filterObject *Fi, const fftImage *featMapImage,\r
+// int filterDispositionLevelFFT(const CvLSVMFilterObject *Fi, const fftImage *featMapImage,\r
                                  float **scoreFi, \r
                                  int **pointsX, int **pointsY);\r
 // INPUT\r
@@ -389,7 +389,7 @@ int filterDispositionLevel(const filterObject *Fi, const featureMap *pyramid,
 // RESULT\r
 // Error status\r
 */\r
-int filterDispositionLevelFFT(const filterObject *Fi, const fftImage *featMapImage,\r
+int filterDispositionLevelFFT(const CvLSVMFilterObject *Fi, const CvLSVMFftImage *featMapImage,\r
                               float **scoreFi, \r
                               int **pointsX, int **pointsY)\r
 {\r
@@ -397,7 +397,7 @@ int filterDispositionLevelFFT(const filterObject *Fi, const fftImage *featMapIma
     float *f;    \r
     int i1, j1;\r
     int res;\r
-    fftImage *filterImage;\r
+    CvLSVMFftImage *filterImage;\r
     \r
     n1 = featMapImage->dimY;\r
     m1 = featMapImage->dimX;\r
@@ -493,7 +493,7 @@ int computeBorderSize(int maxXBorder, int maxYBorder, int *bx, int *by)
 // RESULT\r
 // Error status\r
 */\r
-int addNullableBorder(featureMap *map, int bx, int by)\r
+int addNullableBorder(CvLSVMFeatureMap *map, int bx, int by)\r
 {\r
     int sizeX, sizeY, i, j, k;\r
     float *new_map;\r
@@ -522,12 +522,12 @@ int addNullableBorder(featureMap *map, int bx, int by)
     return LATENT_SVM_OK;\r
 }\r
 \r
-featureMap* featureMapBorderPartFilter(featureMap *map, \r
+CvLSVMFeatureMap* featureMapBorderPartFilter(CvLSVMFeatureMap *map, \r
                                        int maxXBorder, int maxYBorder)\r
 {\r
     int bx, by;\r
     int sizeX, sizeY, i, j, k;\r
-    featureMap *new_map;\r
+    CvLSVMFeatureMap *new_map;\r
     \r
     computeBorderSize(maxXBorder, maxYBorder, &bx, &by);\r
     sizeX = map->sizeX + 2 * bx;\r
@@ -555,7 +555,7 @@ featureMap* featureMapBorderPartFilter(featureMap *map,
 // Computation the maximum of the score function at the level\r
 //\r
 // API\r
-// int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n, \r
+// int maxFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n, \r
                                     const featurePyramid *H, \r
                                     int level, float b, \r
                                     int maxXBorder, int maxYBorder,                                 \r
@@ -579,8 +579,8 @@ featureMap* featureMapBorderPartFilter(featureMap *map,
 // RESULT\r
 // Error status\r
 */\r
-int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n, \r
-                                 const featurePyramid *H, \r
+int maxFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n, \r
+                                 const CvLSVMFeaturePyramid *H, \r
                                  int level, float b, \r
                                  int maxXBorder, int maxYBorder,                                 \r
                                  float *score, CvPoint **points, \r
@@ -588,14 +588,14 @@ int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 {\r
     int i, j, k, dimX, dimY, nF0, mF0, p;\r
     int diff1, diff2, index, last, partsLevel;\r
-    filterDisposition **disposition;\r
+    CvLSVMFilterDisposition **disposition;\r
     float *f;\r
     float *scores;\r
     float sumScorePartDisposition, maxScore;\r
     int res;\r
-    featureMap *map;\r
+    CvLSVMFeatureMap *map;\r
 #ifdef FFT_CONV\r
-    fftImage *rootFilterImage, *mapImage;\r
+    CvLSVMFftImage *rootFilterImage, *mapImage;\r
 #else\r
 #endif\r
 \r
@@ -631,10 +631,10 @@ int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n,
    \r
     // Allocation memory for saving values of function D \r
     // on the level for each part filter\r
-    disposition = (filterDisposition **)malloc(sizeof(filterDisposition *) * n);\r
+    disposition = (CvLSVMFilterDisposition **)malloc(sizeof(CvLSVMFilterDisposition *) * n);\r
     for (i = 0; i < n; i++)\r
     {\r
-        disposition[i] = (filterDisposition *)malloc(sizeof(filterDisposition));\r
+        disposition[i] = (CvLSVMFilterDisposition *)malloc(sizeof(CvLSVMFilterDisposition));\r
     }  \r
 \r
     // Allocation memory for values of score function for each block on the level\r
@@ -801,7 +801,7 @@ int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 // Computation score function at the level that exceed threshold\r
 //\r
 // API\r
-// int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n, \r
+// int thresholdFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n, \r
                                           const featurePyramid *H, \r
                                           int level, float b, \r
                                           int maxXBorder, int maxYBorder,\r
@@ -827,8 +827,8 @@ int maxFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 // RESULT\r
 // Error status\r
 */\r
-int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n, \r
-                                       const featurePyramid *H, \r
+int thresholdFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n, \r
+                                       const CvLSVMFeaturePyramid *H, \r
                                        int level, float b, \r
                                        int maxXBorder, int maxYBorder,\r
                                        float scoreThreshold,\r
@@ -837,14 +837,14 @@ int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 {\r
     int i, j, k, dimX, dimY, nF0, mF0, p;\r
     int diff1, diff2, index, last, partsLevel;\r
-    filterDisposition **disposition;\r
+    CvLSVMFilterDisposition **disposition;\r
     float *f;\r
     float *scores;\r
     float sumScorePartDisposition;\r
     int res;\r
-    featureMap *map;\r
+    CvLSVMFeatureMap *map;\r
 #ifdef FFT_CONV\r
-    fftImage *rootFilterImage, *mapImage;\r
+    CvLSVMFftImage *rootFilterImage, *mapImage;\r
 #else\r
 #endif\r
     /*\r
@@ -879,10 +879,10 @@ int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n,
    \r
     // Allocation memory for saving values of function D \r
     // on the level for each part filter\r
-    disposition = (filterDisposition **)malloc(sizeof(filterDisposition *) * n);\r
+    disposition = (CvLSVMFilterDisposition **)malloc(sizeof(CvLSVMFilterDisposition *) * n);\r
     for (i = 0; i < n; i++)\r
     {\r
-        disposition[i] = (filterDisposition *)malloc(sizeof(filterDisposition));\r
+        disposition[i] = (CvLSVMFilterDisposition *)malloc(sizeof(CvLSVMFilterDisposition));\r
     }  \r
 \r
     // Allocation memory for values of score function for each block on the level\r
@@ -1038,7 +1038,7 @@ int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 // Computation the maximum of the score function\r
 //\r
 // API\r
-// int maxFunctionalScore(const filterObject **all_F, int n, \r
+// int maxFunctionalScore(const CvLSVMFilterObject **all_F, int n, \r
                           const featurePyramid *H, float b, \r
                           int maxXBorder, int maxYBorder,\r
                           float *score, \r
@@ -1061,8 +1061,8 @@ int thresholdFunctionalScoreFixedLevel(const filterObject **all_F, int n,
 // RESULT\r
 // Error status\r
 */\r
-int maxFunctionalScore(const filterObject **all_F, int n, \r
-                       const featurePyramid *H, float b, \r
+int maxFunctionalScore(const CvLSVMFilterObject **all_F, int n, \r
+                       const CvLSVMFeaturePyramid *H, float b, \r
                        int maxXBorder, int maxYBorder,\r
                        float *score, \r
                        CvPoint **points, int **levels, int *kPoints,\r
@@ -1197,7 +1197,7 @@ int maxFunctionalScore(const filterObject **all_F, int n,
 // Computation score function that exceed threshold\r
 //\r
 // API\r
-// int thresholdFunctionalScore(const filterObject **all_F, int n, \r
+// int thresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n, \r
                                 const featurePyramid *H, \r
                                 float b, \r
                                 int maxXBorder, int maxYBorder,\r
@@ -1223,8 +1223,8 @@ int maxFunctionalScore(const filterObject **all_F, int n,
 // RESULT\r
 // Error status\r
 */\r
-int thresholdFunctionalScore(const filterObject **all_F, int n, \r
-                             const featurePyramid *H, \r
+int thresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n, \r
+                             const CvLSVMFeaturePyramid *H, \r
                              float b, \r
                              int maxXBorder, int maxYBorder,\r
                              float scoreThreshold,\r

diff --git a/modules/objdetect/src/routine.cpp b/modules/objdetect/src/routine.cpp
index 5cb3a88..fbf8d98 100644 (file)
--- a/modules/objdetect/src/routine.cpp
+++ b/modules/objdetect/src/routine.cpp
@@ -1,9 +1,9 @@
 #include "precomp.hpp"\r
 #include "_lsvm_routine.h"\r
 \r
-int allocFilterObject(filterObject **obj, const int sizeX, const int sizeY, const int p, const int xp){\r
+int allocFilterObject(CvLSVMFilterObject **obj, const int sizeX, const int sizeY, const int p, const int xp){\r
     int i;\r
-    (*obj) = (filterObject *)malloc(sizeof(filterObject));\r
+    (*obj) = (CvLSVMFilterObject *)malloc(sizeof(CvLSVMFilterObject));\r
     (*obj)->sizeX = sizeX;\r
     (*obj)->sizeY = sizeY;\r
     (*obj)->p     = p    ;\r
@@ -21,7 +21,7 @@ int allocFilterObject(filterObject **obj, const int sizeX, const int sizeY, cons
     }\r
     return LATENT_SVM_OK;\r
 }\r
-int freeFilterObject (filterObject **obj){\r
+int freeFilterObject (CvLSVMFilterObject **obj){\r
     if(*obj == NULL) return 0;\r
     free((*obj)->H);\r
     free(*obj);\r
@@ -29,9 +29,9 @@ int freeFilterObject (filterObject **obj){
     return LATENT_SVM_OK;\r
 }\r
 \r
-int allocFeatureMapObject(featureMap **obj, const int sizeX, const int sizeY, const int p, const int xp){\r
+int allocFeatureMapObject(CvLSVMFeatureMap **obj, const int sizeX, const int sizeY, const int p, const int xp){\r
     int i;\r
-    (*obj) = (featureMap *)malloc(sizeof(featureMap));\r
+    (*obj) = (CvLSVMFeatureMap *)malloc(sizeof(CvLSVMFeatureMap));\r
     (*obj)->sizeX = sizeX;\r
     (*obj)->sizeY = sizeY;\r
     (*obj)->p     = p    ;\r
@@ -42,7 +42,7 @@ int allocFeatureMapObject(featureMap **obj, const int sizeX, const int sizeY, co
     }\r
     return LATENT_SVM_OK;\r
 }\r
-int freeFeatureMapObject (featureMap **obj){\r
+int freeFeatureMapObject (CvLSVMFeatureMap **obj){\r
     if(*obj == NULL) return 0;\r
     free((*obj)->Map);\r
     free(*obj);\r
@@ -50,15 +50,15 @@ int freeFeatureMapObject (featureMap **obj){
     return LATENT_SVM_OK;\r
 }\r
 \r
-int allocFeaturePyramidObject(featurePyramid **obj, const int lambda, const int countLevel){\r
-    (*obj) = (featurePyramid *)malloc(sizeof(featurePyramid));\r
+int allocFeaturePyramidObject(CvLSVMFeaturePyramid **obj, const int lambda, const int countLevel){\r
+    (*obj) = (CvLSVMFeaturePyramid *)malloc(sizeof(CvLSVMFeaturePyramid));\r
     (*obj)->countLevel = countLevel;\r
-    (*obj)->pyramid    = (featureMap **)malloc(sizeof(featureMap *) * countLevel);\r
+    (*obj)->pyramid    = (CvLSVMFeatureMap **)malloc(sizeof(CvLSVMFeatureMap *) * countLevel);\r
     (*obj)->lambda     = lambda;\r
     return LATENT_SVM_OK;\r
 }\r
 \r
-int freeFeaturePyramidObject (featurePyramid **obj){\r
+int freeFeaturePyramidObject (CvLSVMFeaturePyramid **obj){\r
     int i; \r
     if(*obj == NULL) return 0;\r
     for(i = 0; i < (*obj)->countLevel; i++)\r
@@ -69,10 +69,10 @@ int freeFeaturePyramidObject (featurePyramid **obj){
     return LATENT_SVM_OK;\r
 }\r
 \r
-int allocFFTImage(fftImage **image, int p, int dimX, int dimY)\r
+int allocFFTImage(CvLSVMFftImage **image, int p, int dimX, int dimY)\r
 {\r
     int i, j, size;\r
-    *image = (fftImage *)malloc(sizeof(fftImage));\r
+    *image = (CvLSVMFftImage *)malloc(sizeof(CvLSVMFftImage));\r
     (*image)->p = p;\r
     (*image)->dimX = dimX;\r
     (*image)->dimY = dimY;\r
@@ -89,7 +89,7 @@ int allocFFTImage(fftImage **image, int p, int dimX, int dimY)
     return LATENT_SVM_OK;\r
 }\r
 \r
-int freeFFTImage(fftImage **image)\r
+int freeFFTImage(CvLSVMFftImage **image)\r
 {\r
     unsigned int i;\r
     if (*image == NULL) return LATENT_SVM_OK;\r