Fixed float.h issue. OpenCV with built libraries working for linux x64

4 files changed, 5216 insertions, 0 deletions

diff --git a/thirdparty/includes/OpenCV/opencv2/legacy/blobtrack.hpp b/thirdparty/includes/OpenCV/opencv2/legacy/blobtrack.hpp
new file mode 100644
index 0000000..496b8be
--- /dev/null
+++ b/thirdparty/includes/OpenCV/opencv2/legacy/blobtrack.hpp
@@ -0,0 +1,948 @@
+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#ifndef __OPENCV_VIDEOSURVEILLANCE_H__
+#define __OPENCV_VIDEOSURVEILLANCE_H__
+
+/* Turn off the functionality until cvaux/src/Makefile.am gets updated: */
+//#if _MSC_VER >= 1200
+
+#include "opencv2/core/core_c.h"
+#include <stdio.h>
+
+#if (defined _MSC_VER && _MSC_VER >= 1200) || defined __BORLANDC__
+#define cv_stricmp stricmp
+#define cv_strnicmp strnicmp
+#if defined WINCE
+#define strdup _strdup
+#define stricmp _stricmp
+#endif
+#elif defined __GNUC__ || defined __sun
+#define cv_stricmp strcasecmp
+#define cv_strnicmp strncasecmp
+#else
+#error Do not know how to make case-insensitive string comparison on this platform
+#endif
+
+//struct DefParam;
+struct CvDefParam
+{
+    struct CvDefParam*    next;
+    char*               pName;
+    char*               pComment;
+    double*             pDouble;
+    double              Double;
+    float*              pFloat;
+    float               Float;
+    int*                pInt;
+    int                 Int;
+    char**              pStr;
+    char*               Str;
+};
+
+class CV_EXPORTS CvVSModule
+{
+private: /* Internal data: */
+    CvDefParam*   m_pParamList;
+    char*       m_pModuleTypeName;
+    char*       m_pModuleName;
+    char*       m_pNickName;
+protected:
+    int         m_Wnd;
+public: /* Constructor and destructor: */
+    CvVSModule();
+    virtual ~CvVSModule();
+private: /* Internal functions: */
+    void    FreeParam(CvDefParam** pp);
+    CvDefParam* NewParam(const char* name);
+    CvDefParam* GetParamPtr(int index);
+    CvDefParam* GetParamPtr(const char* name);
+protected: /* INTERNAL INTERFACE */
+    int  IsParam(const char* name);
+    void AddParam(const char* name, double* pAddr);
+    void AddParam(const char* name, float* pAddr);
+    void AddParam(const char* name, int* pAddr);
+    void AddParam(const char* name, const char** pAddr);
+    void AddParam(const char* name);
+    void CommentParam(const char* name, const char* pComment);
+    void SetTypeName(const char* name);
+    void SetModuleName(const char* name);
+    void DelParam(const char* name);
+
+public: /* EXTERNAL INTERFACE */
+    const char* GetParamName(int index);
+    const char* GetParamComment(const char* name);
+    double GetParam(const char* name);
+    const char* GetParamStr(const char* name);
+    void   SetParam(const char* name, double val);
+    void   SetParamStr(const char* name, const char* str);
+    void TransferParamsFromChild(CvVSModule* pM, const char* prefix = NULL);
+    void TransferParamsToChild(CvVSModule* pM, char* prefix = NULL);
+    virtual void ParamUpdate();
+    const char*   GetTypeName();
+    int     IsModuleTypeName(const char* name);
+    char*   GetModuleName();
+    int     IsModuleName(const char* name);
+    void SetNickName(const char* pStr);
+    const char* GetNickName();
+    virtual void SaveState(CvFileStorage*);
+    virtual void LoadState(CvFileStorage*, CvFileNode*);
+
+    virtual void Release() = 0;
+};/* CvVMModule */
+
+CV_EXPORTS void cvWriteStruct(CvFileStorage* fs, const char* name, void* addr, const char* desc, int num=1);
+CV_EXPORTS void cvReadStructByName(CvFileStorage* fs, CvFileNode* node, const char* name, void* addr, const char* desc);
+
+/* FOREGROUND DETECTOR INTERFACE */
+class CV_EXPORTS CvFGDetector : public CvVSModule
+{
+public:
+    CvFGDetector();
+    virtual IplImage* GetMask() = 0;
+    /* Process current image: */
+    virtual void    Process(IplImage* pImg) = 0;
+    /* Release foreground detector: */
+    virtual void    Release() = 0;
+};
+
+CV_EXPORTS void cvReleaseFGDetector(CvFGDetector** ppT );
+CV_EXPORTS CvFGDetector* cvCreateFGDetectorBase(int type, void *param);
+
+
+/* BLOB STRUCTURE*/
+struct CvBlob
+{
+    float   x,y; /* blob position   */
+    float   w,h; /* blob sizes      */
+    int     ID;  /* blob ID         */
+};
+
+inline CvBlob cvBlob(float x,float y, float w, float h)
+{
+    CvBlob B = {x,y,w,h,0};
+    return B;
+}
+#define CV_BLOB_MINW 5
+#define CV_BLOB_MINH 5
+#define CV_BLOB_ID(pB) (((CvBlob*)(pB))->ID)
+#define CV_BLOB_CENTER(pB) cvPoint2D32f(((CvBlob*)(pB))->x,((CvBlob*)(pB))->y)
+#define CV_BLOB_X(pB) (((CvBlob*)(pB))->x)
+#define CV_BLOB_Y(pB) (((CvBlob*)(pB))->y)
+#define CV_BLOB_WX(pB) (((CvBlob*)(pB))->w)
+#define CV_BLOB_WY(pB) (((CvBlob*)(pB))->h)
+#define CV_BLOB_RX(pB) (0.5f*CV_BLOB_WX(pB))
+#define CV_BLOB_RY(pB) (0.5f*CV_BLOB_WY(pB))
+#define CV_BLOB_RECT(pB) cvRect(cvRound(((CvBlob*)(pB))->x-CV_BLOB_RX(pB)),cvRound(((CvBlob*)(pB))->y-CV_BLOB_RY(pB)),cvRound(CV_BLOB_WX(pB)),cvRound(CV_BLOB_WY(pB)))
+/* END BLOB STRUCTURE*/
+
+
+/* simple BLOBLIST */
+class CV_EXPORTS CvBlobSeq
+{
+public:
+    CvBlobSeq(int BlobSize = sizeof(CvBlob))
+    {
+        m_pMem = cvCreateMemStorage();
+        m_pSeq = cvCreateSeq(0,sizeof(CvSeq),BlobSize,m_pMem);
+        strcpy(m_pElemFormat,"ffffi");
+    }
+    virtual ~CvBlobSeq()
+    {
+        cvReleaseMemStorage(&m_pMem);
+    };
+    virtual CvBlob* GetBlob(int BlobIndex)
+    {
+        return (CvBlob*)cvGetSeqElem(m_pSeq,BlobIndex);
+    };
+    virtual CvBlob* GetBlobByID(int BlobID)
+    {
+        int i;
+        for(i=0; i<m_pSeq->total; ++i)
+            if(BlobID == CV_BLOB_ID(GetBlob(i)))
+                return GetBlob(i);
+        return NULL;
+    };
+    virtual void DelBlob(int BlobIndex)
+    {
+        cvSeqRemove(m_pSeq,BlobIndex);
+    };
+    virtual void DelBlobByID(int BlobID)
+    {
+        int i;
+        for(i=0; i<m_pSeq->total; ++i)
+        {
+            if(BlobID == CV_BLOB_ID(GetBlob(i)))
+            {
+                DelBlob(i);
+                return;
+            }
+        }
+    };
+    virtual void Clear()
+    {
+        cvClearSeq(m_pSeq);
+    };
+    virtual void AddBlob(CvBlob* pB)
+    {
+        cvSeqPush(m_pSeq,pB);
+    };
+    virtual int GetBlobNum()
+    {
+        return m_pSeq->total;
+    };
+    virtual void Write(CvFileStorage* fs, const char* name)
+    {
+        const char*  attr[] = {"dt",m_pElemFormat,NULL};
+        if(fs)
+        {
+            cvWrite(fs,name,m_pSeq,cvAttrList(attr,NULL));
+        }
+    }
+    virtual void Load(CvFileStorage* fs, CvFileNode* node)
+    {
+        if(fs==NULL) return;
+        CvSeq* pSeq = (CvSeq*)cvRead(fs, node);
+        if(pSeq)
+        {
+            int i;
+            cvClearSeq(m_pSeq);
+            for(i=0;i<pSeq->total;++i)
+            {
+                void* pB = cvGetSeqElem( pSeq, i );
+                cvSeqPush( m_pSeq, pB );
+            }
+        }
+    }
+    void AddFormat(const char* str){strcat(m_pElemFormat,str);}
+protected:
+    CvMemStorage*   m_pMem;
+    CvSeq*          m_pSeq;
+    char            m_pElemFormat[1024];
+};
+/* simple BLOBLIST */
+
+
+/* simple TRACKLIST */
+struct CvBlobTrack
+{
+    int         TrackID;
+    int         StartFrame;
+    CvBlobSeq*  pBlobSeq;
+};
+
+class CV_EXPORTS CvBlobTrackSeq
+{
+public:
+    CvBlobTrackSeq(int TrackSize = sizeof(CvBlobTrack));
+    virtual ~CvBlobTrackSeq();
+    virtual CvBlobTrack* GetBlobTrack(int TrackIndex);
+    virtual CvBlobTrack* GetBlobTrackByID(int TrackID);
+    virtual void DelBlobTrack(int TrackIndex);
+    virtual void DelBlobTrackByID(int TrackID);
+    virtual void Clear();
+    virtual void AddBlobTrack(int TrackID, int StartFrame = 0);
+    virtual int GetBlobTrackNum();
+protected:
+    CvMemStorage*   m_pMem;
+    CvSeq*          m_pSeq;
+};
+
+/* simple TRACKLIST */
+
+
+/* BLOB DETECTOR INTERFACE */
+class CV_EXPORTS CvBlobDetector: public CvVSModule
+{
+public:
+    CvBlobDetector(){SetTypeName("BlobDetector");};
+    /* Try to detect new blob entrance based on foreground mask. */
+    /* pFGMask - image of foreground mask */
+    /* pNewBlob - pointer to CvBlob structure which will be filled if new blob entrance detected */
+    /* pOldBlobList - pointer to blob list which already exist on image */
+    virtual int DetectNewBlob(IplImage* pImg, IplImage* pImgFG, CvBlobSeq* pNewBlobList, CvBlobSeq* pOldBlobList) = 0;
+    /* release blob detector */
+    virtual void Release()=0;
+};
+
+/* Release any blob detector: */
+CV_EXPORTS void cvReleaseBlobDetector(CvBlobDetector** ppBD);
+
+/* Declarations of constructors of implemented modules: */
+CV_EXPORTS CvBlobDetector* cvCreateBlobDetectorSimple();
+CV_EXPORTS CvBlobDetector* cvCreateBlobDetectorCC();
+
+struct CV_EXPORTS CvDetectedBlob : public CvBlob
+{
+    float response;
+};
+
+CV_INLINE CvDetectedBlob cvDetectedBlob( float x, float y, float w, float h, int ID = 0, float response = 0.0F )
+{
+    CvDetectedBlob b;
+    b.x = x; b.y = y; b.w = w; b.h = h; b.ID = ID; b.response = response;
+    return b;
+}
+
+
+class CV_EXPORTS CvObjectDetector
+{
+public:
+    CvObjectDetector( const char* /*detector_file_name*/ = 0 );
+    ~CvObjectDetector();
+
+    /*
+     * Release the current detector and load new detector from file
+     * (if detector_file_name is not 0)
+     * Return true on success:
+     */
+    bool Load( const char* /*detector_file_name*/ = 0 );
+
+    /* Return min detector window size: */
+    CvSize GetMinWindowSize() const;
+
+    /* Return max border: */
+    int GetMaxBorderSize() const;
+
+    /*
+     * Detect the object on the image and push the detected
+     * blobs into <detected_blob_seq> which must be the sequence of <CvDetectedBlob>s
+     */
+    void Detect( const CvArr* /*img*/, /* out */ CvBlobSeq* /*detected_blob_seq*/ = 0 );
+
+protected:
+    class CvObjectDetectorImpl* impl;
+};
+
+
+CV_INLINE CvRect cvRectIntersection( const CvRect r1, const CvRect r2 )
+{
+    CvRect r = cvRect( MAX(r1.x, r2.x), MAX(r1.y, r2.y), 0, 0 );
+
+    r.width  = MIN(r1.x + r1.width, r2.x + r2.width) - r.x;
+    r.height = MIN(r1.y + r1.height, r2.y + r2.height) - r.y;
+
+    return r;
+}
+
+
+/*
+ * CvImageDrawer
+ *
+ * Draw on an image the specified ROIs from the source image and
+ * given blobs as ellipses or rectangles:
+ */
+
+struct CvDrawShape
+{
+    enum {RECT, ELLIPSE} shape;
+    CvScalar color;
+};
+
+/*extern const CvDrawShape icv_shape[] =
+{
+    { CvDrawShape::ELLIPSE, CV_RGB(255,0,0) },
+    { CvDrawShape::ELLIPSE, CV_RGB(0,255,0) },
+    { CvDrawShape::ELLIPSE, CV_RGB(0,0,255) },
+    { CvDrawShape::ELLIPSE, CV_RGB(255,255,0) },
+    { CvDrawShape::ELLIPSE, CV_RGB(0,255,255) },
+    { CvDrawShape::ELLIPSE, CV_RGB(255,0,255) }
+};*/
+
+class CV_EXPORTS CvImageDrawer
+{
+public:
+    CvImageDrawer() : m_image(0) {}
+    ~CvImageDrawer() { cvReleaseImage( &m_image ); }
+    void SetShapes( const CvDrawShape* shapes, int num );
+    /* <blob_seq> must be the sequence of <CvDetectedBlob>s */
+    IplImage* Draw( const CvArr* src, CvBlobSeq* blob_seq = 0, const CvSeq* roi_seq = 0 );
+    IplImage* GetImage() { return m_image; }
+protected:
+    //static const int MAX_SHAPES = sizeof(icv_shape) / sizeof(icv_shape[0]);;
+
+    IplImage* m_image;
+    CvDrawShape m_shape[16];
+};
+
+
+
+/* Trajectory generation module: */
+class CV_EXPORTS CvBlobTrackGen: public CvVSModule
+{
+public:
+    CvBlobTrackGen(){SetTypeName("BlobTrackGen");};
+    virtual void    SetFileName(char* pFileName) = 0;
+    virtual void    AddBlob(CvBlob* pBlob) = 0;
+    virtual void    Process(IplImage* pImg = NULL, IplImage* pFG = NULL) = 0;
+    virtual void    Release() = 0;
+};
+
+inline void cvReleaseBlobTrackGen(CvBlobTrackGen** pBTGen)
+{
+    if(*pBTGen)(*pBTGen)->Release();
+    *pBTGen = 0;
+}
+
+/* Declarations of constructors of implemented modules: */
+CV_EXPORTS CvBlobTrackGen* cvCreateModuleBlobTrackGen1();
+CV_EXPORTS CvBlobTrackGen* cvCreateModuleBlobTrackGenYML();
+
+
+
+/* BLOB TRACKER INTERFACE */
+class CV_EXPORTS CvBlobTracker: public CvVSModule
+{
+public:
+    CvBlobTracker();
+
+    /* Add new blob to track it and assign to this blob personal ID */
+    /* pBlob - pointer to structure with blob parameters (ID is ignored)*/
+    /* pImg - current image */
+    /* pImgFG - current foreground mask */
+    /* Return pointer to new added blob: */
+    virtual CvBlob* AddBlob(CvBlob* pBlob, IplImage* pImg, IplImage* pImgFG = NULL ) = 0;
+
+    /* Return number of currently tracked blobs: */
+    virtual int     GetBlobNum() = 0;
+
+    /* Return pointer to specified by index blob: */
+    virtual CvBlob* GetBlob(int BlobIndex) = 0;
+
+    /* Delete blob by its index: */
+    virtual void    DelBlob(int BlobIndex) = 0;
+
+    /* Process current image and track all existed blobs: */
+    virtual void    Process(IplImage* pImg, IplImage* pImgFG = NULL) = 0;
+
+    /* Release blob tracker: */
+    virtual void    Release() = 0;
+
+
+    /* Process one blob (for multi hypothesis tracing): */
+    virtual void ProcessBlob(int BlobIndex, CvBlob* pBlob, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
+
+    /* Get confidence/wieght/probability (0-1) for blob: */
+    virtual double  GetConfidence(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
+
+    virtual double GetConfidenceList(CvBlobSeq* pBlobList, IplImage* pImg, IplImage* pImgFG = NULL);
+
+    virtual void UpdateBlob(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
+
+    /* Update all blob models: */
+    virtual void Update(IplImage* pImg, IplImage* pImgFG = NULL);
+
+    /* Return pointer to blob by its unique ID: */
+    virtual int     GetBlobIndexByID(int BlobID);
+
+    /* Return pointer to blob by its unique ID: */
+    virtual CvBlob* GetBlobByID(int BlobID);
+
+    /* Delete blob by its ID: */
+    virtual void    DelBlobByID(int BlobID);
+
+    /* Set new parameters for specified (by index) blob: */
+    virtual void    SetBlob(int /*BlobIndex*/, CvBlob* /*pBlob*/);
+
+    /* Set new parameters for specified (by ID) blob: */
+    virtual void    SetBlobByID(int BlobID, CvBlob* pBlob);
+
+    /*  ===============  MULTI HYPOTHESIS INTERFACE ==================  */
+
+    /* Return number of position hyposetis of currently tracked blob: */
+    virtual int     GetBlobHypNum(int /*BlobIdx*/);
+
+    /* Return pointer to specified blob hypothesis by index blob: */
+    virtual CvBlob* GetBlobHyp(int BlobIndex, int /*hypothesis*/);
+
+    /* Set new parameters for specified (by index) blob hyp
+     * (can be called several times for each hyp ):
+     */
+    virtual void    SetBlobHyp(int /*BlobIndex*/, CvBlob* /*pBlob*/);
+};
+
+CV_EXPORTS void cvReleaseBlobTracker(CvBlobTracker**ppT );
+/* BLOB TRACKER INTERFACE */
+
+/*BLOB TRACKER ONE INTERFACE */
+class CV_EXPORTS CvBlobTrackerOne : public CvVSModule
+{
+public:
+    virtual void Init(CvBlob* pBlobInit, IplImage* pImg, IplImage* pImgFG = NULL) = 0;
+    virtual CvBlob* Process(CvBlob* pBlobPrev, IplImage* pImg, IplImage* pImgFG = NULL) = 0;
+    virtual void Release() =  0;
+
+    /* Non-required methods: */
+    virtual void SkipProcess(CvBlob* /*pBlobPrev*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL){};
+    virtual void Update(CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL){};
+    virtual void SetCollision(int /*CollisionFlag*/){}; /* call in case of blob collision situation*/
+    virtual double GetConfidence(CvBlob* /*pBlob*/, IplImage* /*pImg*/,
+                                 IplImage* /*pImgFG*/ = NULL, IplImage* /*pImgUnusedReg*/ = NULL)
+    {
+        return 1;
+    };
+};
+inline void cvReleaseBlobTrackerOne(CvBlobTrackerOne **ppT )
+{
+    ppT[0]->Release();
+    ppT[0] = 0;
+}
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerList(CvBlobTrackerOne* (*create)());
+/*BLOB TRACKER ONE INTERFACE */
+
+/* Declarations of constructors of implemented modules: */
+
+/* Some declarations for specific MeanShift tracker: */
+#define PROFILE_EPANECHNIKOV    0
+#define PROFILE_DOG             1
+struct CvBlobTrackerParamMS
+{
+    int     noOfSigBits;
+    int     appearance_profile;
+    int     meanshift_profile;
+    float   sigma;
+};
+
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS1(CvBlobTrackerParamMS* param);
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS2(CvBlobTrackerParamMS* param);
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS1ByList();
+
+/* Some declarations for specific Likelihood tracker: */
+struct CvBlobTrackerParamLH
+{
+    int     HistType; /* see Prob.h */
+    int     ScaleAfter;
+};
+
+/* Without scale optimization: */
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerLHR(CvBlobTrackerParamLH* /*param*/ = NULL);
+
+/* With scale optimization: */
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerLHRS(CvBlobTrackerParamLH* /*param*/ = NULL);
+
+/* Simple blob tracker based on connected component tracking: */
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerCC();
+
+/* Connected component tracking and mean-shift particle filter collion-resolver: */
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerCCMSPF();
+
+/* Blob tracker that integrates meanshift and connected components: */
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSFG();
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSFGS();
+
+/* Meanshift without connected-components */
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS();
+
+/* Particle filtering via Bhattacharya coefficient, which        */
+/* is roughly the dot-product of two probability densities.      */
+/* See: Real-Time Tracking of Non-Rigid Objects using Mean Shift */
+/*      Comanicius, Ramesh, Meer, 2000, 8p                       */
+/*      http://citeseer.ist.psu.edu/321441.html                  */
+CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSPF();
+
+/* =========== tracker integrators trackers =============*/
+
+/* Integrator based on Particle Filtering method: */
+//CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIPF();
+
+/* Rule based integrator: */
+//CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIRB();
+
+/* Integrator based on data fusion using particle filtering: */
+//CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIPFDF();
+
+
+
+
+/* Trajectory postprocessing module: */
+class CV_EXPORTS CvBlobTrackPostProc: public CvVSModule
+{
+public:
+    CvBlobTrackPostProc(){SetTypeName("BlobTrackPostProc");};
+    virtual void    AddBlob(CvBlob* pBlob) = 0;
+    virtual void    Process() = 0;
+    virtual int     GetBlobNum() = 0;
+    virtual CvBlob* GetBlob(int index) = 0;
+    virtual void    Release() = 0;
+
+    /* Additional functionality: */
+    virtual CvBlob* GetBlobByID(int BlobID)
+    {
+        int i;
+        for(i=GetBlobNum();i>0;i--)
+        {
+            CvBlob* pB=GetBlob(i-1);
+            if(pB->ID==BlobID) return pB;
+        }
+        return NULL;
+    };
+};
+
+inline void cvReleaseBlobTrackPostProc(CvBlobTrackPostProc** pBTPP)
+{
+    if(pBTPP == NULL) return;
+    if(*pBTPP)(*pBTPP)->Release();
+    *pBTPP = 0;
+}
+
+/* Trajectory generation module: */
+class CV_EXPORTS CvBlobTrackPostProcOne: public CvVSModule
+{
+public:
+    CvBlobTrackPostProcOne(){SetTypeName("BlobTrackPostOne");};
+    virtual CvBlob* Process(CvBlob* pBlob) = 0;
+    virtual void    Release() = 0;
+};
+
+/* Create blob tracking post processing module based on simle module: */
+CV_EXPORTS CvBlobTrackPostProc* cvCreateBlobTrackPostProcList(CvBlobTrackPostProcOne* (*create)());
+
+
+/* Declarations of constructors of implemented modules: */
+CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcKalman();
+CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcTimeAverRect();
+CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcTimeAverExp();
+
+
+/* PREDICTORS */
+/* blob PREDICTOR */
+class CvBlobTrackPredictor: public CvVSModule
+{
+public:
+    CvBlobTrackPredictor(){SetTypeName("BlobTrackPredictor");};
+    virtual CvBlob* Predict() = 0;
+    virtual void    Update(CvBlob* pBlob) = 0;
+    virtual void    Release() = 0;
+};
+CV_EXPORTS CvBlobTrackPredictor* cvCreateModuleBlobTrackPredictKalman();
+
+
+
+/* Trajectory analyser module: */
+class CV_EXPORTS CvBlobTrackAnalysis: public CvVSModule
+{
+public:
+    CvBlobTrackAnalysis(){SetTypeName("BlobTrackAnalysis");};
+    virtual void    AddBlob(CvBlob* pBlob) = 0;
+    virtual void    Process(IplImage* pImg, IplImage* pFG) = 0;
+    virtual float   GetState(int BlobID) = 0;
+    /* return 0 if trajectory is normal
+       return >0 if trajectory abnormal */
+    virtual const char*   GetStateDesc(int /*BlobID*/){return NULL;};
+    virtual void    SetFileName(char* /*DataBaseName*/){};
+    virtual void    Release() = 0;
+};
+
+
+inline void cvReleaseBlobTrackAnalysis(CvBlobTrackAnalysis** pBTPP)
+{
+    if(pBTPP == NULL) return;
+    if(*pBTPP)(*pBTPP)->Release();
+    *pBTPP = 0;
+}
+
+/* Feature-vector generation module: */
+class CV_EXPORTS CvBlobTrackFVGen : public CvVSModule
+{
+public:
+    CvBlobTrackFVGen(){SetTypeName("BlobTrackFVGen");};
+    virtual void    AddBlob(CvBlob* pBlob) = 0;
+    virtual void    Process(IplImage* pImg, IplImage* pFG) = 0;
+    virtual void    Release() = 0;
+    virtual int     GetFVSize() = 0;
+    virtual int     GetFVNum() = 0;
+    virtual float*  GetFV(int index, int* pFVID) = 0; /* Returns pointer to FV, if return 0 then FV not created */
+    virtual float*  GetFVVar(){return NULL;}; /* Returns pointer to array of variation of values of FV, if returns 0 then FVVar does not exist. */
+    virtual float*  GetFVMin() = 0; /* Returns pointer to array of minimal values of FV, if returns 0 then FVrange does not exist */
+    virtual float*  GetFVMax() = 0; /* Returns pointer to array of maximal values of FV, if returns 0 then FVrange does not exist */
+};
+
+
+/* Trajectory Analyser module: */
+class CV_EXPORTS CvBlobTrackAnalysisOne
+{
+public:
+    virtual ~CvBlobTrackAnalysisOne() {};
+    virtual int     Process(CvBlob* pBlob, IplImage* pImg, IplImage* pFG) = 0;
+    /* return 0 if trajectory is normal
+       return >0 if trajectory abnormal */
+    virtual void    Release() = 0;
+};
+
+/* Create blob tracking post processing module based on simle module: */
+CV_EXPORTS CvBlobTrackAnalysis* cvCreateBlobTrackAnalysisList(CvBlobTrackAnalysisOne* (*create)());
+
+/* Declarations of constructors of implemented modules: */
+
+/* Based on histogram analysis of 2D FV (x,y): */
+CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistP();
+
+/* Based on histogram analysis of 4D FV (x,y,vx,vy): */
+CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPV();
+
+/* Based on histogram analysis of 5D FV (x,y,vx,vy,state): */
+CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPVS();
+
+/* Based on histogram analysis of 4D FV (startpos,stoppos): */
+CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistSS();
+
+
+
+/* Based on SVM classifier analysis of 2D FV (x,y): */
+//CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMP();
+
+/* Based on SVM classifier analysis of 4D FV (x,y,vx,vy): */
+//CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPV();
+
+/* Based on SVM classifier analysis of 5D FV (x,y,vx,vy,state): */
+//CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPVS();
+
+/* Based on SVM classifier analysis of 4D FV (startpos,stoppos): */
+//CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMSS();
+
+/* Track analysis based on distance between tracks: */
+CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisTrackDist();
+
+/* Analyzer based on reation Road and height map: */
+//CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysis3DRoadMap();
+
+/* Analyzer that makes OR decision using set of analyzers: */
+CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisIOR();
+
+/* Estimator of human height: */
+class CV_EXPORTS CvBlobTrackAnalysisHeight: public CvBlobTrackAnalysis
+{
+public:
+    virtual double  GetHeight(CvBlob* pB) = 0;
+};
+//CV_EXPORTS CvBlobTrackAnalysisHeight* cvCreateModuleBlobTrackAnalysisHeightScale();
+
+
+
+/* AUTO BLOB TRACKER INTERFACE -- pipeline of 3 modules: */
+class CV_EXPORTS CvBlobTrackerAuto: public CvVSModule
+{
+public:
+    CvBlobTrackerAuto(){SetTypeName("BlobTrackerAuto");};
+    virtual void        Process(IplImage* pImg, IplImage* pMask = NULL) = 0;
+    virtual CvBlob*     GetBlob(int index) = 0;
+    virtual CvBlob*     GetBlobByID(int ID) = 0;
+    virtual int         GetBlobNum() = 0;
+    virtual IplImage*   GetFGMask(){return NULL;};
+    virtual float       GetState(int BlobID) = 0;
+    virtual const char*       GetStateDesc(int BlobID) = 0;
+    /* return 0 if trajectory is normal;
+     * return >0 if trajectory abnormal. */
+    virtual void    Release() = 0;
+};
+inline void cvReleaseBlobTrackerAuto(CvBlobTrackerAuto** ppT)
+{
+    ppT[0]->Release();
+    ppT[0] = 0;
+}
+/* END AUTO BLOB TRACKER INTERFACE */
+
+
+/* Constructor functions and data for specific BlobTRackerAuto modules: */
+
+/* Parameters of blobtracker auto ver1: */
+struct CvBlobTrackerAutoParam1
+{
+    int                     FGTrainFrames; /* Number of frames needed for FG (foreground) detector to train.        */
+
+    CvFGDetector*           pFG;           /* FGDetector module. If this field is NULL the Process FG mask is used. */
+
+    CvBlobDetector*         pBD;           /* Selected blob detector module. 					    */
+                                           /* If this field is NULL default blobdetector module will be created.    */
+
+    CvBlobTracker*          pBT;           /* Selected blob tracking module.					    */
+                                           /* If this field is NULL default blobtracker module will be created.     */
+
+    CvBlobTrackGen*         pBTGen;        /* Selected blob trajectory generator.				    */
+                                           /* If this field is NULL no generator is used.                           */
+
+    CvBlobTrackPostProc*    pBTPP;         /* Selected blob trajectory postprocessing module.			    */
+                                           /* If this field is NULL no postprocessing is done.                      */
+
+    int                     UsePPData;
+
+    CvBlobTrackAnalysis*    pBTA;          /* Selected blob trajectory analysis module.                             */
+                                           /* If this field is NULL no track analysis is done.                      */
+};
+
+/* Create blob tracker auto ver1: */
+CV_EXPORTS CvBlobTrackerAuto* cvCreateBlobTrackerAuto1(CvBlobTrackerAutoParam1* param = NULL);
+
+/* Simple loader for many auto trackers by its type : */
+inline CvBlobTrackerAuto* cvCreateBlobTrackerAuto(int type, void* param)
+{
+    if(type == 0) return cvCreateBlobTrackerAuto1((CvBlobTrackerAutoParam1*)param);
+    return 0;
+}
+
+
+
+struct CvTracksTimePos
+{
+    int len1,len2;
+    int beg1,beg2;
+    int end1,end2;
+    int comLen; //common length for two tracks
+    int shift1,shift2;
+};
+
+/*CV_EXPORTS int cvCompareTracks( CvBlobTrackSeq *groundTruth,
+                   CvBlobTrackSeq *result,
+                   FILE *file);*/
+
+
+/* Constructor functions:  */
+
+CV_EXPORTS void cvCreateTracks_One(CvBlobTrackSeq *TS);
+CV_EXPORTS void cvCreateTracks_Same(CvBlobTrackSeq *TS1, CvBlobTrackSeq *TS2);
+CV_EXPORTS void cvCreateTracks_AreaErr(CvBlobTrackSeq *TS1, CvBlobTrackSeq *TS2, int addW, int addH);
+
+
+/* HIST API */
+class CV_EXPORTS CvProb
+{
+public:
+    virtual ~CvProb() {};
+
+    /* Calculate probability value: */
+    virtual double Value(int* /*comp*/, int /*x*/ = 0, int /*y*/ = 0){return -1;};
+
+    /* Update histograpp Pnew = (1-W)*Pold + W*Padd*/
+    /* W weight of new added prob */
+    /* comps - matrix of new fetature vectors used to update prob */
+    virtual void AddFeature(float W, int* comps, int x =0, int y = 0) = 0;
+    virtual void Scale(float factor = 0, int x = -1, int y = -1) = 0;
+    virtual void Release() = 0;
+};
+inline void cvReleaseProb(CvProb** ppProb){ppProb[0]->Release();ppProb[0]=NULL;}
+/* HIST API */
+
+/* Some Prob: */
+CV_EXPORTS CvProb* cvCreateProbS(int dim, CvSize size, int sample_num);
+CV_EXPORTS CvProb* cvCreateProbMG(int dim, CvSize size, int sample_num);
+CV_EXPORTS CvProb* cvCreateProbMG2(int dim, CvSize size, int sample_num);
+CV_EXPORTS CvProb* cvCreateProbHist(int dim, CvSize size);
+
+#define CV_BT_HIST_TYPE_S     0
+#define CV_BT_HIST_TYPE_MG    1
+#define CV_BT_HIST_TYPE_MG2   2
+#define CV_BT_HIST_TYPE_H     3
+inline CvProb* cvCreateProb(int type, int dim, CvSize size = cvSize(1,1), void* /*param*/ = NULL)
+{
+    if(type == CV_BT_HIST_TYPE_S) return cvCreateProbS(dim, size, -1);
+    if(type == CV_BT_HIST_TYPE_MG) return cvCreateProbMG(dim, size, -1);
+    if(type == CV_BT_HIST_TYPE_MG2) return cvCreateProbMG2(dim, size, -1);
+    if(type == CV_BT_HIST_TYPE_H) return cvCreateProbHist(dim, size);
+    return NULL;
+}
+
+
+
+/* Noise type definitions: */
+#define CV_NOISE_NONE               0
+#define CV_NOISE_GAUSSIAN           1
+#define CV_NOISE_UNIFORM            2
+#define CV_NOISE_SPECKLE            3
+#define CV_NOISE_SALT_AND_PEPPER    4
+
+/* Add some noise to image: */
+/* pImg - (input) image without noise */
+/* pImg - (output) image with noise */
+/* noise_type - type of added noise */
+/*  CV_NOISE_GAUSSIAN - pImg += n , n - is gaussian noise with Ampl standart deviation */
+/*  CV_NOISE_UNIFORM - pImg += n , n - is uniform noise with Ampl standart deviation */
+/*  CV_NOISE_SPECKLE - pImg += n*pImg , n - is gaussian noise with Ampl standart deviation */
+/*  CV_NOISE_SALT_AND_PAPPER - pImg = pImg with blacked and whited pixels,
+            Ampl is density of brocken pixels (0-there are not broken pixels, 1 - all pixels are broken)*/
+/* Ampl - "amplitude" of noise */
+//CV_EXPORTS void cvAddNoise(IplImage* pImg, int noise_type, double Ampl, CvRNG* rnd_state = NULL);
+
+/*================== GENERATOR OF TEST VIDEO SEQUENCE ===================== */
+typedef void CvTestSeq;
+
+/* pConfigfile - Name of file (yml or xml) with description of test sequence */
+/* videos - array of names of test videos described in "pConfigfile" file */
+/* numvideos - size of "videos" array */
+CV_EXPORTS CvTestSeq* cvCreateTestSeq(char* pConfigfile, char** videos, int numvideo, float Scale = 1, int noise_type = CV_NOISE_NONE, double noise_ampl = 0);
+CV_EXPORTS void cvReleaseTestSeq(CvTestSeq** ppTestSeq);
+
+/* Generate next frame from test video seq and return pointer to it: */
+CV_EXPORTS IplImage* cvTestSeqQueryFrame(CvTestSeq* pTestSeq);
+
+/* Return pointer to current foreground mask: */
+CV_EXPORTS IplImage* cvTestSeqGetFGMask(CvTestSeq* pTestSeq);
+
+/* Return pointer to current image: */
+CV_EXPORTS IplImage* cvTestSeqGetImage(CvTestSeq* pTestSeq);
+
+/* Return frame size of result test video: */
+CV_EXPORTS CvSize cvTestSeqGetImageSize(CvTestSeq* pTestSeq);
+
+/* Return number of frames result test video: */
+CV_EXPORTS int cvTestSeqFrameNum(CvTestSeq* pTestSeq);
+
+/* Return number of existing objects.
+ * This is general number of any objects.
+ * For example number of trajectories may be equal or less than returned value:
+ */
+CV_EXPORTS int cvTestSeqGetObjectNum(CvTestSeq* pTestSeq);
+
+/* Return 0 if there is not position for current defined on current frame */
+/* Return 1 if there is object position and pPos was filled */
+CV_EXPORTS int cvTestSeqGetObjectPos(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pPos);
+CV_EXPORTS int cvTestSeqGetObjectSize(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pSize);
+
+/* Add noise to final image: */
+CV_EXPORTS void cvTestSeqAddNoise(CvTestSeq* pTestSeq, int noise_type = CV_NOISE_NONE, double noise_ampl = 0);
+
+/* Add Intensity variation: */
+CV_EXPORTS void cvTestSeqAddIntensityVariation(CvTestSeq* pTestSeq, float DI_per_frame, float MinI, float MaxI);
+CV_EXPORTS void cvTestSeqSetFrame(CvTestSeq* pTestSeq, int n);
+
+#endif
+
+/* End of file. */
diff --git a/thirdparty/includes/OpenCV/opencv2/legacy/compat.hpp b/thirdparty/includes/OpenCV/opencv2/legacy/compat.hpp
new file mode 100644
index 0000000..5b5495e
--- /dev/null
+++ b/thirdparty/includes/OpenCV/opencv2/legacy/compat.hpp
@@ -0,0 +1,740 @@
+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright( C) 2000, Intel Corporation, 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 Intel Corporation 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*/
+
+/*
+   A few macros and definitions for backward compatibility
+   with the previous versions of OpenCV. They are obsolete and
+   are likely to be removed in future. To check whether your code
+   uses any of these, define CV_NO_BACKWARD_COMPATIBILITY before
+   including cv.h.
+*/
+
+#ifndef __OPENCV_COMPAT_HPP__
+#define __OPENCV_COMPAT_HPP__
+
+#include "opencv2/core/core_c.h"
+#include "opencv2/imgproc/types_c.h"
+
+#include <math.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int CvMatType;
+typedef int CvDisMaskType;
+typedef CvMat CvMatArray;
+
+typedef int CvThreshType;
+typedef int CvAdaptiveThreshMethod;
+typedef int CvCompareMethod;
+typedef int CvFontFace;
+typedef int CvPolyApproxMethod;
+typedef int CvContoursMatchMethod;
+typedef int CvContourTreesMatchMethod;
+typedef int CvCoeffType;
+typedef int CvRodriguesType;
+typedef int CvElementShape;
+typedef int CvMorphOp;
+typedef int CvTemplMatchMethod;
+
+typedef CvPoint2D64f CvPoint2D64d;
+typedef CvPoint3D64f CvPoint3D64d;
+
+enum
+{
+    CV_MAT32F      = CV_32FC1,
+    CV_MAT3x1_32F  = CV_32FC1,
+    CV_MAT4x1_32F  = CV_32FC1,
+    CV_MAT3x3_32F  = CV_32FC1,
+    CV_MAT4x4_32F  = CV_32FC1,
+
+    CV_MAT64D      = CV_64FC1,
+    CV_MAT3x1_64D  = CV_64FC1,
+    CV_MAT4x1_64D  = CV_64FC1,
+    CV_MAT3x3_64D  = CV_64FC1,
+    CV_MAT4x4_64D  = CV_64FC1
+};
+
+enum
+{
+    IPL_GAUSSIAN_5x5 = 7
+};
+
+typedef CvBox2D  CvBox2D32f;
+
+/* allocation/deallocation macros */
+#define cvCreateImageData   cvCreateData
+#define cvReleaseImageData  cvReleaseData
+#define cvSetImageData      cvSetData
+#define cvGetImageRawData   cvGetRawData
+
+#define cvmAlloc            cvCreateData
+#define cvmFree             cvReleaseData
+#define cvmAllocArray       cvCreateData
+#define cvmFreeArray        cvReleaseData
+
+#define cvIntegralImage     cvIntegral
+#define cvMatchContours     cvMatchShapes
+
+CV_EXPORTS CvMat cvMatArray( int rows, int cols, int type,
+                            int count, void* data CV_DEFAULT(0));
+
+#define cvUpdateMHIByTime  cvUpdateMotionHistory
+
+#define cvAccMask cvAcc
+#define cvSquareAccMask cvSquareAcc
+#define cvMultiplyAccMask cvMultiplyAcc
+#define cvRunningAvgMask(imgY, imgU, mask, alpha) cvRunningAvg(imgY, imgU, alpha, mask)
+
+#define cvSetHistThresh  cvSetHistBinRanges
+#define cvCalcHistMask(img, mask, hist, doNotClear) cvCalcHist(img, hist, doNotClear, mask)
+
+CV_EXPORTS double cvMean( const CvArr* image, const CvArr* mask CV_DEFAULT(0));
+CV_EXPORTS double cvSumPixels( const CvArr* image );
+CV_EXPORTS void  cvMean_StdDev( const CvArr* image, double* mean, double* sdv,
+                                const CvArr* mask CV_DEFAULT(0));
+
+CV_EXPORTS void cvmPerspectiveProject( const CvMat* mat, const CvArr* src, CvArr* dst );
+CV_EXPORTS void cvFillImage( CvArr* mat, double color );
+
+#define cvCvtPixToPlane cvSplit
+#define cvCvtPlaneToPix cvMerge
+
+typedef struct CvRandState
+{
+    CvRNG     state;    /* RNG state (the current seed and carry)*/
+    int       disttype; /* distribution type */
+    CvScalar  param[2]; /* parameters of RNG */
+} CvRandState;
+
+/* Changes RNG range while preserving RNG state */
+CV_EXPORTS void  cvRandSetRange( CvRandState* state, double param1,
+                                 double param2, int index CV_DEFAULT(-1));
+
+CV_EXPORTS void  cvRandInit( CvRandState* state, double param1,
+                             double param2, int seed,
+                             int disttype CV_DEFAULT(CV_RAND_UNI));
+
+/* Fills array with random numbers */
+CV_EXPORTS void cvRand( CvRandState* state, CvArr* arr );
+
+#define cvRandNext( _state ) cvRandInt( &(_state)->state )
+
+CV_EXPORTS void cvbRand( CvRandState* state, float* dst, int len );
+
+CV_EXPORTS void  cvbCartToPolar( const float* y, const float* x,
+                                 float* magnitude, float* angle, int len );
+CV_EXPORTS void  cvbFastArctan( const float* y, const float* x, float* angle, int len );
+CV_EXPORTS void  cvbSqrt( const float* x, float* y, int len );
+CV_EXPORTS void  cvbInvSqrt( const float* x, float* y, int len );
+CV_EXPORTS void  cvbReciprocal( const float* x, float* y, int len );
+CV_EXPORTS void  cvbFastExp( const float* x, double* y, int len );
+CV_EXPORTS void  cvbFastLog( const double* x, float* y, int len );
+
+CV_EXPORTS CvRect  cvContourBoundingRect( void* point_set, int update CV_DEFAULT(0));
+
+CV_EXPORTS double cvPseudoInverse( const CvArr* src, CvArr* dst );
+#define cvPseudoInv cvPseudoInverse
+
+#define cvContourMoments( contour, moments ) cvMoments( contour, moments, 0 )
+
+#define cvGetPtrAt              cvPtr2D
+#define cvGetAt                 cvGet2D
+#define cvSetAt(arr,val,y,x)    cvSet2D((arr),(y),(x),(val))
+
+#define cvMeanMask  cvMean
+#define cvMean_StdDevMask(img,mask,mean,sdv) cvMean_StdDev(img,mean,sdv,mask)
+
+#define cvNormMask(imgA,imgB,mask,normType) cvNorm(imgA,imgB,normType,mask)
+
+#define cvMinMaxLocMask(img, mask, min_val, max_val, min_loc, max_loc) \
+        cvMinMaxLoc(img, min_val, max_val, min_loc, max_loc, mask)
+
+#define cvRemoveMemoryManager  cvSetMemoryManager
+
+#define cvmSetZero( mat )               cvSetZero( mat )
+#define cvmSetIdentity( mat )           cvSetIdentity( mat )
+#define cvmAdd( src1, src2, dst )       cvAdd( src1, src2, dst, 0 )
+#define cvmSub( src1, src2, dst )       cvSub( src1, src2, dst, 0 )
+#define cvmCopy( src, dst )             cvCopy( src, dst, 0 )
+#define cvmMul( src1, src2, dst )       cvMatMulAdd( src1, src2, 0, dst )
+#define cvmTranspose( src, dst )        cvT( src, dst )
+#define cvmInvert( src, dst )           cvInv( src, dst )
+#define cvmMahalanobis(vec1, vec2, mat) cvMahalanobis( vec1, vec2, mat )
+#define cvmDotProduct( vec1, vec2 )     cvDotProduct( vec1, vec2 )
+#define cvmCrossProduct(vec1, vec2,dst) cvCrossProduct( vec1, vec2, dst )
+#define cvmTrace( mat )                 (cvTrace( mat )).val[0]
+#define cvmMulTransposed( src, dst, order ) cvMulTransposed( src, dst, order )
+#define cvmEigenVV( mat, evec, eval, eps)   cvEigenVV( mat, evec, eval, eps )
+#define cvmDet( mat )                   cvDet( mat )
+#define cvmScale( src, dst, scale )     cvScale( src, dst, scale )
+
+#define cvCopyImage( src, dst )         cvCopy( src, dst, 0 )
+#define cvReleaseMatHeader              cvReleaseMat
+
+/* Calculates exact convex hull of 2d point set */
+CV_EXPORTS void cvConvexHull( CvPoint* points, int num_points,
+                             CvRect* bound_rect,
+                             int orientation, int* hull, int* hullsize );
+
+
+CV_EXPORTS void cvMinAreaRect( CvPoint* points, int n,
+                              int left, int bottom,
+                              int right, int top,
+                              CvPoint2D32f* anchor,
+                              CvPoint2D32f* vect1,
+                              CvPoint2D32f* vect2 );
+
+typedef int CvDisType;
+typedef int CvChainApproxMethod;
+typedef int CvContourRetrievalMode;
+
+CV_EXPORTS  void  cvFitLine3D( CvPoint3D32f* points, int count, int dist,
+                    void *param, float reps, float aeps, float* line );
+
+/* Fits a line into set of 2d points in a robust way (M-estimator technique) */
+CV_EXPORTS  void  cvFitLine2D( CvPoint2D32f* points, int count, int dist,
+                    void *param, float reps, float aeps, float* line );
+
+CV_EXPORTS  void  cvFitEllipse( const CvPoint2D32f* points, int count, CvBox2D* box );
+
+/* Projects 2d points to one of standard coordinate planes
+   (i.e. removes one of coordinates) */
+CV_EXPORTS  void  cvProject3D( CvPoint3D32f* points3D, int count,
+                              CvPoint2D32f* points2D,
+                              int xIndx CV_DEFAULT(0),
+                              int yIndx CV_DEFAULT(1));
+
+/* Retrieves value of the particular bin
+   of x-dimensional (x=1,2,3,...) histogram */
+#define cvQueryHistValue_1D( hist, idx0 ) \
+    ((float)cvGetReal1D( (hist)->bins, (idx0)))
+#define cvQueryHistValue_2D( hist, idx0, idx1 ) \
+    ((float)cvGetReal2D( (hist)->bins, (idx0), (idx1)))
+#define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
+    ((float)cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2)))
+#define cvQueryHistValue_nD( hist, idx ) \
+    ((float)cvGetRealND( (hist)->bins, (idx)))
+
+/* Returns pointer to the particular bin of x-dimesional histogram.
+   For sparse histogram the bin is created if it didn't exist before */
+#define cvGetHistValue_1D( hist, idx0 ) \
+    ((float*)cvPtr1D( (hist)->bins, (idx0), 0))
+#define cvGetHistValue_2D( hist, idx0, idx1 ) \
+    ((float*)cvPtr2D( (hist)->bins, (idx0), (idx1), 0))
+#define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
+    ((float*)cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0))
+#define cvGetHistValue_nD( hist, idx ) \
+    ((float*)cvPtrND( (hist)->bins, (idx), 0))
+
+
+#define CV_IS_SET_ELEM_EXISTS CV_IS_SET_ELEM
+
+
+CV_EXPORTS  int  cvHoughLines( CvArr* image, double rho,
+                              double theta, int threshold,
+                              float* lines, int linesNumber );
+
+CV_EXPORTS  int  cvHoughLinesP( CvArr* image, double rho,
+                               double theta, int threshold,
+                               int lineLength, int lineGap,
+                               int* lines, int linesNumber );
+
+
+CV_EXPORTS  int  cvHoughLinesSDiv( CvArr* image, double rho, int srn,
+                                  double theta, int stn, int threshold,
+                                  float* lines, int linesNumber );
+
+CV_EXPORTS  float  cvCalcEMD( const float* signature1, int size1,
+                             const float* signature2, int size2,
+                             int dims, int dist_type CV_DEFAULT(CV_DIST_L2),
+                             CvDistanceFunction dist_func CV_DEFAULT(0),
+                             float* lower_bound CV_DEFAULT(0),
+                             void* user_param CV_DEFAULT(0));
+
+CV_EXPORTS  void  cvKMeans( int num_clusters, float** samples,
+                           int num_samples, int vec_size,
+                           CvTermCriteria termcrit, int* cluster_idx );
+
+CV_EXPORTS void  cvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
+                                  CvGraphVtx* vtx CV_DEFAULT(NULL),
+                                  int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
+
+CV_EXPORTS  void  cvEndScanGraph( CvGraphScanner* scanner );
+
+
+/* old drawing functions */
+CV_EXPORTS void  cvLineAA( CvArr* img, CvPoint pt1, CvPoint pt2,
+                            double color, int scale CV_DEFAULT(0));
+
+CV_EXPORTS void  cvCircleAA( CvArr* img, CvPoint center, int radius,
+                            double color, int scale CV_DEFAULT(0) );
+
+CV_EXPORTS void  cvEllipseAA( CvArr* img, CvPoint center, CvSize axes,
+                              double angle, double start_angle,
+                              double end_angle, double color,
+                              int scale CV_DEFAULT(0) );
+
+CV_EXPORTS void  cvPolyLineAA( CvArr* img, CvPoint** pts, int* npts, int contours,
+                              int is_closed, double color, int scale CV_DEFAULT(0) );
+
+/****************************************************************************************\
+*                                   Pixel Access Macros                                  *
+\****************************************************************************************/
+
+typedef struct _CvPixelPosition8u
+{
+    uchar*  currline;      /* pointer to the start of the current pixel line   */
+    uchar*  topline;       /* pointer to the start of the top pixel line       */
+    uchar*  bottomline;    /* pointer to the start of the first line           */
+                                    /* which is below the image                         */
+    int     x;                      /* current x coordinate ( in pixels )               */
+    int     width;                  /* width of the image  ( in pixels )                */
+    int     height;                 /* height of the image  ( in pixels )               */
+    int     step;                   /* distance between lines ( in elements of single   */
+                                    /* plane )                                          */
+    int     step_arr[3];            /* array: ( 0, -step, step ). It is used for        */
+                                    /* vertical moving                                  */
+} CvPixelPosition8u;
+
+/* this structure differs from the above only in data type */
+typedef struct _CvPixelPosition8s
+{
+    schar*  currline;
+    schar*  topline;
+    schar*  bottomline;
+    int     x;
+    int     width;
+    int     height;
+    int     step;
+    int     step_arr[3];
+} CvPixelPosition8s;
+
+/* this structure differs from the CvPixelPosition8u only in data type */
+typedef struct _CvPixelPosition32f
+{
+    float*  currline;
+    float*  topline;
+    float*  bottomline;
+    int     x;
+    int     width;
+    int     height;
+    int     step;
+    int     step_arr[3];
+} CvPixelPosition32f;
+
+
+/* Initialize one of the CvPixelPosition structures.   */
+/*  pos    - initialized structure                     */
+/*  origin - pointer to the left-top corner of the ROI */
+/*  step   - width of the whole image in bytes         */
+/*  roi    - width & height of the ROI                 */
+/*  x, y   - initial position                          */
+#define CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation)    \
+    (                                                                        \
+    (pos).step = (_step)/sizeof((pos).currline[0]) * (orientation ? -1 : 1), \
+    (pos).width = (roi).width,                                               \
+    (pos).height = (roi).height,                                             \
+    (pos).bottomline = (origin) + (pos).step*(pos).height,                   \
+    (pos).topline = (origin) - (pos).step,                                   \
+    (pos).step_arr[0] = 0,                                                   \
+    (pos).step_arr[1] = -(pos).step,                                         \
+    (pos).step_arr[2] = (pos).step,                                          \
+    (pos).x = (_x),                                                          \
+    (pos).currline = (origin) + (pos).step*(_y) )
+
+
+/* Move to specified point ( absolute shift ) */
+/*  pos    - position structure               */
+/*  x, y   - coordinates of the new position  */
+/*  cs     - number of the image channels     */
+#define CV_MOVE_TO( pos, _x, _y, cs )                                                   \
+((pos).currline = (_y) >= 0 && (_y) < (pos).height ? (pos).topline + ((_y)+1)*(pos).step : 0, \
+ (pos).x = (_x) >= 0 && (_x) < (pos).width ? (_x) : 0, (pos).currline + (_x) * (cs) )
+
+/* Get current coordinates                    */
+/*  pos    - position structure               */
+/*  x, y   - coordinates of the new position  */
+/*  cs     - number of the image channels     */
+#define CV_GET_CURRENT( pos, cs )  ((pos).currline + (pos).x * (cs))
+
+/* Move by one pixel relatively to current position */
+/*  pos    - position structure                     */
+/*  cs     - number of the image channels           */
+
+/* left */
+#define CV_MOVE_LEFT( pos, cs ) \
+ ( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* right */
+#define CV_MOVE_RIGHT( pos, cs ) \
+ ( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* up */
+#define CV_MOVE_UP( pos, cs ) \
+ (((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* down */
+#define CV_MOVE_DOWN( pos, cs ) \
+ (((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* left up */
+#define CV_MOVE_LU( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))
+
+/* right up */
+#define CV_MOVE_RU( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))
+
+/* left down */
+#define CV_MOVE_LD( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))
+
+/* right down */
+#define CV_MOVE_RD( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))
+
+
+
+/* Move by one pixel relatively to current position with wrapping when the position     */
+/* achieves image boundary                                                              */
+/*  pos    - position structure                                                         */
+/*  cs     - number of the image channels                                               */
+
+/* left */
+#define CV_MOVE_LEFT_WRAP( pos, cs ) \
+ ((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))
+
+/* right */
+#define CV_MOVE_RIGHT_WRAP( pos, cs ) \
+ ((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )
+
+/* up */
+#define CV_MOVE_UP_WRAP( pos, cs ) \
+    ((((pos).currline -= (pos).step) != (pos).topline ? \
+    (pos).currline : ((pos).currline = (pos).bottomline - (pos).step)) + (pos).x*(cs) )
+
+/* down */
+#define CV_MOVE_DOWN_WRAP( pos, cs ) \
+    ((((pos).currline += (pos).step) != (pos).bottomline ? \
+    (pos).currline : ((pos).currline = (pos).topline + (pos).step)) + (pos).x*(cs) )
+
+/* left up */
+#define CV_MOVE_LU_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
+/* right up */
+#define CV_MOVE_RU_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
+/* left down */
+#define CV_MOVE_LD_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
+/* right down */
+#define CV_MOVE_RD_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
+
+/* Numeric constants which used for moving in arbitrary direction  */
+enum
+{
+    CV_SHIFT_NONE = 2,
+    CV_SHIFT_LEFT = 1,
+    CV_SHIFT_RIGHT = 3,
+    CV_SHIFT_UP = 6,
+    CV_SHIFT_DOWN = 10,
+    CV_SHIFT_LU = 5,
+    CV_SHIFT_RU = 7,
+    CV_SHIFT_LD = 9,
+    CV_SHIFT_RD = 11
+};
+
+/* Move by one pixel in specified direction                                     */
+/*  pos    - position structure                                                 */
+/*  shift  - direction ( it's value must be one of the CV_SHIFT_Ö constants ) */
+/*  cs     - number of the image channels                                       */
+#define CV_MOVE_PARAM( pos, shift, cs )                                             \
+    ( (pos).currline += (pos).step_arr[(shift)>>2], (pos).x += ((shift)&3)-2,       \
+    ((pos).currline != (pos).topline && (pos).currline != (pos).bottomline &&       \
+    (pos).x >= 0 && (pos).x < (pos).width) ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* Move by one pixel in specified direction with wrapping when the               */
+/* position achieves image boundary                                              */
+/*  pos    - position structure                                                  */
+/*  shift  - direction ( it's value must be one of the CV_SHIFT_Ö constants )  */
+/*  cs     - number of the image channels                                        */
+#define CV_MOVE_PARAM_WRAP( pos, shift, cs )                                        \
+    ( (pos).currline += (pos).step_arr[(shift)>>2],                                 \
+    (pos).currline = ((pos).currline == (pos).topline ?                             \
+    (pos).bottomline - (pos).step :                                                 \
+    (pos).currline == (pos).bottomline ?                                            \
+    (pos).topline + (pos).step : (pos).currline),                                   \
+                                                                                    \
+    (pos).x += ((shift)&3)-2,                                                       \
+    (pos).x = ((pos).x < 0 ? (pos).width-1 : (pos).x >= (pos).width ? 0 : (pos).x), \
+                                                                                    \
+    (pos).currline + (pos).x*(cs) )
+
+
+typedef float*   CvVect32f;
+typedef float*   CvMatr32f;
+typedef double*  CvVect64d;
+typedef double*  CvMatr64d;
+
+CV_EXPORTS void cvUnDistortOnce( const CvArr* src, CvArr* dst,
+                                const float* intrinsic_matrix,
+                                const float* distortion_coeffs,
+                                int interpolate );
+
+/* the two functions below have quite hackerish implementations, use with care
+   (or, which is better, switch to cvUndistortInitMap and cvRemap instead */
+CV_EXPORTS void cvUnDistortInit( const CvArr* src,
+                                CvArr* undistortion_map,
+                                const float* A, const float* k,
+                                int interpolate );
+
+CV_EXPORTS void  cvUnDistort( const CvArr* src, CvArr* dst,
+                             const CvArr* undistortion_map,
+                             int interpolate );
+
+/* Find fundamental matrix */
+CV_EXPORTS void  cvFindFundamentalMatrix( int* points1, int* points2,
+    int numpoints, int method, float* matrix );
+
+
+CV_EXPORTS int cvFindChessBoardCornerGuesses( const void* arr, void* thresharr,
+                               CvMemStorage* storage,
+                               CvSize pattern_size, CvPoint2D32f * corners,
+                               int *corner_count );
+
+/* Calibrates camera using multiple views of calibration pattern */
+CV_EXPORTS void cvCalibrateCamera( int image_count, int* _point_counts,
+    CvSize image_size, CvPoint2D32f* _image_points, CvPoint3D32f* _object_points,
+    float* _distortion_coeffs, float* _camera_matrix, float* _translation_vectors,
+    float* _rotation_matrices, int flags );
+
+
+CV_EXPORTS void cvCalibrateCamera_64d( int image_count, int* _point_counts,
+    CvSize image_size, CvPoint2D64f* _image_points, CvPoint3D64f* _object_points,
+    double* _distortion_coeffs, double* _camera_matrix, double* _translation_vectors,
+    double* _rotation_matrices, int flags );
+
+
+/* Find 3d position of object given intrinsic camera parameters,
+   3d model of the object and projection of the object into view plane */
+CV_EXPORTS void cvFindExtrinsicCameraParams( int point_count,
+    CvSize image_size, CvPoint2D32f* _image_points,
+    CvPoint3D32f* _object_points, float* focal_length,
+    CvPoint2D32f principal_point, float* _distortion_coeffs,
+    float* _rotation_vector, float* _translation_vector );
+
+/* Variant of the previous function that takes double-precision parameters */
+CV_EXPORTS void cvFindExtrinsicCameraParams_64d( int point_count,
+    CvSize image_size, CvPoint2D64f* _image_points,
+    CvPoint3D64f* _object_points, double* focal_length,
+    CvPoint2D64f principal_point, double* _distortion_coeffs,
+    double* _rotation_vector, double* _translation_vector );
+
+/* Rodrigues transform */
+enum
+{
+    CV_RODRIGUES_M2V = 0,
+    CV_RODRIGUES_V2M = 1
+};
+
+/* Converts rotation_matrix matrix to rotation_matrix vector or vice versa */
+CV_EXPORTS void  cvRodrigues( CvMat* rotation_matrix, CvMat* rotation_vector,
+                              CvMat* jacobian, int conv_type );
+
+/* Does reprojection of 3d object points to the view plane */
+CV_EXPORTS void  cvProjectPoints( int point_count, CvPoint3D64f* _object_points,
+    double* _rotation_vector, double*  _translation_vector,
+    double* focal_length, CvPoint2D64f principal_point,
+    double* _distortion, CvPoint2D64f* _image_points,
+    double* _deriv_points_rotation_matrix,
+    double* _deriv_points_translation_vect,
+    double* _deriv_points_focal,
+    double* _deriv_points_principal_point,
+    double* _deriv_points_distortion_coeffs );
+
+
+/* Simpler version of the previous function */
+CV_EXPORTS void  cvProjectPointsSimple( int point_count, CvPoint3D64f* _object_points,
+    double* _rotation_matrix, double*  _translation_vector,
+    double* _camera_matrix, double* _distortion, CvPoint2D64f* _image_points );
+
+
+#define cvMake2DPoints cvConvertPointsHomogeneous
+#define cvMake3DPoints cvConvertPointsHomogeneous
+
+#define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform
+
+#define cvConvertPointsHomogenious cvConvertPointsHomogeneous
+
+
+//////////////////////////////////// feature extractors: obsolete API //////////////////////////////////
+
+typedef struct CvSURFPoint
+{
+    CvPoint2D32f pt;
+
+    int          laplacian;
+    int          size;
+    float        dir;
+    float        hessian;
+
+} CvSURFPoint;
+
+CV_INLINE CvSURFPoint cvSURFPoint( CvPoint2D32f pt, int laplacian,
+                                  int size, float dir CV_DEFAULT(0),
+                                  float hessian CV_DEFAULT(0))
+{
+    CvSURFPoint kp;
+
+    kp.pt        = pt;
+    kp.laplacian = laplacian;
+    kp.size      = size;
+    kp.dir       = dir;
+    kp.hessian   = hessian;
+
+    return kp;
+}
+
+typedef struct CvSURFParams
+{
+    int    extended;
+    int    upright;
+    double hessianThreshold;
+
+    int    nOctaves;
+    int    nOctaveLayers;
+
+} CvSURFParams;
+
+CVAPI(CvSURFParams) cvSURFParams( double hessianThreshold, int extended CV_DEFAULT(0) );
+
+// If useProvidedKeyPts!=0, keypoints are not detected, but descriptors are computed
+//  at the locations provided in keypoints (a CvSeq of CvSURFPoint).
+CVAPI(void) cvExtractSURF( const CvArr* img, const CvArr* mask,
+                          CvSeq** keypoints, CvSeq** descriptors,
+                          CvMemStorage* storage, CvSURFParams params,
+                             int useProvidedKeyPts CV_DEFAULT(0)  );
+
+/*!
+ Maximal Stable Regions Parameters
+ */
+typedef struct CvMSERParams
+{
+    //! delta, in the code, it compares (size_{i}-size_{i-delta})/size_{i-delta}
+    int delta;
+    //! prune the area which bigger than maxArea
+    int maxArea;
+    //! prune the area which smaller than minArea
+    int minArea;
+    //! prune the area have simliar size to its children
+    float maxVariation;
+    //! trace back to cut off mser with diversity < min_diversity
+    float minDiversity;
+
+    /////// the next few params for MSER of color image
+
+    //! for color image, the evolution steps
+    int maxEvolution;
+    //! the area threshold to cause re-initialize
+    double areaThreshold;
+    //! ignore too small margin
+    double minMargin;
+    //! the aperture size for edge blur
+    int edgeBlurSize;
+} CvMSERParams;
+
+CVAPI(CvMSERParams) cvMSERParams( int delta CV_DEFAULT(5), int min_area CV_DEFAULT(60),
+                                 int max_area CV_DEFAULT(14400), float max_variation CV_DEFAULT(.25f),
+                                 float min_diversity CV_DEFAULT(.2f), int max_evolution CV_DEFAULT(200),
+                                 double area_threshold CV_DEFAULT(1.01),
+                                 double min_margin CV_DEFAULT(.003),
+                                 int edge_blur_size CV_DEFAULT(5) );
+
+// Extracts the contours of Maximally Stable Extremal Regions
+CVAPI(void) cvExtractMSER( CvArr* _img, CvArr* _mask, CvSeq** contours, CvMemStorage* storage, CvMSERParams params );
+
+
+typedef struct CvStarKeypoint
+{
+    CvPoint pt;
+    int size;
+    float response;
+} CvStarKeypoint;
+
+CV_INLINE CvStarKeypoint cvStarKeypoint(CvPoint pt, int size, float response)
+{
+    CvStarKeypoint kpt;
+    kpt.pt = pt;
+    kpt.size = size;
+    kpt.response = response;
+    return kpt;
+}
+
+typedef struct CvStarDetectorParams
+{
+    int maxSize;
+    int responseThreshold;
+    int lineThresholdProjected;
+    int lineThresholdBinarized;
+    int suppressNonmaxSize;
+} CvStarDetectorParams;
+
+CV_INLINE CvStarDetectorParams cvStarDetectorParams(
+                                                    int maxSize CV_DEFAULT(45),
+                                                    int responseThreshold CV_DEFAULT(30),
+                                                    int lineThresholdProjected CV_DEFAULT(10),
+                                                    int lineThresholdBinarized CV_DEFAULT(8),
+                                                    int suppressNonmaxSize CV_DEFAULT(5))
+{
+    CvStarDetectorParams params;
+    params.maxSize = maxSize;
+    params.responseThreshold = responseThreshold;
+    params.lineThresholdProjected = lineThresholdProjected;
+    params.lineThresholdBinarized = lineThresholdBinarized;
+    params.suppressNonmaxSize = suppressNonmaxSize;
+
+    return params;
+}
+
+CVAPI(CvSeq*) cvGetStarKeypoints( const CvArr* img, CvMemStorage* storage,
+                                 CvStarDetectorParams params CV_DEFAULT(cvStarDetectorParams()));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/thirdparty/includes/OpenCV/opencv2/legacy/legacy.hpp b/thirdparty/includes/OpenCV/opencv2/legacy/legacy.hpp
new file mode 100644
index 0000000..96da25c
--- /dev/null
+++ b/thirdparty/includes/OpenCV/opencv2/legacy/legacy.hpp
@@ -0,0 +1,3436 @@
+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_LEGACY_HPP__
+#define __OPENCV_LEGACY_HPP__
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
+#include "opencv2/ml/ml.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CVAPI(CvSeq*) cvSegmentImage( const CvArr* srcarr, CvArr* dstarr,
+                                    double canny_threshold,
+                                    double ffill_threshold,
+                                    CvMemStorage* storage );
+
+/****************************************************************************************\
+*                                  Eigen objects                                         *
+\****************************************************************************************/
+
+typedef int (CV_CDECL * CvCallback)(int index, void* buffer, void* user_data);
+typedef union
+{
+    CvCallback callback;
+    void* data;
+}
+CvInput;
+
+#define CV_EIGOBJ_NO_CALLBACK     0
+#define CV_EIGOBJ_INPUT_CALLBACK  1
+#define CV_EIGOBJ_OUTPUT_CALLBACK 2
+#define CV_EIGOBJ_BOTH_CALLBACK   3
+
+/* Calculates covariation matrix of a set of arrays */
+CVAPI(void)  cvCalcCovarMatrixEx( int nObjects, void* input, int ioFlags,
+                                  int ioBufSize, uchar* buffer, void* userData,
+                                  IplImage* avg, float* covarMatrix );
+
+/* Calculates eigen values and vectors of covariation matrix of a set of
+   arrays */
+CVAPI(void)  cvCalcEigenObjects( int nObjects, void* input, void* output,
+                                 int ioFlags, int ioBufSize, void* userData,
+                                 CvTermCriteria* calcLimit, IplImage* avg,
+                                 float* eigVals );
+
+/* Calculates dot product (obj - avg) * eigObj (i.e. projects image to eigen vector) */
+CVAPI(double)  cvCalcDecompCoeff( IplImage* obj, IplImage* eigObj, IplImage* avg );
+
+/* Projects image to eigen space (finds all decomposion coefficients */
+CVAPI(void)  cvEigenDecomposite( IplImage* obj, int nEigObjs, void* eigInput,
+                                 int ioFlags, void* userData, IplImage* avg,
+                                 float* coeffs );
+
+/* Projects original objects used to calculate eigen space basis to that space */
+CVAPI(void)  cvEigenProjection( void* eigInput, int nEigObjs, int ioFlags,
+                                void* userData, float* coeffs, IplImage* avg,
+                                IplImage* proj );
+
+/****************************************************************************************\
+*                                       1D/2D HMM                                        *
+\****************************************************************************************/
+
+typedef struct CvImgObsInfo
+{
+    int obs_x;
+    int obs_y;
+    int obs_size;
+    float* obs;//consequtive observations
+
+    int* state;/* arr of pairs superstate/state to which observation belong */
+    int* mix;  /* number of mixture to which observation belong */
+
+} CvImgObsInfo;/*struct for 1 image*/
+
+typedef CvImgObsInfo Cv1DObsInfo;
+
+typedef struct CvEHMMState
+{
+    int num_mix;        /*number of mixtures in this state*/
+    float* mu;          /*mean vectors corresponding to each mixture*/
+    float* inv_var;     /* square root of inversed variances corresp. to each mixture*/
+    float* log_var_val; /* sum of 0.5 (LN2PI + ln(variance[i]) ) for i=1,n */
+    float* weight;      /*array of mixture weights. Summ of all weights in state is 1. */
+
+} CvEHMMState;
+
+typedef struct CvEHMM
+{
+    int level; /* 0 - lowest(i.e its states are real states), ..... */
+    int num_states; /* number of HMM states */
+    float*  transP;/*transition probab. matrices for states */
+    float** obsProb; /* if level == 0 - array of brob matrices corresponding to hmm
+                        if level == 1 - martix of matrices */
+    union
+    {
+        CvEHMMState* state; /* if level == 0 points to real states array,
+                               if not - points to embedded hmms */
+        struct CvEHMM* ehmm; /* pointer to an embedded model or NULL, if it is a leaf */
+    } u;
+
+} CvEHMM;
+
+/*CVAPI(int)  icvCreate1DHMM( CvEHMM** this_hmm,
+                                   int state_number, int* num_mix, int obs_size );
+
+CVAPI(int)  icvRelease1DHMM( CvEHMM** phmm );
+
+CVAPI(int)  icvUniform1DSegm( Cv1DObsInfo* obs_info, CvEHMM* hmm );
+
+CVAPI(int)  icvInit1DMixSegm( Cv1DObsInfo** obs_info_array, int num_img, CvEHMM* hmm);
+
+CVAPI(int)  icvEstimate1DHMMStateParams( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm);
+
+CVAPI(int)  icvEstimate1DObsProb( CvImgObsInfo* obs_info, CvEHMM* hmm );
+
+CVAPI(int)  icvEstimate1DTransProb( Cv1DObsInfo** obs_info_array,
+                                           int num_seq,
+                                           CvEHMM* hmm );
+
+CVAPI(float)  icvViterbi( Cv1DObsInfo* obs_info, CvEHMM* hmm);
+
+CVAPI(int)  icv1DMixSegmL2( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm );*/
+
+/*********************************** Embedded HMMs *************************************/
+
+/* Creates 2D HMM */
+CVAPI(CvEHMM*)  cvCreate2DHMM( int* stateNumber, int* numMix, int obsSize );
+
+/* Releases HMM */
+CVAPI(void)  cvRelease2DHMM( CvEHMM** hmm );
+
+#define CV_COUNT_OBS(roi, win, delta, numObs )                                       \
+{                                                                                    \
+   (numObs)->width  =((roi)->width  -(win)->width  +(delta)->width)/(delta)->width;  \
+   (numObs)->height =((roi)->height -(win)->height +(delta)->height)/(delta)->height;\
+}
+
+/* Creates storage for observation vectors */
+CVAPI(CvImgObsInfo*)  cvCreateObsInfo( CvSize numObs, int obsSize );
+
+/* Releases storage for observation vectors */
+CVAPI(void)  cvReleaseObsInfo( CvImgObsInfo** obs_info );
+
+
+/* The function takes an image on input and and returns the sequnce of observations
+   to be used with an embedded HMM; Each observation is top-left block of DCT
+   coefficient matrix */
+CVAPI(void)  cvImgToObs_DCT( const CvArr* arr, float* obs, CvSize dctSize,
+                             CvSize obsSize, CvSize delta );
+
+
+/* Uniformly segments all observation vectors extracted from image */
+CVAPI(void)  cvUniformImgSegm( CvImgObsInfo* obs_info, CvEHMM* ehmm );
+
+/* Does mixture segmentation of the states of embedded HMM */
+CVAPI(void)  cvInitMixSegm( CvImgObsInfo** obs_info_array,
+                            int num_img, CvEHMM* hmm );
+
+/* Function calculates means, variances, weights of every Gaussian mixture
+   of every low-level state of embedded HMM */
+CVAPI(void)  cvEstimateHMMStateParams( CvImgObsInfo** obs_info_array,
+                                       int num_img, CvEHMM* hmm );
+
+/* Function computes transition probability matrices of embedded HMM
+   given observations segmentation */
+CVAPI(void)  cvEstimateTransProb( CvImgObsInfo** obs_info_array,
+                                  int num_img, CvEHMM* hmm );
+
+/* Function computes probabilities of appearing observations at any state
+   (i.e. computes P(obs|state) for every pair(obs,state)) */
+CVAPI(void)  cvEstimateObsProb( CvImgObsInfo* obs_info,
+                                CvEHMM* hmm );
+
+/* Runs Viterbi algorithm for embedded HMM */
+CVAPI(float)  cvEViterbi( CvImgObsInfo* obs_info, CvEHMM* hmm );
+
+
+/* Function clusters observation vectors from several images
+   given observations segmentation.
+   Euclidean distance used for clustering vectors.
+   Centers of clusters are given means of every mixture */
+CVAPI(void)  cvMixSegmL2( CvImgObsInfo** obs_info_array,
+                          int num_img, CvEHMM* hmm );
+
+/****************************************************************************************\
+*               A few functions from old stereo gesture recognition demosions            *
+\****************************************************************************************/
+
+/* Creates hand mask image given several points on the hand */
+CVAPI(void)  cvCreateHandMask( CvSeq* hand_points,
+                                   IplImage *img_mask, CvRect *roi);
+
+/* Finds hand region in range image data */
+CVAPI(void)  cvFindHandRegion (CvPoint3D32f* points, int count,
+                                CvSeq* indexs,
+                                float* line, CvSize2D32f size, int flag,
+                                CvPoint3D32f* center,
+                                CvMemStorage* storage, CvSeq **numbers);
+
+/* Finds hand region in range image data (advanced version) */
+CVAPI(void)  cvFindHandRegionA( CvPoint3D32f* points, int count,
+                                CvSeq* indexs,
+                                float* line, CvSize2D32f size, int jc,
+                                CvPoint3D32f* center,
+                                CvMemStorage* storage, CvSeq **numbers);
+
+/* Calculates the cooficients of the homography matrix */
+CVAPI(void)  cvCalcImageHomography( float* line, CvPoint3D32f* center,
+                                    float* intrinsic, float* homography );
+
+/****************************************************************************************\
+*                           More operations on sequences                                 *
+\****************************************************************************************/
+
+/*****************************************************************************************/
+
+#define CV_CURRENT_INT( reader ) (*((int *)(reader).ptr))
+#define CV_PREV_INT( reader ) (*((int *)(reader).prev_elem))
+
+#define  CV_GRAPH_WEIGHTED_VERTEX_FIELDS() CV_GRAPH_VERTEX_FIELDS()\
+    float weight;
+
+#define  CV_GRAPH_WEIGHTED_EDGE_FIELDS() CV_GRAPH_EDGE_FIELDS()
+
+typedef struct CvGraphWeightedVtx
+{
+    CV_GRAPH_WEIGHTED_VERTEX_FIELDS()
+} CvGraphWeightedVtx;
+
+typedef struct CvGraphWeightedEdge
+{
+    CV_GRAPH_WEIGHTED_EDGE_FIELDS()
+} CvGraphWeightedEdge;
+
+typedef enum CvGraphWeightType
+{
+    CV_NOT_WEIGHTED,
+    CV_WEIGHTED_VTX,
+    CV_WEIGHTED_EDGE,
+    CV_WEIGHTED_ALL
+} CvGraphWeightType;
+
+
+/* Calculates histogram of a contour */
+CVAPI(void)  cvCalcPGH( const CvSeq* contour, CvHistogram* hist );
+
+#define CV_DOMINANT_IPAN 1
+
+/* Finds high-curvature points of the contour */
+CVAPI(CvSeq*) cvFindDominantPoints( CvSeq* contour, CvMemStorage* storage,
+                                   int method CV_DEFAULT(CV_DOMINANT_IPAN),
+                                   double parameter1 CV_DEFAULT(0),
+                                   double parameter2 CV_DEFAULT(0),
+                                   double parameter3 CV_DEFAULT(0),
+                                   double parameter4 CV_DEFAULT(0));
+
+/*****************************************************************************************/
+
+
+/*******************************Stereo correspondence*************************************/
+
+typedef struct CvCliqueFinder
+{
+    CvGraph* graph;
+    int**    adj_matr;
+    int N; //graph size
+
+    // stacks, counters etc/
+    int k; //stack size
+    int* current_comp;
+    int** All;
+
+    int* ne;
+    int* ce;
+    int* fixp; //node with minimal disconnections
+    int* nod;
+    int* s; //for selected candidate
+    int status;
+    int best_score;
+    int weighted;
+    int weighted_edges;
+    float best_weight;
+    float* edge_weights;
+    float* vertex_weights;
+    float* cur_weight;
+    float* cand_weight;
+
+} CvCliqueFinder;
+
+#define CLIQUE_TIME_OFF 2
+#define CLIQUE_FOUND 1
+#define CLIQUE_END   0
+
+/*CVAPI(void) cvStartFindCliques( CvGraph* graph, CvCliqueFinder* finder, int reverse,
+                                   int weighted CV_DEFAULT(0),  int weighted_edges CV_DEFAULT(0));
+CVAPI(int) cvFindNextMaximalClique( CvCliqueFinder* finder, int* clock_rest CV_DEFAULT(0) );
+CVAPI(void) cvEndFindCliques( CvCliqueFinder* finder );
+
+CVAPI(void) cvBronKerbosch( CvGraph* graph );*/
+
+
+/*F///////////////////////////////////////////////////////////////////////////////////////
+//
+//    Name:    cvSubgraphWeight
+//    Purpose: finds weight of subgraph in a graph
+//    Context:
+//    Parameters:
+//      graph - input graph.
+//      subgraph - sequence of pairwise different ints.  These are indices of vertices of subgraph.
+//      weight_type - describes the way we measure weight.
+//            one of the following:
+//            CV_NOT_WEIGHTED - weight of a clique is simply its size
+//            CV_WEIGHTED_VTX - weight of a clique is the sum of weights of its vertices
+//            CV_WEIGHTED_EDGE - the same but edges
+//            CV_WEIGHTED_ALL - the same but both edges and vertices
+//      weight_vtx - optional vector of floats, with size = graph->total.
+//            If weight_type is either CV_WEIGHTED_VTX or CV_WEIGHTED_ALL
+//            weights of vertices must be provided.  If weight_vtx not zero
+//            these weights considered to be here, otherwise function assumes
+//            that vertices of graph are inherited from CvGraphWeightedVtx.
+//      weight_edge - optional matrix of floats, of width and height = graph->total.
+//            If weight_type is either CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL
+//            weights of edges ought to be supplied.  If weight_edge is not zero
+//            function finds them here, otherwise function expects
+//            edges of graph to be inherited from CvGraphWeightedEdge.
+//            If this parameter is not zero structure of the graph is determined from matrix
+//            rather than from CvGraphEdge's.  In particular, elements corresponding to
+//            absent edges should be zero.
+//    Returns:
+//      weight of subgraph.
+//    Notes:
+//F*/
+/*CVAPI(float) cvSubgraphWeight( CvGraph *graph, CvSeq *subgraph,
+                                  CvGraphWeightType weight_type CV_DEFAULT(CV_NOT_WEIGHTED),
+                                  CvVect32f weight_vtx CV_DEFAULT(0),
+                                  CvMatr32f weight_edge CV_DEFAULT(0) );*/
+
+
+/*F///////////////////////////////////////////////////////////////////////////////////////
+//
+//    Name:    cvFindCliqueEx
+//    Purpose: tries to find clique with maximum possible weight in a graph
+//    Context:
+//    Parameters:
+//      graph - input graph.
+//      storage - memory storage to be used by the result.
+//      is_complementary - optional flag showing whether function should seek for clique
+//            in complementary graph.
+//      weight_type - describes our notion about weight.
+//            one of the following:
+//            CV_NOT_WEIGHTED - weight of a clique is simply its size
+//            CV_WEIGHTED_VTX - weight of a clique is the sum of weights of its vertices
+//            CV_WEIGHTED_EDGE - the same but edges
+//            CV_WEIGHTED_ALL - the same but both edges and vertices
+//      weight_vtx - optional vector of floats, with size = graph->total.
+//            If weight_type is either CV_WEIGHTED_VTX or CV_WEIGHTED_ALL
+//            weights of vertices must be provided.  If weight_vtx not zero
+//            these weights considered to be here, otherwise function assumes
+//            that vertices of graph are inherited from CvGraphWeightedVtx.
+//      weight_edge - optional matrix of floats, of width and height = graph->total.
+//            If weight_type is either CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL
+//            weights of edges ought to be supplied.  If weight_edge is not zero
+//            function finds them here, otherwise function expects
+//            edges of graph to be inherited from CvGraphWeightedEdge.
+//            Note that in case of CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL
+//            nonzero is_complementary implies nonzero weight_edge.
+//      start_clique - optional sequence of pairwise different ints.  They are indices of
+//            vertices that shall be present in the output clique.
+//      subgraph_of_ban - optional sequence of (maybe equal) ints.  They are indices of
+//            vertices that shall not be present in the output clique.
+//      clique_weight_ptr - optional output parameter.  Weight of found clique stored here.
+//      num_generations - optional number of generations in evolutionary part of algorithm,
+//            zero forces to return first found clique.
+//      quality - optional parameter determining degree of required quality/speed tradeoff.
+//            Must be in the range from 0 to 9.
+//            0 is fast and dirty, 9 is slow but hopefully yields good clique.
+//    Returns:
+//      sequence of pairwise different ints.
+//      These are indices of vertices that form found clique.
+//    Notes:
+//      in cases of CV_WEIGHTED_EDGE and CV_WEIGHTED_ALL weights should be nonnegative.
+//      start_clique has a priority over subgraph_of_ban.
+//F*/
+/*CVAPI(CvSeq*) cvFindCliqueEx( CvGraph *graph, CvMemStorage *storage,
+                                 int is_complementary CV_DEFAULT(0),
+                                 CvGraphWeightType weight_type CV_DEFAULT(CV_NOT_WEIGHTED),
+                                 CvVect32f weight_vtx CV_DEFAULT(0),
+                                 CvMatr32f weight_edge CV_DEFAULT(0),
+                                 CvSeq *start_clique CV_DEFAULT(0),
+                                 CvSeq *subgraph_of_ban CV_DEFAULT(0),
+                                 float *clique_weight_ptr CV_DEFAULT(0),
+                                 int num_generations CV_DEFAULT(3),
+                                 int quality CV_DEFAULT(2) );*/
+
+
+#define CV_UNDEF_SC_PARAM         12345 //default value of parameters
+
+#define CV_IDP_BIRCHFIELD_PARAM1  25
+#define CV_IDP_BIRCHFIELD_PARAM2  5
+#define CV_IDP_BIRCHFIELD_PARAM3  12
+#define CV_IDP_BIRCHFIELD_PARAM4  15
+#define CV_IDP_BIRCHFIELD_PARAM5  25
+
+
+#define  CV_DISPARITY_BIRCHFIELD  0
+
+
+/*F///////////////////////////////////////////////////////////////////////////
+//
+//    Name:    cvFindStereoCorrespondence
+//    Purpose: find stereo correspondence on stereo-pair
+//    Context:
+//    Parameters:
+//      leftImage - left image of stereo-pair (format 8uC1).
+//      rightImage - right image of stereo-pair (format 8uC1).
+//   mode - mode of correspondence retrieval (now CV_DISPARITY_BIRCHFIELD only)
+//      dispImage - destination disparity image
+//      maxDisparity - maximal disparity
+//      param1, param2, param3, param4, param5 - parameters of algorithm
+//    Returns:
+//    Notes:
+//      Images must be rectified.
+//      All images must have format 8uC1.
+//F*/
+CVAPI(void)
+cvFindStereoCorrespondence(
+                   const  CvArr* leftImage, const  CvArr* rightImage,
+                   int     mode,
+                   CvArr*  dispImage,
+                   int     maxDisparity,
+                   double  param1 CV_DEFAULT(CV_UNDEF_SC_PARAM),
+                   double  param2 CV_DEFAULT(CV_UNDEF_SC_PARAM),
+                   double  param3 CV_DEFAULT(CV_UNDEF_SC_PARAM),
+                   double  param4 CV_DEFAULT(CV_UNDEF_SC_PARAM),
+                   double  param5 CV_DEFAULT(CV_UNDEF_SC_PARAM) );
+
+/*****************************************************************************************/
+/************ Epiline functions *******************/
+
+
+
+typedef struct CvStereoLineCoeff
+{
+    double Xcoef;
+    double XcoefA;
+    double XcoefB;
+    double XcoefAB;
+
+    double Ycoef;
+    double YcoefA;
+    double YcoefB;
+    double YcoefAB;
+
+    double Zcoef;
+    double ZcoefA;
+    double ZcoefB;
+    double ZcoefAB;
+}CvStereoLineCoeff;
+
+
+typedef struct CvCamera
+{
+    float   imgSize[2]; /* size of the camera view, used during calibration */
+    float   matrix[9]; /* intinsic camera parameters:  [ fx 0 cx; 0 fy cy; 0 0 1 ] */
+    float   distortion[4]; /* distortion coefficients - two coefficients for radial distortion
+                              and another two for tangential: [ k1 k2 p1 p2 ] */
+    float   rotMatr[9];
+    float   transVect[3]; /* rotation matrix and transition vector relatively
+                             to some reference point in the space. */
+} CvCamera;
+
+typedef struct CvStereoCamera
+{
+    CvCamera* camera[2]; /* two individual camera parameters */
+    float fundMatr[9]; /* fundamental matrix */
+
+    /* New part for stereo */
+    CvPoint3D32f epipole[2];
+    CvPoint2D32f quad[2][4]; /* coordinates of destination quadrangle after
+                                epipolar geometry rectification */
+    double coeffs[2][3][3];/* coefficients for transformation */
+    CvPoint2D32f border[2][4];
+    CvSize warpSize;
+    CvStereoLineCoeff* lineCoeffs;
+    int needSwapCameras;/* flag set to 1 if need to swap cameras for good reconstruction */
+    float rotMatrix[9];
+    float transVector[3];
+} CvStereoCamera;
+
+
+typedef struct CvContourOrientation
+{
+    float egvals[2];
+    float egvects[4];
+
+    float max, min; // minimum and maximum projections
+    int imax, imin;
+} CvContourOrientation;
+
+#define CV_CAMERA_TO_WARP 1
+#define CV_WARP_TO_CAMERA 2
+
+CVAPI(int) icvConvertWarpCoordinates(double coeffs[3][3],
+                                CvPoint2D32f* cameraPoint,
+                                CvPoint2D32f* warpPoint,
+                                int direction);
+
+CVAPI(int) icvGetSymPoint3D(  CvPoint3D64f pointCorner,
+                            CvPoint3D64f point1,
+                            CvPoint3D64f point2,
+                            CvPoint3D64f *pointSym2);
+
+CVAPI(void) icvGetPieceLength3D(CvPoint3D64f point1,CvPoint3D64f point2,double* dist);
+
+CVAPI(int) icvCompute3DPoint(    double alpha,double betta,
+                            CvStereoLineCoeff* coeffs,
+                            CvPoint3D64f* point);
+
+CVAPI(int) icvCreateConvertMatrVect( double*     rotMatr1,
+                                double*     transVect1,
+                                double*     rotMatr2,
+                                double*     transVect2,
+                                double*     convRotMatr,
+                                double*     convTransVect);
+
+CVAPI(int) icvConvertPointSystem(CvPoint3D64f  M2,
+                            CvPoint3D64f* M1,
+                            double*     rotMatr,
+                            double*     transVect
+                            );
+
+CVAPI(int) icvComputeCoeffForStereo(  CvStereoCamera* stereoCamera);
+
+CVAPI(int) icvGetCrossPieceVector(CvPoint2D32f p1_start,CvPoint2D32f p1_end,CvPoint2D32f v2_start,CvPoint2D32f v2_end,CvPoint2D32f *cross);
+CVAPI(int) icvGetCrossLineDirect(CvPoint2D32f p1,CvPoint2D32f p2,float a,float b,float c,CvPoint2D32f* cross);
+CVAPI(float) icvDefinePointPosition(CvPoint2D32f point1,CvPoint2D32f point2,CvPoint2D32f point);
+CVAPI(int) icvStereoCalibration( int numImages,
+                            int* nums,
+                            CvSize imageSize,
+                            CvPoint2D32f* imagePoints1,
+                            CvPoint2D32f* imagePoints2,
+                            CvPoint3D32f* objectPoints,
+                            CvStereoCamera* stereoparams
+                           );
+
+
+CVAPI(int) icvComputeRestStereoParams(CvStereoCamera *stereoparams);
+
+CVAPI(void) cvComputePerspectiveMap( const double coeffs[3][3], CvArr* rectMapX, CvArr* rectMapY );
+
+CVAPI(int) icvComCoeffForLine(   CvPoint2D64f point1,
+                            CvPoint2D64f point2,
+                            CvPoint2D64f point3,
+                            CvPoint2D64f point4,
+                            double*    camMatr1,
+                            double*    rotMatr1,
+                            double*    transVect1,
+                            double*    camMatr2,
+                            double*    rotMatr2,
+                            double*    transVect2,
+                            CvStereoLineCoeff*    coeffs,
+                            int* needSwapCameras);
+
+CVAPI(int) icvGetDirectionForPoint(  CvPoint2D64f point,
+                                double* camMatr,
+                                CvPoint3D64f* direct);
+
+CVAPI(int) icvGetCrossLines(CvPoint3D64f point11,CvPoint3D64f point12,
+                       CvPoint3D64f point21,CvPoint3D64f point22,
+                       CvPoint3D64f* midPoint);
+
+CVAPI(int) icvComputeStereoLineCoeffs(   CvPoint3D64f pointA,
+                                    CvPoint3D64f pointB,
+                                    CvPoint3D64f pointCam1,
+                                    double gamma,
+                                    CvStereoLineCoeff*    coeffs);
+
+/*CVAPI(int) icvComputeFundMatrEpipoles ( double* camMatr1,
+                                    double*     rotMatr1,
+                                    double*     transVect1,
+                                    double*     camMatr2,
+                                    double*     rotMatr2,
+                                    double*     transVect2,
+                                    CvPoint2D64f* epipole1,
+                                    CvPoint2D64f* epipole2,
+                                    double*     fundMatr);*/
+
+CVAPI(int) icvGetAngleLine( CvPoint2D64f startPoint, CvSize imageSize,CvPoint2D64f *point1,CvPoint2D64f *point2);
+
+CVAPI(void) icvGetCoefForPiece(   CvPoint2D64f p_start,CvPoint2D64f p_end,
+                        double *a,double *b,double *c,
+                        int* result);
+
+/*CVAPI(void) icvGetCommonArea( CvSize imageSize,
+                    CvPoint2D64f epipole1,CvPoint2D64f epipole2,
+                    double* fundMatr,
+                    double* coeff11,double* coeff12,
+                    double* coeff21,double* coeff22,
+                    int* result);*/
+
+CVAPI(void) icvComputeeInfiniteProject1(double*    rotMatr,
+                                     double*    camMatr1,
+                                     double*    camMatr2,
+                                     CvPoint2D32f point1,
+                                     CvPoint2D32f *point2);
+
+CVAPI(void) icvComputeeInfiniteProject2(double*    rotMatr,
+                                     double*    camMatr1,
+                                     double*    camMatr2,
+                                     CvPoint2D32f* point1,
+                                     CvPoint2D32f point2);
+
+CVAPI(void) icvGetCrossDirectDirect(  double* direct1,double* direct2,
+                            CvPoint2D64f *cross,int* result);
+
+CVAPI(void) icvGetCrossPieceDirect(   CvPoint2D64f p_start,CvPoint2D64f p_end,
+                            double a,double b,double c,
+                            CvPoint2D64f *cross,int* result);
+
+CVAPI(void) icvGetCrossPiecePiece( CvPoint2D64f p1_start,CvPoint2D64f p1_end,
+                            CvPoint2D64f p2_start,CvPoint2D64f p2_end,
+                            CvPoint2D64f* cross,
+                            int* result);
+
+CVAPI(void) icvGetPieceLength(CvPoint2D64f point1,CvPoint2D64f point2,double* dist);
+
+CVAPI(void) icvGetCrossRectDirect(    CvSize imageSize,
+                            double a,double b,double c,
+                            CvPoint2D64f *start,CvPoint2D64f *end,
+                            int* result);
+
+CVAPI(void) icvProjectPointToImage(   CvPoint3D64f point,
+                            double* camMatr,double* rotMatr,double* transVect,
+                            CvPoint2D64f* projPoint);
+
+CVAPI(void) icvGetQuadsTransform( CvSize        imageSize,
+                        double*     camMatr1,
+                        double*     rotMatr1,
+                        double*     transVect1,
+                        double*     camMatr2,
+                        double*     rotMatr2,
+                        double*     transVect2,
+                        CvSize*       warpSize,
+                        double quad1[4][2],
+                        double quad2[4][2],
+                        double*     fundMatr,
+                        CvPoint3D64f* epipole1,
+                        CvPoint3D64f* epipole2
+                        );
+
+CVAPI(void) icvGetQuadsTransformStruct(  CvStereoCamera* stereoCamera);
+
+CVAPI(void) icvComputeStereoParamsForCameras(CvStereoCamera* stereoCamera);
+
+CVAPI(void) icvGetCutPiece(   double* areaLineCoef1,double* areaLineCoef2,
+                    CvPoint2D64f epipole,
+                    CvSize imageSize,
+                    CvPoint2D64f* point11,CvPoint2D64f* point12,
+                    CvPoint2D64f* point21,CvPoint2D64f* point22,
+                    int* result);
+
+CVAPI(void) icvGetMiddleAnglePoint(   CvPoint2D64f basePoint,
+                            CvPoint2D64f point1,CvPoint2D64f point2,
+                            CvPoint2D64f* midPoint);
+
+CVAPI(void) icvGetNormalDirect(double* direct,CvPoint2D64f point,double* normDirect);
+
+CVAPI(double) icvGetVect(CvPoint2D64f basePoint,CvPoint2D64f point1,CvPoint2D64f point2);
+
+CVAPI(void) icvProjectPointToDirect(  CvPoint2D64f point,double* lineCoeff,
+                            CvPoint2D64f* projectPoint);
+
+CVAPI(void) icvGetDistanceFromPointToDirect( CvPoint2D64f point,double* lineCoef,double*dist);
+
+CVAPI(IplImage*) icvCreateIsometricImage( IplImage* src, IplImage* dst,
+                              int desired_depth, int desired_num_channels );
+
+CVAPI(void) cvDeInterlace( const CvArr* frame, CvArr* fieldEven, CvArr* fieldOdd );
+
+/*CVAPI(int) icvSelectBestRt(           int           numImages,
+                                    int*          numPoints,
+                                    CvSize        imageSize,
+                                    CvPoint2D32f* imagePoints1,
+                                    CvPoint2D32f* imagePoints2,
+                                    CvPoint3D32f* objectPoints,
+
+                                    CvMatr32f     cameraMatrix1,
+                                    CvVect32f     distortion1,
+                                    CvMatr32f     rotMatrs1,
+                                    CvVect32f     transVects1,
+
+                                    CvMatr32f     cameraMatrix2,
+                                    CvVect32f     distortion2,
+                                    CvMatr32f     rotMatrs2,
+                                    CvVect32f     transVects2,
+
+                                    CvMatr32f     bestRotMatr,
+                                    CvVect32f     bestTransVect
+                                    );*/
+
+
+/****************************************************************************************\
+*                                     Contour Tree                                       *
+\****************************************************************************************/
+
+/* Contour tree header */
+typedef struct CvContourTree
+{
+    CV_SEQUENCE_FIELDS()
+    CvPoint p1;            /* the first point of the binary tree root segment */
+    CvPoint p2;            /* the last point of the binary tree root segment */
+} CvContourTree;
+
+/* Builds hierarhical representation of a contour */
+CVAPI(CvContourTree*)  cvCreateContourTree( const CvSeq* contour,
+                                            CvMemStorage* storage,
+                                            double threshold );
+
+/* Reconstruct (completelly or partially) contour a from contour tree */
+CVAPI(CvSeq*)  cvContourFromContourTree( const CvContourTree* tree,
+                                         CvMemStorage* storage,
+                                         CvTermCriteria criteria );
+
+/* Compares two contour trees */
+enum { CV_CONTOUR_TREES_MATCH_I1 = 1 };
+
+CVAPI(double)  cvMatchContourTrees( const CvContourTree* tree1,
+                                    const CvContourTree* tree2,
+                                    int method, double threshold );
+
+/****************************************************************************************\
+*                                   Contour Morphing                                     *
+\****************************************************************************************/
+
+/* finds correspondence between two contours */
+CvSeq* cvCalcContoursCorrespondence( const CvSeq* contour1,
+                                     const CvSeq* contour2,
+                                     CvMemStorage* storage);
+
+/* morphs contours using the pre-calculated correspondence:
+   alpha=0 ~ contour1, alpha=1 ~ contour2 */
+CvSeq* cvMorphContours( const CvSeq* contour1, const CvSeq* contour2,
+                        CvSeq* corr, double alpha,
+                        CvMemStorage* storage );
+
+
+/****************************************************************************************\
+*                                   Active Contours                                      *
+\****************************************************************************************/
+
+#define  CV_VALUE  1
+#define  CV_ARRAY  2
+/* Updates active contour in order to minimize its cummulative
+   (internal and external) energy. */
+CVAPI(void)  cvSnakeImage( const IplImage* image, CvPoint* points,
+                           int  length, float* alpha,
+                           float* beta, float* gamma,
+                           int coeff_usage, CvSize  win,
+                           CvTermCriteria criteria, int calc_gradient CV_DEFAULT(1));
+
+/****************************************************************************************\
+*                                    Texture Descriptors                                 *
+\****************************************************************************************/
+
+#define CV_GLCM_OPTIMIZATION_NONE                   -2
+#define CV_GLCM_OPTIMIZATION_LUT                    -1
+#define CV_GLCM_OPTIMIZATION_HISTOGRAM              0
+
+#define CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST    10
+#define CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST    11
+#define CV_GLCMDESC_OPTIMIZATION_HISTOGRAM          4
+
+#define CV_GLCMDESC_ENTROPY                         0
+#define CV_GLCMDESC_ENERGY                          1
+#define CV_GLCMDESC_HOMOGENITY                      2
+#define CV_GLCMDESC_CONTRAST                        3
+#define CV_GLCMDESC_CLUSTERTENDENCY                 4
+#define CV_GLCMDESC_CLUSTERSHADE                    5
+#define CV_GLCMDESC_CORRELATION                     6
+#define CV_GLCMDESC_CORRELATIONINFO1                7
+#define CV_GLCMDESC_CORRELATIONINFO2                8
+#define CV_GLCMDESC_MAXIMUMPROBABILITY              9
+
+#define CV_GLCM_ALL                                 0
+#define CV_GLCM_GLCM                                1
+#define CV_GLCM_DESC                                2
+
+typedef struct CvGLCM CvGLCM;
+
+CVAPI(CvGLCM*) cvCreateGLCM( const IplImage* srcImage,
+                                int stepMagnitude,
+                                const int* stepDirections CV_DEFAULT(0),
+                                int numStepDirections CV_DEFAULT(0),
+                                int optimizationType CV_DEFAULT(CV_GLCM_OPTIMIZATION_NONE));
+
+CVAPI(void) cvReleaseGLCM( CvGLCM** GLCM, int flag CV_DEFAULT(CV_GLCM_ALL));
+
+CVAPI(void) cvCreateGLCMDescriptors( CvGLCM* destGLCM,
+                                        int descriptorOptimizationType
+                                        CV_DEFAULT(CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST));
+
+CVAPI(double) cvGetGLCMDescriptor( CvGLCM* GLCM, int step, int descriptor );
+
+CVAPI(void) cvGetGLCMDescriptorStatistics( CvGLCM* GLCM, int descriptor,
+                                              double* average, double* standardDeviation );
+
+CVAPI(IplImage*) cvCreateGLCMImage( CvGLCM* GLCM, int step );
+
+/****************************************************************************************\
+*                                  Face eyes&mouth tracking                              *
+\****************************************************************************************/
+
+
+typedef struct CvFaceTracker CvFaceTracker;
+
+#define CV_NUM_FACE_ELEMENTS    3
+enum CV_FACE_ELEMENTS
+{
+    CV_FACE_MOUTH = 0,
+    CV_FACE_LEFT_EYE = 1,
+    CV_FACE_RIGHT_EYE = 2
+};
+
+CVAPI(CvFaceTracker*) cvInitFaceTracker(CvFaceTracker* pFaceTracking, const IplImage* imgGray,
+                                                CvRect* pRects, int nRects);
+CVAPI(int) cvTrackFace( CvFaceTracker* pFaceTracker, IplImage* imgGray,
+                              CvRect* pRects, int nRects,
+                              CvPoint* ptRotate, double* dbAngleRotate);
+CVAPI(void) cvReleaseFaceTracker(CvFaceTracker** ppFaceTracker);
+
+
+typedef struct CvFace
+{
+    CvRect MouthRect;
+    CvRect LeftEyeRect;
+    CvRect RightEyeRect;
+} CvFaceData;
+
+CvSeq * cvFindFace(IplImage * Image,CvMemStorage* storage);
+CvSeq * cvPostBoostingFindFace(IplImage * Image,CvMemStorage* storage);
+
+
+/****************************************************************************************\
+*                                         3D Tracker                                     *
+\****************************************************************************************/
+
+typedef unsigned char CvBool;
+
+typedef struct Cv3dTracker2dTrackedObject
+{
+    int id;
+    CvPoint2D32f p; // pgruebele: So we do not loose precision, this needs to be float
+} Cv3dTracker2dTrackedObject;
+
+CV_INLINE Cv3dTracker2dTrackedObject cv3dTracker2dTrackedObject(int id, CvPoint2D32f p)
+{
+    Cv3dTracker2dTrackedObject r;
+    r.id = id;
+    r.p = p;
+    return r;
+}
+
+typedef struct Cv3dTrackerTrackedObject
+{
+    int id;
+    CvPoint3D32f p;             // location of the tracked object
+} Cv3dTrackerTrackedObject;
+
+CV_INLINE Cv3dTrackerTrackedObject cv3dTrackerTrackedObject(int id, CvPoint3D32f p)
+{
+    Cv3dTrackerTrackedObject r;
+    r.id = id;
+    r.p = p;
+    return r;
+}
+
+typedef struct Cv3dTrackerCameraInfo
+{
+    CvBool valid;
+    float mat[4][4];              /* maps camera coordinates to world coordinates */
+    CvPoint2D32f principal_point; /* copied from intrinsics so this structure */
+                                  /* has all the info we need */
+} Cv3dTrackerCameraInfo;
+
+typedef struct Cv3dTrackerCameraIntrinsics
+{
+    CvPoint2D32f principal_point;
+    float focal_length[2];
+    float distortion[4];
+} Cv3dTrackerCameraIntrinsics;
+
+CVAPI(CvBool) cv3dTrackerCalibrateCameras(int num_cameras,
+                     const Cv3dTrackerCameraIntrinsics camera_intrinsics[], /* size is num_cameras */
+                     CvSize etalon_size,
+                     float square_size,
+                     IplImage *samples[],                                   /* size is num_cameras */
+                     Cv3dTrackerCameraInfo camera_info[]);                  /* size is num_cameras */
+
+CVAPI(int)  cv3dTrackerLocateObjects(int num_cameras, int num_objects,
+                   const Cv3dTrackerCameraInfo camera_info[],        /* size is num_cameras */
+                   const Cv3dTracker2dTrackedObject tracking_info[], /* size is num_objects*num_cameras */
+                   Cv3dTrackerTrackedObject tracked_objects[]);      /* size is num_objects */
+/****************************************************************************************
+ tracking_info is a rectangular array; one row per camera, num_objects elements per row.
+ The id field of any unused slots must be -1. Ids need not be ordered or consecutive. On
+ completion, the return value is the number of objects located; i.e., the number of objects
+ visible by more than one camera. The id field of any unused slots in tracked objects is
+ set to -1.
+****************************************************************************************/
+
+
+/****************************************************************************************\
+*                           Skeletons and Linear-Contour Models                          *
+\****************************************************************************************/
+
+typedef enum CvLeeParameters
+{
+    CV_LEE_INT = 0,
+    CV_LEE_FLOAT = 1,
+    CV_LEE_DOUBLE = 2,
+    CV_LEE_AUTO = -1,
+    CV_LEE_ERODE = 0,
+    CV_LEE_ZOOM = 1,
+    CV_LEE_NON = 2
+} CvLeeParameters;
+
+#define CV_NEXT_VORONOISITE2D( SITE ) ((SITE)->edge[0]->site[((SITE)->edge[0]->site[0] == (SITE))])
+#define CV_PREV_VORONOISITE2D( SITE ) ((SITE)->edge[1]->site[((SITE)->edge[1]->site[0] == (SITE))])
+#define CV_FIRST_VORONOIEDGE2D( SITE ) ((SITE)->edge[0])
+#define CV_LAST_VORONOIEDGE2D( SITE ) ((SITE)->edge[1])
+#define CV_NEXT_VORONOIEDGE2D( EDGE, SITE ) ((EDGE)->next[(EDGE)->site[0] != (SITE)])
+#define CV_PREV_VORONOIEDGE2D( EDGE, SITE ) ((EDGE)->next[2 + ((EDGE)->site[0] != (SITE))])
+#define CV_VORONOIEDGE2D_BEGINNODE( EDGE, SITE ) ((EDGE)->node[((EDGE)->site[0] != (SITE))])
+#define CV_VORONOIEDGE2D_ENDNODE( EDGE, SITE ) ((EDGE)->node[((EDGE)->site[0] == (SITE))])
+#define CV_TWIN_VORONOISITE2D( SITE, EDGE ) ( (EDGE)->site[((EDGE)->site[0] == (SITE))])
+
+#define CV_VORONOISITE2D_FIELDS()    \
+    struct CvVoronoiNode2D *node[2]; \
+    struct CvVoronoiEdge2D *edge[2];
+
+typedef struct CvVoronoiSite2D
+{
+    CV_VORONOISITE2D_FIELDS()
+    struct CvVoronoiSite2D *next[2];
+} CvVoronoiSite2D;
+
+#define CV_VORONOIEDGE2D_FIELDS()    \
+    struct CvVoronoiNode2D *node[2]; \
+    struct CvVoronoiSite2D *site[2]; \
+    struct CvVoronoiEdge2D *next[4];
+
+typedef struct CvVoronoiEdge2D
+{
+    CV_VORONOIEDGE2D_FIELDS()
+} CvVoronoiEdge2D;
+
+#define CV_VORONOINODE2D_FIELDS()       \
+    CV_SET_ELEM_FIELDS(CvVoronoiNode2D) \
+    CvPoint2D32f pt;                    \
+    float radius;
+
+typedef struct CvVoronoiNode2D
+{
+    CV_VORONOINODE2D_FIELDS()
+} CvVoronoiNode2D;
+
+#define CV_VORONOIDIAGRAM2D_FIELDS() \
+    CV_GRAPH_FIELDS()                \
+    CvSet *sites;
+
+typedef struct CvVoronoiDiagram2D
+{
+    CV_VORONOIDIAGRAM2D_FIELDS()
+} CvVoronoiDiagram2D;
+
+/* Computes Voronoi Diagram for given polygons with holes */
+CVAPI(int)  cvVoronoiDiagramFromContour(CvSeq* ContourSeq,
+                                           CvVoronoiDiagram2D** VoronoiDiagram,
+                                           CvMemStorage* VoronoiStorage,
+                                           CvLeeParameters contour_type CV_DEFAULT(CV_LEE_INT),
+                                           int contour_orientation CV_DEFAULT(-1),
+                                           int attempt_number CV_DEFAULT(10));
+
+/* Computes Voronoi Diagram for domains in given image */
+CVAPI(int)  cvVoronoiDiagramFromImage(IplImage* pImage,
+                                         CvSeq** ContourSeq,
+                                         CvVoronoiDiagram2D** VoronoiDiagram,
+                                         CvMemStorage* VoronoiStorage,
+                                         CvLeeParameters regularization_method CV_DEFAULT(CV_LEE_NON),
+                                         float approx_precision CV_DEFAULT(CV_LEE_AUTO));
+
+/* Deallocates the storage */
+CVAPI(void) cvReleaseVoronoiStorage(CvVoronoiDiagram2D* VoronoiDiagram,
+                                          CvMemStorage** pVoronoiStorage);
+
+/*********************** Linear-Contour Model ****************************/
+
+struct CvLCMEdge;
+struct CvLCMNode;
+
+typedef struct CvLCMEdge
+{
+    CV_GRAPH_EDGE_FIELDS()
+    CvSeq* chain;
+    float width;
+    int index1;
+    int index2;
+} CvLCMEdge;
+
+typedef struct CvLCMNode
+{
+    CV_GRAPH_VERTEX_FIELDS()
+    CvContour* contour;
+} CvLCMNode;
+
+
+/* Computes hybrid model from Voronoi Diagram */
+CVAPI(CvGraph*) cvLinearContorModelFromVoronoiDiagram(CvVoronoiDiagram2D* VoronoiDiagram,
+                                                         float maxWidth);
+
+/* Releases hybrid model storage */
+CVAPI(int) cvReleaseLinearContorModelStorage(CvGraph** Graph);
+
+
+/* two stereo-related functions */
+
+CVAPI(void) cvInitPerspectiveTransform( CvSize size, const CvPoint2D32f vertex[4], double matrix[3][3],
+                                              CvArr* rectMap );
+
+/*CVAPI(void) cvInitStereoRectification( CvStereoCamera* params,
+                                             CvArr* rectMap1, CvArr* rectMap2,
+                                             int do_undistortion );*/
+
+/*************************** View Morphing Functions ************************/
+
+typedef struct CvMatrix3
+{
+    float m[3][3];
+} CvMatrix3;
+
+/* The order of the function corresponds to the order they should appear in
+   the view morphing pipeline */
+
+/* Finds ending points of scanlines on left and right images of stereo-pair */
+CVAPI(void)  cvMakeScanlines( const CvMatrix3* matrix, CvSize  img_size,
+                              int*  scanlines1, int*  scanlines2,
+                              int*  lengths1, int*  lengths2,
+                              int*  line_count );
+
+/* Grab pixel values from scanlines and stores them sequentially
+   (some sort of perspective image transform) */
+CVAPI(void)  cvPreWarpImage( int       line_count,
+                             IplImage* img,
+                             uchar*    dst,
+                             int*      dst_nums,
+                             int*      scanlines);
+
+/* Approximate each grabbed scanline by a sequence of runs
+   (lossy run-length compression) */
+CVAPI(void)  cvFindRuns( int    line_count,
+                         uchar* prewarp1,
+                         uchar* prewarp2,
+                         int*   line_lengths1,
+                         int*   line_lengths2,
+                         int*   runs1,
+                         int*   runs2,
+                         int*   num_runs1,
+                         int*   num_runs2);
+
+/* Compares two sets of compressed scanlines */
+CVAPI(void)  cvDynamicCorrespondMulti( int  line_count,
+                                       int* first,
+                                       int* first_runs,
+                                       int* second,
+                                       int* second_runs,
+                                       int* first_corr,
+                                       int* second_corr);
+
+/* Finds scanline ending coordinates for some intermediate "virtual" camera position */
+CVAPI(void)  cvMakeAlphaScanlines( int*  scanlines1,
+                                   int*  scanlines2,
+                                   int*  scanlinesA,
+                                   int*  lengths,
+                                   int   line_count,
+                                   float alpha);
+
+/* Blends data of the left and right image scanlines to get
+   pixel values of "virtual" image scanlines */
+CVAPI(void)  cvMorphEpilinesMulti( int    line_count,
+                                   uchar* first_pix,
+                                   int*   first_num,
+                                   uchar* second_pix,
+                                   int*   second_num,
+                                   uchar* dst_pix,
+                                   int*   dst_num,
+                                   float  alpha,
+                                   int*   first,
+                                   int*   first_runs,
+                                   int*   second,
+                                   int*   second_runs,
+                                   int*   first_corr,
+                                   int*   second_corr);
+
+/* Does reverse warping of the morphing result to make
+   it fill the destination image rectangle */
+CVAPI(void)  cvPostWarpImage( int       line_count,
+                              uchar*    src,
+                              int*      src_nums,
+                              IplImage* img,
+                              int*      scanlines);
+
+/* Deletes Moire (missed pixels that appear due to discretization) */
+CVAPI(void)  cvDeleteMoire( IplImage*  img );
+
+
+typedef struct CvConDensation
+{
+    int MP;
+    int DP;
+    float* DynamMatr;       /* Matrix of the linear Dynamics system  */
+    float* State;           /* Vector of State                       */
+    int SamplesNum;         /* Number of the Samples                 */
+    float** flSamples;      /* arr of the Sample Vectors             */
+    float** flNewSamples;   /* temporary array of the Sample Vectors */
+    float* flConfidence;    /* Confidence for each Sample            */
+    float* flCumulative;    /* Cumulative confidence                 */
+    float* Temp;            /* Temporary vector                      */
+    float* RandomSample;    /* RandomVector to update sample set     */
+    struct CvRandState* RandS; /* Array of structures to generate random vectors */
+} CvConDensation;
+
+/* Creates ConDensation filter state */
+CVAPI(CvConDensation*)  cvCreateConDensation( int dynam_params,
+                                             int measure_params,
+                                             int sample_count );
+
+/* Releases ConDensation filter state */
+CVAPI(void)  cvReleaseConDensation( CvConDensation** condens );
+
+/* Updates ConDensation filter by time (predict future state of the system) */
+CVAPI(void)  cvConDensUpdateByTime( CvConDensation* condens);
+
+/* Initializes ConDensation filter samples  */
+CVAPI(void)  cvConDensInitSampleSet( CvConDensation* condens, CvMat* lower_bound, CvMat* upper_bound );
+
+CV_INLINE int iplWidth( const IplImage* img )
+{
+    return !img ? 0 : !img->roi ? img->width : img->roi->width;
+}
+
+CV_INLINE int iplHeight( const IplImage* img )
+{
+    return !img ? 0 : !img->roi ? img->height : img->roi->height;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+
+/****************************************************************************************\
+*                                   Calibration engine                                   *
+\****************************************************************************************/
+
+typedef enum CvCalibEtalonType
+{
+    CV_CALIB_ETALON_USER = -1,
+    CV_CALIB_ETALON_CHESSBOARD = 0,
+    CV_CALIB_ETALON_CHECKERBOARD = CV_CALIB_ETALON_CHESSBOARD
+}
+CvCalibEtalonType;
+
+class CV_EXPORTS CvCalibFilter
+{
+public:
+    /* Constructor & destructor */
+    CvCalibFilter();
+    virtual ~CvCalibFilter();
+
+    /* Sets etalon type - one for all cameras.
+       etalonParams is used in case of pre-defined etalons (such as chessboard).
+       Number of elements in etalonParams is determined by etalonType.
+       E.g., if etalon type is CV_ETALON_TYPE_CHESSBOARD then:
+         etalonParams[0] is number of squares per one side of etalon
+         etalonParams[1] is number of squares per another side of etalon
+         etalonParams[2] is linear size of squares in the board in arbitrary units.
+       pointCount & points are used in case of
+       CV_CALIB_ETALON_USER (user-defined) etalon. */
+    virtual bool
+        SetEtalon( CvCalibEtalonType etalonType, double* etalonParams,
+                   int pointCount = 0, CvPoint2D32f* points = 0 );
+
+    /* Retrieves etalon parameters/or and points */
+    virtual CvCalibEtalonType
+        GetEtalon( int* paramCount = 0, const double** etalonParams = 0,
+                   int* pointCount = 0, const CvPoint2D32f** etalonPoints = 0 ) const;
+
+    /* Sets number of cameras calibrated simultaneously. It is equal to 1 initially */
+    virtual void SetCameraCount( int cameraCount );
+
+    /* Retrieves number of cameras */
+    int GetCameraCount() const { return cameraCount; }
+
+    /* Starts cameras calibration */
+    virtual bool SetFrames( int totalFrames );
+
+    /* Stops cameras calibration */
+    virtual void Stop( bool calibrate = false );
+
+    /* Retrieves number of cameras */
+    bool IsCalibrated() const { return isCalibrated; }
+
+    /* Feeds another serie of snapshots (one per each camera) to filter.
+       Etalon points on these images are found automatically.
+       If the function can't locate points, it returns false */
+    virtual bool FindEtalon( IplImage** imgs );
+
+    /* The same but takes matrices */
+    virtual bool FindEtalon( CvMat** imgs );
+
+    /* Lower-level function for feeding filter with already found etalon points.
+       Array of point arrays for each camera is passed. */
+    virtual bool Push( const CvPoint2D32f** points = 0 );
+
+    /* Returns total number of accepted frames and, optionally,
+       total number of frames to collect */
+    virtual int GetFrameCount( int* framesTotal = 0 ) const;
+
+    /* Retrieves camera parameters for specified camera.
+       If camera is not calibrated the function returns 0 */
+    virtual const CvCamera* GetCameraParams( int idx = 0 ) const;
+
+    virtual const CvStereoCamera* GetStereoParams() const;
+
+    /* Sets camera parameters for all cameras */
+    virtual bool SetCameraParams( CvCamera* params );
+
+    /* Saves all camera parameters to file */
+    virtual bool SaveCameraParams( const char* filename );
+
+    /* Loads all camera parameters from file */
+    virtual bool LoadCameraParams( const char* filename );
+
+    /* Undistorts images using camera parameters. Some of src pointers can be NULL. */
+    virtual bool Undistort( IplImage** src, IplImage** dst );
+
+    /* Undistorts images using camera parameters. Some of src pointers can be NULL. */
+    virtual bool Undistort( CvMat** src, CvMat** dst );
+
+    /* Returns array of etalon points detected/partally detected
+       on the latest frame for idx-th camera */
+    virtual bool GetLatestPoints( int idx, CvPoint2D32f** pts,
+                                                  int* count, bool* found );
+
+    /* Draw the latest detected/partially detected etalon */
+    virtual void DrawPoints( IplImage** dst );
+
+    /* Draw the latest detected/partially detected etalon */
+    virtual void DrawPoints( CvMat** dst );
+
+    virtual bool Rectify( IplImage** srcarr, IplImage** dstarr );
+    virtual bool Rectify( CvMat** srcarr, CvMat** dstarr );
+
+protected:
+
+    enum { MAX_CAMERAS = 3 };
+
+    /* etalon data */
+    CvCalibEtalonType  etalonType;
+    int     etalonParamCount;
+    double* etalonParams;
+    int     etalonPointCount;
+    CvPoint2D32f* etalonPoints;
+    CvSize  imgSize;
+    CvMat*  grayImg;
+    CvMat*  tempImg;
+    CvMemStorage* storage;
+
+    /* camera data */
+    int     cameraCount;
+    CvCamera cameraParams[MAX_CAMERAS];
+    CvStereoCamera stereo;
+    CvPoint2D32f* points[MAX_CAMERAS];
+    CvMat*  undistMap[MAX_CAMERAS][2];
+    CvMat*  undistImg;
+    int     latestCounts[MAX_CAMERAS];
+    CvPoint2D32f* latestPoints[MAX_CAMERAS];
+    CvMat*  rectMap[MAX_CAMERAS][2];
+
+    /* Added by Valery */
+    //CvStereoCamera stereoParams;
+
+    int     maxPoints;
+    int     framesTotal;
+    int     framesAccepted;
+    bool    isCalibrated;
+};
+
+#include <iosfwd>
+#include <limits>
+
+class CV_EXPORTS CvImage
+{
+public:
+    CvImage() : image(0), refcount(0) {}
+    CvImage( CvSize _size, int _depth, int _channels )
+    {
+        image = cvCreateImage( _size, _depth, _channels );
+        refcount = image ? new int(1) : 0;
+    }
+
+    CvImage( IplImage* img ) : image(img)
+    {
+        refcount = image ? new int(1) : 0;
+    }
+
+    CvImage( const CvImage& img ) : image(img.image), refcount(img.refcount)
+    {
+        if( refcount ) ++(*refcount);
+    }
+
+    CvImage( const char* filename, const char* imgname=0, int color=-1 ) : image(0), refcount(0)
+    { load( filename, imgname, color ); }
+
+    CvImage( CvFileStorage* fs, const char* mapname, const char* imgname ) : image(0), refcount(0)
+    { read( fs, mapname, imgname ); }
+
+    CvImage( CvFileStorage* fs, const char* seqname, int idx ) : image(0), refcount(0)
+    { read( fs, seqname, idx ); }
+
+    ~CvImage()
+    {
+        if( refcount && !(--*refcount) )
+        {
+            cvReleaseImage( &image );
+            delete refcount;
+        }
+    }
+
+    CvImage clone() { return CvImage(image ? cvCloneImage(image) : 0); }
+
+    void create( CvSize _size, int _depth, int _channels )
+    {
+        if( !image || !refcount ||
+           image->width != _size.width || image->height != _size.height ||
+           image->depth != _depth || image->nChannels != _channels )
+            attach( cvCreateImage( _size, _depth, _channels ));
+    }
+
+    void release() { detach(); }
+    void clear() { detach(); }
+
+    void attach( IplImage* img, bool use_refcount=true )
+    {
+        if( refcount && --*refcount == 0 )
+        {
+            cvReleaseImage( &image );
+            delete refcount;
+        }
+        image = img;
+        refcount = use_refcount && image ? new int(1) : 0;
+    }
+
+    void detach()
+    {
+        if( refcount && --*refcount == 0 )
+        {
+            cvReleaseImage( &image );
+            delete refcount;
+        }
+        image = 0;
+        refcount = 0;
+    }
+
+    bool load( const char* filename, const char* imgname=0, int color=-1 );
+    bool read( CvFileStorage* fs, const char* mapname, const char* imgname );
+    bool read( CvFileStorage* fs, const char* seqname, int idx );
+    void save( const char* filename, const char* imgname, const int* params=0 );
+    void write( CvFileStorage* fs, const char* imgname );
+
+    void show( const char* window_name );
+    bool is_valid() { return image != 0; }
+
+    int width() const { return image ? image->width : 0; }
+    int height() const { return image ? image->height : 0; }
+
+    CvSize size() const { return image ? cvSize(image->width, image->height) : cvSize(0,0); }
+
+    CvSize roi_size() const
+    {
+        return !image ? cvSize(0,0) :
+        !image->roi ? cvSize(image->width,image->height) :
+        cvSize(image->roi->width, image->roi->height);
+    }
+
+    CvRect roi() const
+    {
+        return !image ? cvRect(0,0,0,0) :
+        !image->roi ? cvRect(0,0,image->width,image->height) :
+        cvRect(image->roi->xOffset,image->roi->yOffset,
+               image->roi->width,image->roi->height);
+    }
+
+    int coi() const { return !image || !image->roi ? 0 : image->roi->coi; }
+
+    void set_roi(CvRect _roi) { cvSetImageROI(image,_roi); }
+    void reset_roi() { cvResetImageROI(image); }
+    void set_coi(int _coi) { cvSetImageCOI(image,_coi); }
+    int depth() const { return image ? image->depth : 0; }
+    int channels() const { return image ? image->nChannels : 0; }
+    int pix_size() const { return image ? ((image->depth & 255)>>3)*image->nChannels : 0; }
+
+    uchar* data() { return image ? (uchar*)image->imageData : 0; }
+    const uchar* data() const { return image ? (const uchar*)image->imageData : 0; }
+    int step() const { return image ? image->widthStep : 0; }
+    int origin() const { return image ? image->origin : 0; }
+
+    uchar* roi_row(int y)
+    {
+        assert(0<=y);
+        assert(!image ?
+               1 : image->roi ?
+               y<image->roi->height : y<image->height);
+
+        return !image ? 0 :
+        !image->roi ?
+        (uchar*)(image->imageData + y*image->widthStep) :
+        (uchar*)(image->imageData + (y+image->roi->yOffset)*image->widthStep +
+                 image->roi->xOffset*((image->depth & 255)>>3)*image->nChannels);
+    }
+
+    const uchar* roi_row(int y) const
+    {
+        assert(0<=y);
+        assert(!image ?
+               1 : image->roi ?
+               y<image->roi->height : y<image->height);
+
+        return !image ? 0 :
+        !image->roi ?
+        (const uchar*)(image->imageData + y*image->widthStep) :
+        (const uchar*)(image->imageData + (y+image->roi->yOffset)*image->widthStep +
+                       image->roi->xOffset*((image->depth & 255)>>3)*image->nChannels);
+    }
+
+    operator const IplImage* () const { return image; }
+    operator IplImage* () { return image; }
+
+    CvImage& operator = (const CvImage& img)
+    {
+        if( img.refcount )
+            ++*img.refcount;
+        if( refcount && !(--*refcount) )
+            cvReleaseImage( &image );
+        image=img.image;
+        refcount=img.refcount;
+        return *this;
+    }
+
+protected:
+    IplImage* image;
+    int* refcount;
+};
+
+
+class CV_EXPORTS CvMatrix
+{
+public:
+    CvMatrix() : matrix(0) {}
+    CvMatrix( int _rows, int _cols, int _type )
+    { matrix = cvCreateMat( _rows, _cols, _type ); }
+
+    CvMatrix( int _rows, int _cols, int _type, CvMat* hdr,
+             void* _data=0, int _step=CV_AUTOSTEP )
+    { matrix = cvInitMatHeader( hdr, _rows, _cols, _type, _data, _step ); }
+
+    CvMatrix( int rows, int cols, int type, CvMemStorage* storage, bool alloc_data=true );
+
+    CvMatrix( int _rows, int _cols, int _type, void* _data, int _step=CV_AUTOSTEP )
+    { matrix = cvCreateMatHeader( _rows, _cols, _type );
+        cvSetData( matrix, _data, _step ); }
+
+    CvMatrix( CvMat* m )
+    { matrix = m; }
+
+    CvMatrix( const CvMatrix& m )
+    {
+        matrix = m.matrix;
+        addref();
+    }
+
+    CvMatrix( const char* filename, const char* matname=0, int color=-1 ) : matrix(0)
+    {  load( filename, matname, color ); }
+
+    CvMatrix( CvFileStorage* fs, const char* mapname, const char* matname ) : matrix(0)
+    {  read( fs, mapname, matname ); }
+
+    CvMatrix( CvFileStorage* fs, const char* seqname, int idx ) : matrix(0)
+    {  read( fs, seqname, idx ); }
+
+    ~CvMatrix()
+    {
+        release();
+    }
+
+    CvMatrix clone() { return CvMatrix(matrix ? cvCloneMat(matrix) : 0); }
+
+    void set( CvMat* m, bool add_ref )
+    {
+        release();
+        matrix = m;
+        if( add_ref )
+            addref();
+    }
+
+    void create( int _rows, int _cols, int _type )
+    {
+        if( !matrix || !matrix->refcount ||
+           matrix->rows != _rows || matrix->cols != _cols ||
+           CV_MAT_TYPE(matrix->type) != _type )
+            set( cvCreateMat( _rows, _cols, _type ), false );
+    }
+
+    void addref() const
+    {
+        if( matrix )
+        {
+            if( matrix->hdr_refcount )
+                ++matrix->hdr_refcount;
+            else if( matrix->refcount )
+                ++*matrix->refcount;
+        }
+    }
+
+    void release()
+    {
+        if( matrix )
+        {
+            if( matrix->hdr_refcount )
+            {
+                if( --matrix->hdr_refcount == 0 )
+                    cvReleaseMat( &matrix );
+            }
+            else if( matrix->refcount )
+            {
+                if( --*matrix->refcount == 0 )
+                    cvFree( &matrix->refcount );
+            }
+            matrix = 0;
+        }
+    }
+
+    void clear()
+    {
+        release();
+    }
+
+    bool load( const char* filename, const char* matname=0, int color=-1 );
+    bool read( CvFileStorage* fs, const char* mapname, const char* matname );
+    bool read( CvFileStorage* fs, const char* seqname, int idx );
+    void save( const char* filename, const char* matname, const int* params=0 );
+    void write( CvFileStorage* fs, const char* matname );
+
+    void show( const char* window_name );
+
+    bool is_valid() { return matrix != 0; }
+
+    int rows() const { return matrix ? matrix->rows : 0; }
+    int cols() const { return matrix ? matrix->cols : 0; }
+
+    CvSize size() const
+    {
+        return !matrix ? cvSize(0,0) : cvSize(matrix->rows,matrix->cols);
+    }
+
+    int type() const { return matrix ? CV_MAT_TYPE(matrix->type) : 0; }
+    int depth() const { return matrix ? CV_MAT_DEPTH(matrix->type) : 0; }
+    int channels() const { return matrix ? CV_MAT_CN(matrix->type) : 0; }
+    int pix_size() const { return matrix ? CV_ELEM_SIZE(matrix->type) : 0; }
+
+    uchar* data() { return matrix ? matrix->data.ptr : 0; }
+    const uchar* data() const { return matrix ? matrix->data.ptr : 0; }
+    int step() const { return matrix ? matrix->step : 0; }
+
+    void set_data( void* _data, int _step=CV_AUTOSTEP )
+    { cvSetData( matrix, _data, _step ); }
+
+    uchar* row(int i) { return !matrix ? 0 : matrix->data.ptr + i*matrix->step; }
+    const uchar* row(int i) const
+    { return !matrix ? 0 : matrix->data.ptr + i*matrix->step; }
+
+    operator const CvMat* () const { return matrix; }
+    operator CvMat* () { return matrix; }
+
+    CvMatrix& operator = (const CvMatrix& _m)
+    {
+        _m.addref();
+        release();
+        matrix = _m.matrix;
+        return *this;
+    }
+
+protected:
+    CvMat* matrix;
+};
+
+/****************************************************************************************\
+ *                                       CamShiftTracker                                  *
+ \****************************************************************************************/
+
+class CV_EXPORTS CvCamShiftTracker
+{
+public:
+
+    CvCamShiftTracker();
+    virtual ~CvCamShiftTracker();
+
+    /**** Characteristics of the object that are calculated by track_object method *****/
+    float   get_orientation() const // orientation of the object in degrees
+    { return m_box.angle; }
+    float   get_length() const // the larger linear size of the object
+    { return m_box.size.height; }
+    float   get_width() const // the smaller linear size of the object
+    { return m_box.size.width; }
+    CvPoint2D32f get_center() const // center of the object
+    { return m_box.center; }
+    CvRect get_window() const // bounding rectangle for the object
+    { return m_comp.rect; }
+
+    /*********************** Tracking parameters ************************/
+    int     get_threshold() const // thresholding value that applied to back project
+    { return m_threshold; }
+
+    int     get_hist_dims( int* dims = 0 ) const // returns number of histogram dimensions and sets
+    { return m_hist ? cvGetDims( m_hist->bins, dims ) : 0; }
+
+    int     get_min_ch_val( int channel ) const // get the minimum allowed value of the specified channel
+    { return m_min_ch_val[channel]; }
+
+    int     get_max_ch_val( int channel ) const // get the maximum allowed value of the specified channel
+    { return m_max_ch_val[channel]; }
+
+    // set initial object rectangle (must be called before initial calculation of the histogram)
+    bool    set_window( CvRect window)
+    { m_comp.rect = window; return true; }
+
+    bool    set_threshold( int threshold ) // threshold applied to the histogram bins
+    { m_threshold = threshold; return true; }
+
+    bool    set_hist_bin_range( int dim, int min_val, int max_val );
+
+    bool    set_hist_dims( int c_dims, int* dims );// set the histogram parameters
+
+    bool    set_min_ch_val( int channel, int val ) // set the minimum allowed value of the specified channel
+    { m_min_ch_val[channel] = val; return true; }
+    bool    set_max_ch_val( int channel, int val ) // set the maximum allowed value of the specified channel
+    { m_max_ch_val[channel] = val; return true; }
+
+    /************************ The processing methods *********************************/
+    // update object position
+    virtual bool  track_object( const IplImage* cur_frame );
+
+    // update object histogram
+    virtual bool  update_histogram( const IplImage* cur_frame );
+
+    // reset histogram
+    virtual void  reset_histogram();
+
+    /************************ Retrieving internal data *******************************/
+    // get back project image
+    virtual IplImage* get_back_project()
+    { return m_back_project; }
+
+    float query( int* bin ) const
+    { return m_hist ? (float)cvGetRealND(m_hist->bins, bin) : 0.f; }
+
+protected:
+
+    // internal method for color conversion: fills m_color_planes group
+    virtual void color_transform( const IplImage* img );
+
+    CvHistogram* m_hist;
+
+    CvBox2D    m_box;
+    CvConnectedComp m_comp;
+
+    float      m_hist_ranges_data[CV_MAX_DIM][2];
+    float*     m_hist_ranges[CV_MAX_DIM];
+
+    int        m_min_ch_val[CV_MAX_DIM];
+    int        m_max_ch_val[CV_MAX_DIM];
+    int        m_threshold;
+
+    IplImage*  m_color_planes[CV_MAX_DIM];
+    IplImage*  m_back_project;
+    IplImage*  m_temp;
+    IplImage*  m_mask;
+};
+
+/****************************************************************************************\
+*                              Expectation - Maximization                                *
+\****************************************************************************************/
+struct CV_EXPORTS_W_MAP CvEMParams
+{
+    CvEMParams();
+    CvEMParams( int nclusters, int cov_mat_type=cv::EM::COV_MAT_DIAGONAL,
+                int start_step=cv::EM::START_AUTO_STEP,
+                CvTermCriteria term_crit=cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON),
+                const CvMat* probs=0, const CvMat* weights=0, const CvMat* means=0, const CvMat** covs=0 );
+
+    CV_PROP_RW int nclusters;
+    CV_PROP_RW int cov_mat_type;
+    CV_PROP_RW int start_step;
+    const CvMat* probs;
+    const CvMat* weights;
+    const CvMat* means;
+    const CvMat** covs;
+    CV_PROP_RW CvTermCriteria term_crit;
+};
+
+
+class CV_EXPORTS_W CvEM : public CvStatModel
+{
+public:
+    // Type of covariation matrices
+    enum { COV_MAT_SPHERICAL=cv::EM::COV_MAT_SPHERICAL,
+           COV_MAT_DIAGONAL =cv::EM::COV_MAT_DIAGONAL,
+           COV_MAT_GENERIC  =cv::EM::COV_MAT_GENERIC };
+
+    // The initial step
+    enum { START_E_STEP=cv::EM::START_E_STEP,
+           START_M_STEP=cv::EM::START_M_STEP,
+           START_AUTO_STEP=cv::EM::START_AUTO_STEP };
+
+    CV_WRAP CvEM();
+    CvEM( const CvMat* samples, const CvMat* sampleIdx=0,
+          CvEMParams params=CvEMParams(), CvMat* labels=0 );
+
+    virtual ~CvEM();
+
+    virtual bool train( const CvMat* samples, const CvMat* sampleIdx=0,
+                        CvEMParams params=CvEMParams(), CvMat* labels=0 );
+
+    virtual float predict( const CvMat* sample, CV_OUT CvMat* probs ) const;
+
+    CV_WRAP CvEM( const cv::Mat& samples, const cv::Mat& sampleIdx=cv::Mat(),
+                  CvEMParams params=CvEMParams() );
+
+    CV_WRAP virtual bool train( const cv::Mat& samples,
+                                const cv::Mat& sampleIdx=cv::Mat(),
+                                CvEMParams params=CvEMParams(),
+                                CV_OUT cv::Mat* labels=0 );
+
+    CV_WRAP virtual float predict( const cv::Mat& sample, CV_OUT cv::Mat* probs=0 ) const;
+    CV_WRAP virtual double calcLikelihood( const cv::Mat &sample ) const;
+
+    CV_WRAP int getNClusters() const;
+    CV_WRAP cv::Mat getMeans() const;
+    CV_WRAP void getCovs(CV_OUT std::vector<cv::Mat>& covs) const;
+    CV_WRAP cv::Mat getWeights() const;
+    CV_WRAP cv::Mat getProbs() const;
+
+    CV_WRAP inline double getLikelihood() const { return emObj.isTrained() ? logLikelihood : DBL_MAX; }
+
+    CV_WRAP virtual void clear();
+
+    int get_nclusters() const;
+    const CvMat* get_means() const;
+    const CvMat** get_covs() const;
+    const CvMat* get_weights() const;
+    const CvMat* get_probs() const;
+
+    inline double get_log_likelihood() const { return getLikelihood(); }
+
+    virtual void read( CvFileStorage* fs, CvFileNode* node );
+    virtual void write( CvFileStorage* fs, const char* name ) const;
+
+protected:
+    void set_mat_hdrs();
+
+    cv::EM emObj;
+    cv::Mat probs;
+    double logLikelihood;
+
+    CvMat meansHdr;
+    std::vector<CvMat> covsHdrs;
+    std::vector<CvMat*> covsPtrs;
+    CvMat weightsHdr;
+    CvMat probsHdr;
+};
+
+namespace cv
+{
+
+typedef CvEMParams EMParams;
+typedef CvEM ExpectationMaximization;
+
+/*!
+ The Patch Generator class
+ */
+class CV_EXPORTS PatchGenerator
+{
+public:
+    PatchGenerator();
+    PatchGenerator(double _backgroundMin, double _backgroundMax,
+                   double _noiseRange, bool _randomBlur=true,
+                   double _lambdaMin=0.6, double _lambdaMax=1.5,
+                   double _thetaMin=-CV_PI, double _thetaMax=CV_PI,
+                   double _phiMin=-CV_PI, double _phiMax=CV_PI );
+    void operator()(const Mat& image, Point2f pt, Mat& patch, Size patchSize, RNG& rng) const;
+    void operator()(const Mat& image, const Mat& transform, Mat& patch,
+                    Size patchSize, RNG& rng) const;
+    void warpWholeImage(const Mat& image, Mat& matT, Mat& buf,
+                        CV_OUT Mat& warped, int border, RNG& rng) const;
+    void generateRandomTransform(Point2f srcCenter, Point2f dstCenter,
+                                 CV_OUT Mat& transform, RNG& rng,
+                                 bool inverse=false) const;
+    void setAffineParam(double lambda, double theta, double phi);
+
+    double backgroundMin, backgroundMax;
+    double noiseRange;
+    bool randomBlur;
+    double lambdaMin, lambdaMax;
+    double thetaMin, thetaMax;
+    double phiMin, phiMax;
+};
+
+
+class CV_EXPORTS LDetector
+{
+public:
+    LDetector();
+    LDetector(int _radius, int _threshold, int _nOctaves,
+              int _nViews, double _baseFeatureSize, double _clusteringDistance);
+    void operator()(const Mat& image,
+                    CV_OUT vector<KeyPoint>& keypoints,
+                    int maxCount=0, bool scaleCoords=true) const;
+    void operator()(const vector<Mat>& pyr,
+                    CV_OUT vector<KeyPoint>& keypoints,
+                    int maxCount=0, bool scaleCoords=true) const;
+    void getMostStable2D(const Mat& image, CV_OUT vector<KeyPoint>& keypoints,
+                         int maxCount, const PatchGenerator& patchGenerator) const;
+    void setVerbose(bool verbose);
+
+    void read(const FileNode& node);
+    void write(FileStorage& fs, const String& name=String()) const;
+
+    int radius;
+    int threshold;
+    int nOctaves;
+    int nViews;
+    bool verbose;
+
+    double baseFeatureSize;
+    double clusteringDistance;
+};
+
+typedef LDetector YAPE;
+
+class CV_EXPORTS FernClassifier
+{
+public:
+    FernClassifier();
+    FernClassifier(const FileNode& node);
+    FernClassifier(const vector<vector<Point2f> >& points,
+                   const vector<Mat>& refimgs,
+                   const vector<vector<int> >& labels=vector<vector<int> >(),
+                   int _nclasses=0, int _patchSize=PATCH_SIZE,
+                   int _signatureSize=DEFAULT_SIGNATURE_SIZE,
+                   int _nstructs=DEFAULT_STRUCTS,
+                   int _structSize=DEFAULT_STRUCT_SIZE,
+                   int _nviews=DEFAULT_VIEWS,
+                   int _compressionMethod=COMPRESSION_NONE,
+                   const PatchGenerator& patchGenerator=PatchGenerator());
+    virtual ~FernClassifier();
+    virtual void read(const FileNode& n);
+    virtual void write(FileStorage& fs, const String& name=String()) const;
+    virtual void trainFromSingleView(const Mat& image,
+                                     const vector<KeyPoint>& keypoints,
+                                     int _patchSize=PATCH_SIZE,
+                                     int _signatureSize=DEFAULT_SIGNATURE_SIZE,
+                                     int _nstructs=DEFAULT_STRUCTS,
+                                     int _structSize=DEFAULT_STRUCT_SIZE,
+                                     int _nviews=DEFAULT_VIEWS,
+                                     int _compressionMethod=COMPRESSION_NONE,
+                                     const PatchGenerator& patchGenerator=PatchGenerator());
+    virtual void train(const vector<vector<Point2f> >& points,
+                       const vector<Mat>& refimgs,
+                       const vector<vector<int> >& labels=vector<vector<int> >(),
+                       int _nclasses=0, int _patchSize=PATCH_SIZE,
+                       int _signatureSize=DEFAULT_SIGNATURE_SIZE,
+                       int _nstructs=DEFAULT_STRUCTS,
+                       int _structSize=DEFAULT_STRUCT_SIZE,
+                       int _nviews=DEFAULT_VIEWS,
+                       int _compressionMethod=COMPRESSION_NONE,
+                       const PatchGenerator& patchGenerator=PatchGenerator());
+    virtual int operator()(const Mat& img, Point2f kpt, vector<float>& signature) const;
+    virtual int operator()(const Mat& patch, vector<float>& signature) const;
+    virtual void clear();
+    virtual bool empty() const;
+    void setVerbose(bool verbose);
+
+    int getClassCount() const;
+    int getStructCount() const;
+    int getStructSize() const;
+    int getSignatureSize() const;
+    int getCompressionMethod() const;
+    Size getPatchSize() const;
+
+    struct Feature
+    {
+        uchar x1, y1, x2, y2;
+        Feature() : x1(0), y1(0), x2(0), y2(0) {}
+        Feature(int _x1, int _y1, int _x2, int _y2)
+        : x1((uchar)_x1), y1((uchar)_y1), x2((uchar)_x2), y2((uchar)_y2)
+        {}
+        template<typename _Tp> bool operator ()(const Mat_<_Tp>& patch) const
+        { return patch(y1,x1) > patch(y2, x2); }
+    };
+
+    enum
+    {
+        PATCH_SIZE = 31,
+        DEFAULT_STRUCTS = 50,
+        DEFAULT_STRUCT_SIZE = 9,
+        DEFAULT_VIEWS = 5000,
+        DEFAULT_SIGNATURE_SIZE = 176,
+        COMPRESSION_NONE = 0,
+        COMPRESSION_RANDOM_PROJ = 1,
+        COMPRESSION_PCA = 2,
+        DEFAULT_COMPRESSION_METHOD = COMPRESSION_NONE
+    };
+
+protected:
+    virtual void prepare(int _nclasses, int _patchSize, int _signatureSize,
+                         int _nstructs, int _structSize,
+                         int _nviews, int _compressionMethod);
+    virtual void finalize(RNG& rng);
+    virtual int getLeaf(int fidx, const Mat& patch) const;
+
+    bool verbose;
+    int nstructs;
+    int structSize;
+    int nclasses;
+    int signatureSize;
+    int compressionMethod;
+    int leavesPerStruct;
+    Size patchSize;
+    vector<Feature> features;
+    vector<int> classCounters;
+    vector<float> posteriors;
+};
+
+
+/****************************************************************************************\
+ *                                 Calonder Classifier                                    *
+ \****************************************************************************************/
+
+struct RTreeNode;
+
+struct CV_EXPORTS BaseKeypoint
+{
+    int x;
+    int y;
+    IplImage* image;
+
+    BaseKeypoint()
+    : x(0), y(0), image(NULL)
+    {}
+
+    BaseKeypoint(int _x, int _y, IplImage* _image)
+    : x(_x), y(_y), image(_image)
+    {}
+};
+
+class CV_EXPORTS RandomizedTree
+{
+public:
+    friend class RTreeClassifier;
+
+    static const uchar PATCH_SIZE = 32;
+    static const int DEFAULT_DEPTH = 9;
+    static const int DEFAULT_VIEWS = 5000;
+    static const size_t DEFAULT_REDUCED_NUM_DIM = 176;
+    static float GET_LOWER_QUANT_PERC() { return .03f; }
+    static float GET_UPPER_QUANT_PERC() { return .92f; }
+
+    RandomizedTree();
+    ~RandomizedTree();
+
+    void train(vector<BaseKeypoint> const& base_set, RNG &rng,
+               int depth, int views, size_t reduced_num_dim, int num_quant_bits);
+    void train(vector<BaseKeypoint> const& base_set, RNG &rng,
+               PatchGenerator &make_patch, int depth, int views, size_t reduced_num_dim,
+               int num_quant_bits);
+
+    // following two funcs are EXPERIMENTAL (do not use unless you know exactly what you do)
+    static void quantizeVector(float *vec, int dim, int N, float bnds[2], int clamp_mode=0);
+    static void quantizeVector(float *src, int dim, int N, float bnds[2], uchar *dst);
+
+    // patch_data must be a 32x32 array (no row padding)
+    float* getPosterior(uchar* patch_data);
+    const float* getPosterior(uchar* patch_data) const;
+    uchar* getPosterior2(uchar* patch_data);
+    const uchar* getPosterior2(uchar* patch_data) const;
+
+    void read(const char* file_name, int num_quant_bits);
+    void read(std::istream &is, int num_quant_bits);
+    void write(const char* file_name) const;
+    void write(std::ostream &os) const;
+
+    int classes() { return classes_; }
+    int depth() { return depth_; }
+
+    //void setKeepFloatPosteriors(bool b) { keep_float_posteriors_ = b; }
+    void discardFloatPosteriors() { freePosteriors(1); }
+
+    inline void applyQuantization(int num_quant_bits) { makePosteriors2(num_quant_bits); }
+
+    // debug
+    void savePosteriors(std::string url, bool append=false);
+    void savePosteriors2(std::string url, bool append=false);
+
+private:
+    int classes_;
+    int depth_;
+    int num_leaves_;
+    vector<RTreeNode> nodes_;
+    float **posteriors_;        // 16-bytes aligned posteriors
+    uchar **posteriors2_;     // 16-bytes aligned posteriors
+    vector<int> leaf_counts_;
+
+    void createNodes(int num_nodes, RNG &rng);
+    void allocPosteriorsAligned(int num_leaves, int num_classes);
+    void freePosteriors(int which);    // which: 1=posteriors_, 2=posteriors2_, 3=both
+    void init(int classes, int depth, RNG &rng);
+    void addExample(int class_id, uchar* patch_data);
+    void finalize(size_t reduced_num_dim, int num_quant_bits);
+    int getIndex(uchar* patch_data) const;
+    inline float* getPosteriorByIndex(int index);
+    inline const float* getPosteriorByIndex(int index) const;
+    inline uchar* getPosteriorByIndex2(int index);
+    inline const uchar* getPosteriorByIndex2(int index) const;
+    //void makeRandomMeasMatrix(float *cs_phi, PHI_DISTR_TYPE dt, size_t reduced_num_dim);
+    void convertPosteriorsToChar();
+    void makePosteriors2(int num_quant_bits);
+    void compressLeaves(size_t reduced_num_dim);
+    void estimateQuantPercForPosteriors(float perc[2]);
+};
+
+
+inline uchar* getData(IplImage* image)
+{
+    return reinterpret_cast<uchar*>(image->imageData);
+}
+
+inline float* RandomizedTree::getPosteriorByIndex(int index)
+{
+    return const_cast<float*>(const_cast<const RandomizedTree*>(this)->getPosteriorByIndex(index));
+}
+
+inline const float* RandomizedTree::getPosteriorByIndex(int index) const
+{
+    return posteriors_[index];
+}
+
+inline uchar* RandomizedTree::getPosteriorByIndex2(int index)
+{
+    return const_cast<uchar*>(const_cast<const RandomizedTree*>(this)->getPosteriorByIndex2(index));
+}
+
+inline const uchar* RandomizedTree::getPosteriorByIndex2(int index) const
+{
+    return posteriors2_[index];
+}
+
+struct CV_EXPORTS RTreeNode
+{
+    short offset1, offset2;
+
+    RTreeNode() {}
+    RTreeNode(uchar x1, uchar y1, uchar x2, uchar y2)
+    : offset1(y1*RandomizedTree::PATCH_SIZE + x1),
+    offset2(y2*RandomizedTree::PATCH_SIZE + x2)
+    {}
+
+    //! Left child on 0, right child on 1
+    inline bool operator() (uchar* patch_data) const
+    {
+        return patch_data[offset1] > patch_data[offset2];
+    }
+};
+
+class CV_EXPORTS RTreeClassifier
+{
+public:
+    static const int DEFAULT_TREES = 48;
+    static const size_t DEFAULT_NUM_QUANT_BITS = 4;
+
+    RTreeClassifier();
+    void train(vector<BaseKeypoint> const& base_set,
+               RNG &rng,
+               int num_trees = RTreeClassifier::DEFAULT_TREES,
+               int depth = RandomizedTree::DEFAULT_DEPTH,
+               int views = RandomizedTree::DEFAULT_VIEWS,
+               size_t reduced_num_dim = RandomizedTree::DEFAULT_REDUCED_NUM_DIM,
+               int num_quant_bits = DEFAULT_NUM_QUANT_BITS);
+    void train(vector<BaseKeypoint> const& base_set,
+               RNG &rng,
+               PatchGenerator &make_patch,
+               int num_trees = RTreeClassifier::DEFAULT_TREES,
+               int depth = RandomizedTree::DEFAULT_DEPTH,
+               int views = RandomizedTree::DEFAULT_VIEWS,
+               size_t reduced_num_dim = RandomizedTree::DEFAULT_REDUCED_NUM_DIM,
+               int num_quant_bits = DEFAULT_NUM_QUANT_BITS);
+
+    // sig must point to a memory block of at least classes()*sizeof(float|uchar) bytes
+    void getSignature(IplImage *patch, uchar *sig) const;
+    void getSignature(IplImage *patch, float *sig) const;
+    void getSparseSignature(IplImage *patch, float *sig, float thresh) const;
+    // TODO: deprecated in favor of getSignature overload, remove
+    void getFloatSignature(IplImage *patch, float *sig) const { getSignature(patch, sig); }
+
+    static int countNonZeroElements(float *vec, int n, double tol=1e-10);
+    static inline void safeSignatureAlloc(uchar **sig, int num_sig=1, int sig_len=176);
+    static inline uchar* safeSignatureAlloc(int num_sig=1, int sig_len=176);
+
+    inline int classes() const { return classes_; }
+    inline int original_num_classes() const { return original_num_classes_; }
+
+    void setQuantization(int num_quant_bits);
+    void discardFloatPosteriors();
+
+    void read(const char* file_name);
+    void read(std::istream &is);
+    void write(const char* file_name) const;
+    void write(std::ostream &os) const;
+
+    // experimental and debug
+    void saveAllFloatPosteriors(std::string file_url);
+    void saveAllBytePosteriors(std::string file_url);
+    void setFloatPosteriorsFromTextfile_176(std::string url);
+    float countZeroElements();
+
+    vector<RandomizedTree> trees_;
+
+private:
+    int classes_;
+    int num_quant_bits_;
+    mutable uchar **posteriors_;
+    mutable unsigned short *ptemp_;
+    int original_num_classes_;
+    bool keep_floats_;
+};
+
+/****************************************************************************************\
+*                                     One-Way Descriptor                                 *
+\****************************************************************************************/
+
+// CvAffinePose: defines a parameterized affine transformation of an image patch.
+// An image patch is rotated on angle phi (in degrees), then scaled lambda1 times
+// along horizontal and lambda2 times along vertical direction, and then rotated again
+// on angle (theta - phi).
+class CV_EXPORTS CvAffinePose
+{
+public:
+    float phi;
+    float theta;
+    float lambda1;
+    float lambda2;
+};
+
+class CV_EXPORTS OneWayDescriptor
+{
+public:
+    OneWayDescriptor();
+    ~OneWayDescriptor();
+
+    // allocates memory for given descriptor parameters
+    void Allocate(int pose_count, CvSize size, int nChannels);
+
+    // GenerateSamples: generates affine transformed patches with averaging them over small transformation variations.
+    // If external poses and transforms were specified, uses them instead of generating random ones
+    // - pose_count: the number of poses to be generated
+    // - frontal: the input patch (can be a roi in a larger image)
+    // - norm: if nonzero, normalizes the output patch so that the sum of pixel intensities is 1
+    void GenerateSamples(int pose_count, IplImage* frontal, int norm = 0);
+
+    // GenerateSamplesFast: generates affine transformed patches with averaging them over small transformation variations.
+    // Uses precalculated transformed pca components.
+    // - frontal: the input patch (can be a roi in a larger image)
+    // - pca_hr_avg: pca average vector
+    // - pca_hr_eigenvectors: pca eigenvectors
+    // - pca_descriptors: an array of precomputed descriptors of pca components containing their affine transformations
+    //   pca_descriptors[0] corresponds to the average, pca_descriptors[1]-pca_descriptors[pca_dim] correspond to eigenvectors
+    void GenerateSamplesFast(IplImage* frontal, CvMat* pca_hr_avg,
+                             CvMat* pca_hr_eigenvectors, OneWayDescriptor* pca_descriptors);
+
+    // sets the poses and corresponding transforms
+    void SetTransforms(CvAffinePose* poses, CvMat** transforms);
+
+    // Initialize: builds a descriptor.
+    // - pose_count: the number of poses to build. If poses were set externally, uses them rather than generating random ones
+    // - frontal: input patch. Can be a roi in a larger image
+    // - feature_name: the feature name to be associated with the descriptor
+    // - norm: if 1, the affine transformed patches are normalized so that their sum is 1
+    void Initialize(int pose_count, IplImage* frontal, const char* feature_name = 0, int norm = 0);
+
+    // InitializeFast: builds a descriptor using precomputed descriptors of pca components
+    // - pose_count: the number of poses to build
+    // - frontal: input patch. Can be a roi in a larger image
+    // - feature_name: the feature name to be associated with the descriptor
+    // - pca_hr_avg: average vector for PCA
+    // - pca_hr_eigenvectors: PCA eigenvectors (one vector per row)
+    // - pca_descriptors: precomputed descriptors of PCA components, the first descriptor for the average vector
+    // followed by the descriptors for eigenvectors
+    void InitializeFast(int pose_count, IplImage* frontal, const char* feature_name,
+                        CvMat* pca_hr_avg, CvMat* pca_hr_eigenvectors, OneWayDescriptor* pca_descriptors);
+
+    // ProjectPCASample: unwarps an image patch into a vector and projects it into PCA space
+    // - patch: input image patch
+    // - avg: PCA average vector
+    // - eigenvectors: PCA eigenvectors, one per row
+    // - pca_coeffs: output PCA coefficients
+    void ProjectPCASample(IplImage* patch, CvMat* avg, CvMat* eigenvectors, CvMat* pca_coeffs) const;
+
+    // InitializePCACoeffs: projects all warped patches into PCA space
+    // - avg: PCA average vector
+    // - eigenvectors: PCA eigenvectors, one per row
+    void InitializePCACoeffs(CvMat* avg, CvMat* eigenvectors);
+
+    // EstimatePose: finds the closest match between an input patch and a set of patches with different poses
+    // - patch: input image patch
+    // - pose_idx: the output index of the closest pose
+    // - distance: the distance to the closest pose (L2 distance)
+    void EstimatePose(IplImage* patch, int& pose_idx, float& distance) const;
+
+    // EstimatePosePCA: finds the closest match between an input patch and a set of patches with different poses.
+    // The distance between patches is computed in PCA space
+    // - patch: input image patch
+    // - pose_idx: the output index of the closest pose
+    // - distance: distance to the closest pose (L2 distance in PCA space)
+    // - avg: PCA average vector. If 0, matching without PCA is used
+    // - eigenvectors: PCA eigenvectors, one per row
+    void EstimatePosePCA(CvArr* patch, int& pose_idx, float& distance, CvMat* avg, CvMat* eigenvalues) const;
+
+    // GetPatchSize: returns the size of each image patch after warping (2 times smaller than the input patch)
+    CvSize GetPatchSize() const
+    {
+        return m_patch_size;
+    }
+
+    // GetInputPatchSize: returns the required size of the patch that the descriptor is built from
+    // (2 time larger than the patch after warping)
+    CvSize GetInputPatchSize() const
+    {
+        return cvSize(m_patch_size.width*2, m_patch_size.height*2);
+    }
+
+    // GetPatch: returns a patch corresponding to specified pose index
+    // - index: pose index
+    // - return value: the patch corresponding to specified pose index
+    IplImage* GetPatch(int index);
+
+    // GetPose: returns a pose corresponding to specified pose index
+    // - index: pose index
+    // - return value: the pose corresponding to specified pose index
+    CvAffinePose GetPose(int index) const;
+
+    // Save: saves all patches with different poses to a specified path
+    void Save(const char* path);
+
+    // ReadByName: reads a descriptor from a file storage
+    // - fs: file storage
+    // - parent: parent node
+    // - name: node name
+    // - return value: 1 if succeeded, 0 otherwise
+    int ReadByName(CvFileStorage* fs, CvFileNode* parent, const char* name);
+
+    // ReadByName: reads a descriptor from a file node
+    // - parent: parent node
+    // - name: node name
+    // - return value: 1 if succeeded, 0 otherwise
+    int ReadByName(const FileNode &parent, const char* name);
+
+    // Write: writes a descriptor into a file storage
+    // - fs: file storage
+    // - name: node name
+    void Write(CvFileStorage* fs, const char* name);
+
+    // GetFeatureName: returns a name corresponding to a feature
+    const char* GetFeatureName() const;
+
+    // GetCenter: returns the center of the feature
+    CvPoint GetCenter() const;
+
+    void SetPCADimHigh(int pca_dim_high) {m_pca_dim_high = pca_dim_high;};
+    void SetPCADimLow(int pca_dim_low) {m_pca_dim_low = pca_dim_low;};
+
+    int GetPCADimLow() const;
+    int GetPCADimHigh() const;
+
+    CvMat** GetPCACoeffs() const {return m_pca_coeffs;}
+
+protected:
+    int m_pose_count; // the number of poses
+    CvSize m_patch_size; // size of each image
+    IplImage** m_samples; // an array of length m_pose_count containing the patch in different poses
+    IplImage* m_input_patch;
+    IplImage* m_train_patch;
+    CvMat** m_pca_coeffs; // an array of length m_pose_count containing pca decomposition of the patch in different poses
+    CvAffinePose* m_affine_poses; // an array of poses
+    CvMat** m_transforms; // an array of affine transforms corresponding to poses
+
+    string m_feature_name; // the name of the feature associated with the descriptor
+    CvPoint m_center; // the coordinates of the feature (the center of the input image ROI)
+
+    int m_pca_dim_high; // the number of descriptor pca components to use for generating affine poses
+    int m_pca_dim_low; // the number of pca components to use for comparison
+};
+
+
+// OneWayDescriptorBase: encapsulates functionality for training/loading a set of one way descriptors
+// and finding the nearest closest descriptor to an input feature
+class CV_EXPORTS OneWayDescriptorBase
+{
+public:
+
+    // creates an instance of OneWayDescriptor from a set of training files
+    // - patch_size: size of the input (large) patch
+    // - pose_count: the number of poses to generate for each descriptor
+    // - train_path: path to training files
+    // - pca_config: the name of the file that contains PCA for small patches (2 times smaller
+    // than patch_size each dimension
+    // - pca_hr_config: the name of the file that contains PCA for large patches (of patch_size size)
+    // - pca_desc_config: the name of the file that contains descriptors of PCA components
+    OneWayDescriptorBase(CvSize patch_size, int pose_count, const char* train_path = 0, const char* pca_config = 0,
+                         const char* pca_hr_config = 0, const char* pca_desc_config = 0, int pyr_levels = 1,
+                         int pca_dim_high = 100, int pca_dim_low = 100);
+
+    OneWayDescriptorBase(CvSize patch_size, int pose_count, const string &pca_filename, const string &train_path = string(), const string &images_list = string(),
+                         float _scale_min = 0.7f, float _scale_max=1.5f, float _scale_step=1.2f, int pyr_levels = 1,
+                         int pca_dim_high = 100, int pca_dim_low = 100);
+
+
+    virtual ~OneWayDescriptorBase();
+    void clear ();
+
+
+    // Allocate: allocates memory for a given number of descriptors
+    void Allocate(int train_feature_count);
+
+    // AllocatePCADescriptors: allocates memory for pca descriptors
+    void AllocatePCADescriptors();
+
+    // returns patch size
+    CvSize GetPatchSize() const {return m_patch_size;};
+    // returns the number of poses for each descriptor
+    int GetPoseCount() const {return m_pose_count;};
+
+    // returns the number of pyramid levels
+    int GetPyrLevels() const {return m_pyr_levels;};
+
+    // returns the number of descriptors
+    int GetDescriptorCount() const {return m_train_feature_count;};
+
+    // CreateDescriptorsFromImage: creates descriptors for each of the input features
+    // - src: input image
+    // - features: input features
+    // - pyr_levels: the number of pyramid levels
+    void CreateDescriptorsFromImage(IplImage* src, const vector<KeyPoint>& features);
+
+    // CreatePCADescriptors: generates descriptors for PCA components, needed for fast generation of feature descriptors
+    void CreatePCADescriptors();
+
+    // returns a feature descriptor by feature index
+    const OneWayDescriptor* GetDescriptor(int desc_idx) const {return &m_descriptors[desc_idx];};
+
+    // FindDescriptor: finds the closest descriptor
+    // - patch: input image patch
+    // - desc_idx: output index of the closest descriptor to the input patch
+    // - pose_idx: output index of the closest pose of the closest descriptor to the input patch
+    // - distance: distance from the input patch to the closest feature pose
+    // - _scales: scales of the input patch for each descriptor
+    // - scale_ranges: input scales variation (float[2])
+    void FindDescriptor(IplImage* patch, int& desc_idx, int& pose_idx, float& distance, float* _scale = 0, float* scale_ranges = 0) const;
+
+    // - patch: input image patch
+    // - n: number of the closest indexes
+    // - desc_idxs: output indexes of the closest descriptor to the input patch (n)
+    // - pose_idx: output indexes of the closest pose of the closest descriptor to the input patch (n)
+    // - distances: distance from the input patch to the closest feature pose (n)
+    // - _scales: scales of the input patch
+    // - scale_ranges: input scales variation (float[2])
+    void FindDescriptor(IplImage* patch, int n, vector<int>& desc_idxs, vector<int>& pose_idxs,
+                        vector<float>& distances, vector<float>& _scales, float* scale_ranges = 0) const;
+
+    // FindDescriptor: finds the closest descriptor
+    // - src: input image
+    // - pt: center of the feature
+    // - desc_idx: output index of the closest descriptor to the input patch
+    // - pose_idx: output index of the closest pose of the closest descriptor to the input patch
+    // - distance: distance from the input patch to the closest feature pose
+    void FindDescriptor(IplImage* src, cv::Point2f pt, int& desc_idx, int& pose_idx, float& distance) const;
+
+    // InitializePoses: generates random poses
+    void InitializePoses();
+
+    // InitializeTransformsFromPoses: generates 2x3 affine matrices from poses (initializes m_transforms)
+    void InitializeTransformsFromPoses();
+
+    // InitializePoseTransforms: subsequently calls InitializePoses and InitializeTransformsFromPoses
+    void InitializePoseTransforms();
+
+    // InitializeDescriptor: initializes a descriptor
+    // - desc_idx: descriptor index
+    // - train_image: image patch (ROI is supported)
+    // - feature_label: feature textual label
+    void InitializeDescriptor(int desc_idx, IplImage* train_image, const char* feature_label);
+
+    void InitializeDescriptor(int desc_idx, IplImage* train_image, const KeyPoint& keypoint, const char* feature_label);
+
+    // InitializeDescriptors: load features from an image and create descriptors for each of them
+    void InitializeDescriptors(IplImage* train_image, const vector<KeyPoint>& features,
+                               const char* feature_label = "", int desc_start_idx = 0);
+
+    // Write: writes this object to a file storage
+    // - fs: output filestorage
+    void Write (FileStorage &fs) const;
+
+    // Read: reads OneWayDescriptorBase object from a file node
+    // - fn: input file node
+    void Read (const FileNode &fn);
+
+    // LoadPCADescriptors: loads PCA descriptors from a file
+    // - filename: input filename
+    int LoadPCADescriptors(const char* filename);
+
+    // LoadPCADescriptors: loads PCA descriptors from a file node
+    // - fn: input file node
+    int LoadPCADescriptors(const FileNode &fn);
+
+    // SavePCADescriptors: saves PCA descriptors to a file
+    // - filename: output filename
+    void SavePCADescriptors(const char* filename);
+
+    // SavePCADescriptors: saves PCA descriptors to a file storage
+    // - fs: output file storage
+    void SavePCADescriptors(CvFileStorage* fs) const;
+
+    // GeneratePCA: calculate and save PCA components and descriptors
+    // - img_path: path to training PCA images directory
+    // - images_list: filename with filenames of training PCA images
+    void GeneratePCA(const char* img_path, const char* images_list, int pose_count=500);
+
+    // SetPCAHigh: sets the high resolution pca matrices (copied to internal structures)
+    void SetPCAHigh(CvMat* avg, CvMat* eigenvectors);
+
+    // SetPCALow: sets the low resolution pca matrices (copied to internal structures)
+    void SetPCALow(CvMat* avg, CvMat* eigenvectors);
+
+    int GetLowPCA(CvMat** avg, CvMat** eigenvectors)
+    {
+        *avg = m_pca_avg;
+        *eigenvectors = m_pca_eigenvectors;
+        return m_pca_dim_low;
+    };
+
+    int GetPCADimLow() const {return m_pca_dim_low;};
+    int GetPCADimHigh() const {return m_pca_dim_high;};
+
+    void ConvertDescriptorsArrayToTree(); // Converting pca_descriptors array to KD tree
+
+    // GetPCAFilename: get default PCA filename
+    static string GetPCAFilename () { return "pca.yml"; }
+
+    virtual bool empty() const { return m_train_feature_count <= 0 ? true : false; }
+
+protected:
+    CvSize m_patch_size; // patch size
+    int m_pose_count; // the number of poses for each descriptor
+    int m_train_feature_count; // the number of the training features
+    OneWayDescriptor* m_descriptors; // array of train feature descriptors
+    CvMat* m_pca_avg; // PCA average Vector for small patches
+    CvMat* m_pca_eigenvectors; // PCA eigenvectors for small patches
+    CvMat* m_pca_hr_avg; // PCA average Vector for large patches
+    CvMat* m_pca_hr_eigenvectors; // PCA eigenvectors for large patches
+    OneWayDescriptor* m_pca_descriptors; // an array of PCA descriptors
+
+    cv::flann::Index* m_pca_descriptors_tree;
+    CvMat* m_pca_descriptors_matrix;
+
+    CvAffinePose* m_poses; // array of poses
+    CvMat** m_transforms; // array of affine transformations corresponding to poses
+
+    int m_pca_dim_high;
+    int m_pca_dim_low;
+
+    int m_pyr_levels;
+    float scale_min;
+    float scale_max;
+    float scale_step;
+
+    // SavePCAall: saves PCA components and descriptors to a file storage
+    // - fs: output file storage
+    void SavePCAall (FileStorage &fs) const;
+
+    // LoadPCAall: loads PCA components and descriptors from a file node
+    // - fn: input file node
+    void LoadPCAall (const FileNode &fn);
+};
+
+class CV_EXPORTS OneWayDescriptorObject : public OneWayDescriptorBase
+{
+public:
+    // creates an instance of OneWayDescriptorObject from a set of training files
+    // - patch_size: size of the input (large) patch
+    // - pose_count: the number of poses to generate for each descriptor
+    // - train_path: path to training files
+    // - pca_config: the name of the file that contains PCA for small patches (2 times smaller
+    // than patch_size each dimension
+    // - pca_hr_config: the name of the file that contains PCA for large patches (of patch_size size)
+    // - pca_desc_config: the name of the file that contains descriptors of PCA components
+    OneWayDescriptorObject(CvSize patch_size, int pose_count, const char* train_path, const char* pca_config,
+                           const char* pca_hr_config = 0, const char* pca_desc_config = 0, int pyr_levels = 1);
+
+    OneWayDescriptorObject(CvSize patch_size, int pose_count, const string &pca_filename,
+                           const string &train_path = string (), const string &images_list = string (),
+                           float _scale_min = 0.7f, float _scale_max=1.5f, float _scale_step=1.2f, int pyr_levels = 1);
+
+
+    virtual ~OneWayDescriptorObject();
+
+    // Allocate: allocates memory for a given number of features
+    // - train_feature_count: the total number of features
+    // - object_feature_count: the number of features extracted from the object
+    void Allocate(int train_feature_count, int object_feature_count);
+
+
+    void SetLabeledFeatures(const vector<KeyPoint>& features) {m_train_features = features;};
+    vector<KeyPoint>& GetLabeledFeatures() {return m_train_features;};
+    const vector<KeyPoint>& GetLabeledFeatures() const {return m_train_features;};
+    vector<KeyPoint> _GetLabeledFeatures() const;
+
+    // IsDescriptorObject: returns 1 if descriptor with specified index is positive, otherwise 0
+    int IsDescriptorObject(int desc_idx) const;
+
+    // MatchPointToPart: returns the part number of a feature if it matches one of the object parts, otherwise -1
+    int MatchPointToPart(CvPoint pt) const;
+
+    // GetDescriptorPart: returns the part number of the feature corresponding to a specified descriptor
+    // - desc_idx: descriptor index
+    int GetDescriptorPart(int desc_idx) const;
+
+
+    void InitializeObjectDescriptors(IplImage* train_image, const vector<KeyPoint>& features,
+                                     const char* feature_label, int desc_start_idx = 0, float scale = 1.0f,
+                                     int is_background = 0);
+
+    // GetObjectFeatureCount: returns the number of object features
+    int GetObjectFeatureCount() const {return m_object_feature_count;};
+
+protected:
+    int* m_part_id; // contains part id for each of object descriptors
+    vector<KeyPoint> m_train_features; // train features
+    int m_object_feature_count; // the number of the positive features
+
+};
+
+
+/*
+ *  OneWayDescriptorMatcher
+ */
+class OneWayDescriptorMatcher;
+typedef OneWayDescriptorMatcher OneWayDescriptorMatch;
+
+class CV_EXPORTS OneWayDescriptorMatcher : public GenericDescriptorMatcher
+{
+public:
+    class CV_EXPORTS Params
+    {
+    public:
+        static const int POSE_COUNT = 500;
+        static const int PATCH_WIDTH = 24;
+        static const int PATCH_HEIGHT = 24;
+        static float GET_MIN_SCALE() { return 0.7f; }
+        static float GET_MAX_SCALE() { return 1.5f; }
+        static float GET_STEP_SCALE() { return 1.2f; }
+
+        Params( int poseCount = POSE_COUNT,
+               Size patchSize = Size(PATCH_WIDTH, PATCH_HEIGHT),
+               string pcaFilename = string(),
+               string trainPath = string(), string trainImagesList = string(),
+               float minScale = GET_MIN_SCALE(), float maxScale = GET_MAX_SCALE(),
+               float stepScale = GET_STEP_SCALE() );
+
+        int poseCount;
+        Size patchSize;
+        string pcaFilename;
+        string trainPath;
+        string trainImagesList;
+
+        float minScale, maxScale, stepScale;
+    };
+
+    OneWayDescriptorMatcher( const Params& params=Params() );
+    virtual ~OneWayDescriptorMatcher();
+
+    void initialize( const Params& params, const Ptr<OneWayDescriptorBase>& base=Ptr<OneWayDescriptorBase>() );
+
+    // Clears keypoints storing in collection and OneWayDescriptorBase
+    virtual void clear();
+
+    virtual void train();
+
+    virtual bool isMaskSupported();
+
+    virtual void read( const FileNode &fn );
+    virtual void write( FileStorage& fs ) const;
+
+    virtual bool empty() const;
+
+    virtual Ptr<GenericDescriptorMatcher> clone( bool emptyTrainData=false ) const;
+
+protected:
+    // Matches a set of keypoints from a single image of the training set. A rectangle with a center in a keypoint
+    // and size (patch_width/2*scale, patch_height/2*scale) is cropped from the source image for each
+    // keypoint. scale is iterated from DescriptorOneWayParams::min_scale to DescriptorOneWayParams::max_scale.
+    // The minimum distance to each training patch with all its affine poses is found over all scales.
+    // The class ID of a match is returned for each keypoint. The distance is calculated over PCA components
+    // loaded with DescriptorOneWay::Initialize, kd tree is used for finding minimum distances.
+    virtual void knnMatchImpl( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                              vector<vector<DMatch> >& matches, int k,
+                              const vector<Mat>& masks, bool compactResult );
+    virtual void radiusMatchImpl( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                                 vector<vector<DMatch> >& matches, float maxDistance,
+                                 const vector<Mat>& masks, bool compactResult );
+
+    Ptr<OneWayDescriptorBase> base;
+    Params params;
+    int prevTrainCount;
+};
+
+/*
+ *  FernDescriptorMatcher
+ */
+class FernDescriptorMatcher;
+typedef FernDescriptorMatcher FernDescriptorMatch;
+
+class CV_EXPORTS FernDescriptorMatcher : public GenericDescriptorMatcher
+{
+public:
+    class CV_EXPORTS Params
+    {
+    public:
+        Params( int nclasses=0,
+               int patchSize=FernClassifier::PATCH_SIZE,
+               int signatureSize=FernClassifier::DEFAULT_SIGNATURE_SIZE,
+               int nstructs=FernClassifier::DEFAULT_STRUCTS,
+               int structSize=FernClassifier::DEFAULT_STRUCT_SIZE,
+               int nviews=FernClassifier::DEFAULT_VIEWS,
+               int compressionMethod=FernClassifier::COMPRESSION_NONE,
+               const PatchGenerator& patchGenerator=PatchGenerator() );
+
+        Params( const string& filename );
+
+        int nclasses;
+        int patchSize;
+        int signatureSize;
+        int nstructs;
+        int structSize;
+        int nviews;
+        int compressionMethod;
+        PatchGenerator patchGenerator;
+
+        string filename;
+    };
+
+    FernDescriptorMatcher( const Params& params=Params() );
+    virtual ~FernDescriptorMatcher();
+
+    virtual void clear();
+
+    virtual void train();
+
+    virtual bool isMaskSupported();
+
+    virtual void read( const FileNode &fn );
+    virtual void write( FileStorage& fs ) const;
+    virtual bool empty() const;
+
+    virtual Ptr<GenericDescriptorMatcher> clone( bool emptyTrainData=false ) const;
+
+protected:
+    virtual void knnMatchImpl( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                              vector<vector<DMatch> >& matches, int k,
+                              const vector<Mat>& masks, bool compactResult );
+    virtual void radiusMatchImpl( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                                 vector<vector<DMatch> >& matches, float maxDistance,
+                                 const vector<Mat>& masks, bool compactResult );
+
+    void trainFernClassifier();
+    void calcBestProbAndMatchIdx( const Mat& image, const Point2f& pt,
+                                 float& bestProb, int& bestMatchIdx, vector<float>& signature );
+    Ptr<FernClassifier> classifier;
+    Params params;
+    int prevTrainCount;
+};
+
+
+/*
+ * CalonderDescriptorExtractor
+ */
+template<typename T>
+class CV_EXPORTS CalonderDescriptorExtractor : public DescriptorExtractor
+{
+public:
+    CalonderDescriptorExtractor( const string& classifierFile );
+
+    virtual void read( const FileNode &fn );
+    virtual void write( FileStorage &fs ) const;
+
+    virtual int descriptorSize() const { return classifier_.classes(); }
+    virtual int descriptorType() const { return DataType<T>::type; }
+
+    virtual bool empty() const;
+
+protected:
+    virtual void computeImpl( const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors ) const;
+
+    RTreeClassifier classifier_;
+    static const int BORDER_SIZE = 16;
+};
+
+template<typename T>
+CalonderDescriptorExtractor<T>::CalonderDescriptorExtractor(const std::string& classifier_file)
+{
+    classifier_.read( classifier_file.c_str() );
+}
+
+template<typename T>
+void CalonderDescriptorExtractor<T>::computeImpl( const Mat& image,
+                                                 vector<KeyPoint>& keypoints,
+                                                 Mat& descriptors) const
+{
+    // Cannot compute descriptors for keypoints on the image border.
+    KeyPointsFilter::runByImageBorder(keypoints, image.size(), BORDER_SIZE);
+
+    /// @todo Check 16-byte aligned
+    descriptors.create((int)keypoints.size(), classifier_.classes(), cv::DataType<T>::type);
+
+    int patchSize = RandomizedTree::PATCH_SIZE;
+    int offset = patchSize / 2;
+    for (size_t i = 0; i < keypoints.size(); ++i)
+    {
+        cv::Point2f pt = keypoints[i].pt;
+        IplImage ipl = image( Rect((int)(pt.x - offset), (int)(pt.y - offset), patchSize, patchSize) );
+        classifier_.getSignature( &ipl, descriptors.ptr<T>((int)i));
+    }
+}
+
+template<typename T>
+void CalonderDescriptorExtractor<T>::read( const FileNode& )
+{}
+
+template<typename T>
+void CalonderDescriptorExtractor<T>::write( FileStorage& ) const
+{}
+
+template<typename T>
+bool CalonderDescriptorExtractor<T>::empty() const
+{
+    return classifier_.trees_.empty();
+}
+
+
+////////////////////// Brute Force Matcher //////////////////////////
+
+template<class Distance>
+class CV_EXPORTS BruteForceMatcher : public BFMatcher
+{
+public:
+    BruteForceMatcher( Distance d = Distance() ) : BFMatcher(Distance::normType, false) {(void)d;}
+    virtual ~BruteForceMatcher() {}
+};
+
+
+/****************************************************************************************\
+*                                Planar Object Detection                                 *
+\****************************************************************************************/
+
+class CV_EXPORTS PlanarObjectDetector
+{
+public:
+    PlanarObjectDetector();
+    PlanarObjectDetector(const FileNode& node);
+    PlanarObjectDetector(const vector<Mat>& pyr, int _npoints=300,
+                         int _patchSize=FernClassifier::PATCH_SIZE,
+                         int _nstructs=FernClassifier::DEFAULT_STRUCTS,
+                         int _structSize=FernClassifier::DEFAULT_STRUCT_SIZE,
+                         int _nviews=FernClassifier::DEFAULT_VIEWS,
+                         const LDetector& detector=LDetector(),
+                         const PatchGenerator& patchGenerator=PatchGenerator());
+    virtual ~PlanarObjectDetector();
+    virtual void train(const vector<Mat>& pyr, int _npoints=300,
+                       int _patchSize=FernClassifier::PATCH_SIZE,
+                       int _nstructs=FernClassifier::DEFAULT_STRUCTS,
+                       int _structSize=FernClassifier::DEFAULT_STRUCT_SIZE,
+                       int _nviews=FernClassifier::DEFAULT_VIEWS,
+                       const LDetector& detector=LDetector(),
+                       const PatchGenerator& patchGenerator=PatchGenerator());
+    virtual void train(const vector<Mat>& pyr, const vector<KeyPoint>& keypoints,
+                       int _patchSize=FernClassifier::PATCH_SIZE,
+                       int _nstructs=FernClassifier::DEFAULT_STRUCTS,
+                       int _structSize=FernClassifier::DEFAULT_STRUCT_SIZE,
+                       int _nviews=FernClassifier::DEFAULT_VIEWS,
+                       const LDetector& detector=LDetector(),
+                       const PatchGenerator& patchGenerator=PatchGenerator());
+    Rect getModelROI() const;
+    vector<KeyPoint> getModelPoints() const;
+    const LDetector& getDetector() const;
+    const FernClassifier& getClassifier() const;
+    void setVerbose(bool verbose);
+
+    void read(const FileNode& node);
+    void write(FileStorage& fs, const String& name=String()) const;
+    bool operator()(const Mat& image, CV_OUT Mat& H, CV_OUT vector<Point2f>& corners) const;
+    bool operator()(const vector<Mat>& pyr, const vector<KeyPoint>& keypoints,
+                    CV_OUT Mat& H, CV_OUT vector<Point2f>& corners,
+                    CV_OUT vector<int>* pairs=0) const;
+
+protected:
+    bool verbose;
+    Rect modelROI;
+    vector<KeyPoint> modelPoints;
+    LDetector ldetector;
+    FernClassifier fernClassifier;
+};
+
+}
+
+// 2009-01-12, Xavier Delacour <xavier.delacour@gmail.com>
+
+struct lsh_hash {
+    int h1, h2;
+};
+
+struct CvLSHOperations
+{
+    virtual ~CvLSHOperations() {}
+
+    virtual int vector_add(const void* data) = 0;
+    virtual void vector_remove(int i) = 0;
+    virtual const void* vector_lookup(int i) = 0;
+    virtual void vector_reserve(int n) = 0;
+    virtual unsigned int vector_count() = 0;
+
+    virtual void hash_insert(lsh_hash h, int l, int i) = 0;
+    virtual void hash_remove(lsh_hash h, int l, int i) = 0;
+    virtual int hash_lookup(lsh_hash h, int l, int* ret_i, int ret_i_max) = 0;
+};
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Splits color or grayscale image into multiple connected components
+ of nearly the same color/brightness using modification of Burt algorithm.
+ comp with contain a pointer to sequence (CvSeq)
+ of connected components (CvConnectedComp) */
+CVAPI(void) cvPyrSegmentation( IplImage* src, IplImage* dst,
+                              CvMemStorage* storage, CvSeq** comp,
+                              int level, double threshold1,
+                              double threshold2 );
+
+/****************************************************************************************\
+*                              Planar subdivisions                                       *
+\****************************************************************************************/
+
+/* Initializes Delaunay triangulation */
+CVAPI(void)  cvInitSubdivDelaunay2D( CvSubdiv2D* subdiv, CvRect rect );
+
+/* Creates new subdivision */
+CVAPI(CvSubdiv2D*)  cvCreateSubdiv2D( int subdiv_type, int header_size,
+                                     int vtx_size, int quadedge_size,
+                                     CvMemStorage* storage );
+
+/************************* high-level subdivision functions ***************************/
+
+/* Simplified Delaunay diagram creation */
+CV_INLINE  CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage )
+{
+    CvSubdiv2D* subdiv = cvCreateSubdiv2D( CV_SEQ_KIND_SUBDIV2D, sizeof(*subdiv),
+                                          sizeof(CvSubdiv2DPoint), sizeof(CvQuadEdge2D), storage );
+
+    cvInitSubdivDelaunay2D( subdiv, rect );
+    return subdiv;
+}
+
+
+/* Inserts new point to the Delaunay triangulation */
+CVAPI(CvSubdiv2DPoint*)  cvSubdivDelaunay2DInsert( CvSubdiv2D* subdiv, CvPoint2D32f pt);
+
+/* Locates a point within the Delaunay triangulation (finds the edge
+ the point is left to or belongs to, or the triangulation point the given
+ point coinsides with */
+CVAPI(CvSubdiv2DPointLocation)  cvSubdiv2DLocate(
+                                                 CvSubdiv2D* subdiv, CvPoint2D32f pt,
+                                                 CvSubdiv2DEdge* edge,
+                                                 CvSubdiv2DPoint** vertex CV_DEFAULT(NULL) );
+
+/* Calculates Voronoi tesselation (i.e. coordinates of Voronoi points) */
+CVAPI(void)  cvCalcSubdivVoronoi2D( CvSubdiv2D* subdiv );
+
+
+/* Removes all Voronoi points from the tesselation */
+CVAPI(void)  cvClearSubdivVoronoi2D( CvSubdiv2D* subdiv );
+
+
+/* Finds the nearest to the given point vertex in subdivision. */
+CVAPI(CvSubdiv2DPoint*) cvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f pt );
+
+
+/************ Basic quad-edge navigation and operations ************/
+
+CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DNextEdge( CvSubdiv2DEdge edge )
+{
+    return  CV_SUBDIV2D_NEXT_EDGE(edge);
+}
+
+
+CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DRotateEdge( CvSubdiv2DEdge edge, int rotate )
+{
+    return  (edge & ~3) + ((edge + rotate) & 3);
+}
+
+CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DSymEdge( CvSubdiv2DEdge edge )
+{
+    return edge ^ 2;
+}
+
+CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, CvNextEdgeType type )
+{
+    CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
+    edge = e->next[(edge + (int)type) & 3];
+    return  (edge & ~3) + ((edge + ((int)type >> 4)) & 3);
+}
+
+
+CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeOrg( CvSubdiv2DEdge edge )
+{
+    CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
+    return (CvSubdiv2DPoint*)e->pt[edge & 3];
+}
+
+
+CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeDst( CvSubdiv2DEdge edge )
+{
+    CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
+    return (CvSubdiv2DPoint*)e->pt[(edge + 2) & 3];
+}
+
+/****************************************************************************************\
+*                           Additional operations on Subdivisions                        *
+\****************************************************************************************/
+
+// paints voronoi diagram: just demo function
+CVAPI(void)  icvDrawMosaic( CvSubdiv2D* subdiv, IplImage* src, IplImage* dst );
+
+// checks planar subdivision for correctness. It is not an absolute check,
+// but it verifies some relations between quad-edges
+CVAPI(int)   icvSubdiv2DCheck( CvSubdiv2D* subdiv );
+
+// returns squared distance between two 2D points with floating-point coordinates.
+CV_INLINE double icvSqDist2D32f( CvPoint2D32f pt1, CvPoint2D32f pt2 )
+{
+    double dx = pt1.x - pt2.x;
+    double dy = pt1.y - pt2.y;
+
+    return dx*dx + dy*dy;
+}
+
+
+
+
+CV_INLINE  double  cvTriangleArea( CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c )
+{
+    return ((double)b.x - a.x) * ((double)c.y - a.y) - ((double)b.y - a.y) * ((double)c.x - a.x);
+}
+
+
+/* Constructs kd-tree from set of feature descriptors */
+CVAPI(struct CvFeatureTree*) cvCreateKDTree(CvMat* desc);
+
+/* Constructs spill-tree from set of feature descriptors */
+CVAPI(struct CvFeatureTree*) cvCreateSpillTree( const CvMat* raw_data,
+                                               const int naive CV_DEFAULT(50),
+                                               const double rho CV_DEFAULT(.7),
+                                               const double tau CV_DEFAULT(.1) );
+
+/* Release feature tree */
+CVAPI(void) cvReleaseFeatureTree(struct CvFeatureTree* tr);
+
+/* Searches feature tree for k nearest neighbors of given reference points,
+ searching (in case of kd-tree/bbf) at most emax leaves. */
+CVAPI(void) cvFindFeatures(struct CvFeatureTree* tr, const CvMat* query_points,
+                           CvMat* indices, CvMat* dist, int k, int emax CV_DEFAULT(20));
+
+/* Search feature tree for all points that are inlier to given rect region.
+ Only implemented for kd trees */
+CVAPI(int) cvFindFeaturesBoxed(struct CvFeatureTree* tr,
+                               CvMat* bounds_min, CvMat* bounds_max,
+                               CvMat* out_indices);
+
+
+/* Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
+ given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions. */
+CVAPI(struct CvLSH*) cvCreateLSH(struct CvLSHOperations* ops, int d,
+                                 int L CV_DEFAULT(10), int k CV_DEFAULT(10),
+                                 int type CV_DEFAULT(CV_64FC1), double r CV_DEFAULT(4),
+                                 int64 seed CV_DEFAULT(-1));
+
+/* Construct in-memory LSH table, with n bins. */
+CVAPI(struct CvLSH*) cvCreateMemoryLSH(int d, int n, int L CV_DEFAULT(10), int k CV_DEFAULT(10),
+                                       int type CV_DEFAULT(CV_64FC1), double r CV_DEFAULT(4),
+                                       int64 seed CV_DEFAULT(-1));
+
+/* Free the given LSH structure. */
+CVAPI(void) cvReleaseLSH(struct CvLSH** lsh);
+
+/* Return the number of vectors in the LSH. */
+CVAPI(unsigned int) LSHSize(struct CvLSH* lsh);
+
+/* Add vectors to the LSH structure, optionally returning indices. */
+CVAPI(void) cvLSHAdd(struct CvLSH* lsh, const CvMat* data, CvMat* indices CV_DEFAULT(0));
+
+/* Remove vectors from LSH, as addressed by given indices. */
+CVAPI(void) cvLSHRemove(struct CvLSH* lsh, const CvMat* indices);
+
+/* Query the LSH n times for at most k nearest points; data is n x d,
+ indices and dist are n x k. At most emax stored points will be accessed. */
+CVAPI(void) cvLSHQuery(struct CvLSH* lsh, const CvMat* query_points,
+                       CvMat* indices, CvMat* dist, int k, int emax);
+
+/* Kolmogorov-Zabin stereo-correspondence algorithm (a.k.a. KZ1) */
+#define CV_STEREO_GC_OCCLUDED  SHRT_MAX
+
+typedef struct CvStereoGCState
+{
+    int Ithreshold;
+    int interactionRadius;
+    float K, lambda, lambda1, lambda2;
+    int occlusionCost;
+    int minDisparity;
+    int numberOfDisparities;
+    int maxIters;
+
+    CvMat* left;
+    CvMat* right;
+    CvMat* dispLeft;
+    CvMat* dispRight;
+    CvMat* ptrLeft;
+    CvMat* ptrRight;
+    CvMat* vtxBuf;
+    CvMat* edgeBuf;
+} CvStereoGCState;
+
+CVAPI(CvStereoGCState*) cvCreateStereoGCState( int numberOfDisparities, int maxIters );
+CVAPI(void) cvReleaseStereoGCState( CvStereoGCState** state );
+
+CVAPI(void) cvFindStereoCorrespondenceGC( const CvArr* left, const CvArr* right,
+                                         CvArr* disparityLeft, CvArr* disparityRight,
+                                         CvStereoGCState* state,
+                                         int useDisparityGuess CV_DEFAULT(0) );
+
+/* Calculates optical flow for 2 images using classical Lucas & Kanade algorithm */
+CVAPI(void)  cvCalcOpticalFlowLK( const CvArr* prev, const CvArr* curr,
+                                 CvSize win_size, CvArr* velx, CvArr* vely );
+
+/* Calculates optical flow for 2 images using block matching algorithm */
+CVAPI(void)  cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr,
+                                 CvSize block_size, CvSize shift_size,
+                                 CvSize max_range, int use_previous,
+                                 CvArr* velx, CvArr* vely );
+
+/* Calculates Optical flow for 2 images using Horn & Schunck algorithm */
+CVAPI(void)  cvCalcOpticalFlowHS( const CvArr* prev, const CvArr* curr,
+                                 int use_previous, CvArr* velx, CvArr* vely,
+                                 double lambda, CvTermCriteria criteria );
+
+
+/****************************************************************************************\
+*                           Background/foreground segmentation                           *
+\****************************************************************************************/
+
+/* We discriminate between foreground and background pixels
+ * by building and maintaining a model of the background.
+ * Any pixel which does not fit this model is then deemed
+ * to be foreground.
+ *
+ * At present we support two core background models,
+ * one of which has two variations:
+ *
+ *  o CV_BG_MODEL_FGD: latest and greatest algorithm, described in
+ *
+ *	 Foreground Object Detection from Videos Containing Complex Background.
+ *	 Liyuan Li, Weimin Huang, Irene Y.H. Gu, and Qi Tian.
+ *	 ACM MM2003 9p
+ *
+ *  o CV_BG_MODEL_FGD_SIMPLE:
+ *       A code comment describes this as a simplified version of the above,
+ *       but the code is in fact currently identical
+ *
+ *  o CV_BG_MODEL_MOG: "Mixture of Gaussians", older algorithm, described in
+ *
+ *       Moving target classification and tracking from real-time video.
+ *       A Lipton, H Fujijoshi, R Patil
+ *       Proceedings IEEE Workshop on Application of Computer Vision pp 8-14 1998
+ *
+ *       Learning patterns of activity using real-time tracking
+ *       C Stauffer and W Grimson  August 2000
+ *       IEEE Transactions on Pattern Analysis and Machine Intelligence 22(8):747-757
+ */
+
+
+#define CV_BG_MODEL_FGD		0
+#define CV_BG_MODEL_MOG		1			/* "Mixture of Gaussians".	*/
+#define CV_BG_MODEL_FGD_SIMPLE	2
+
+struct CvBGStatModel;
+
+typedef void (CV_CDECL * CvReleaseBGStatModel)( struct CvBGStatModel** bg_model );
+typedef int (CV_CDECL * CvUpdateBGStatModel)( IplImage* curr_frame, struct CvBGStatModel* bg_model,
+                                             double learningRate );
+
+#define CV_BG_STAT_MODEL_FIELDS()                                               \
+int             type; /*type of BG model*/                                      \
+CvReleaseBGStatModel release;                                                   \
+CvUpdateBGStatModel update;                                                     \
+IplImage*       background;   /*8UC3 reference background image*/               \
+IplImage*       foreground;   /*8UC1 foreground image*/                         \
+IplImage**      layers;       /*8UC3 reference background image, can be null */ \
+int             layer_count;  /* can be zero */                                 \
+CvMemStorage*   storage;      /*storage for foreground_regions*/                \
+CvSeq*          foreground_regions /*foreground object contours*/
+
+typedef struct CvBGStatModel
+{
+    CV_BG_STAT_MODEL_FIELDS();
+} CvBGStatModel;
+
+//
+
+// Releases memory used by BGStatModel
+CVAPI(void) cvReleaseBGStatModel( CvBGStatModel** bg_model );
+
+// Updates statistical model and returns number of found foreground regions
+CVAPI(int) cvUpdateBGStatModel( IplImage* current_frame, CvBGStatModel*  bg_model,
+                               double learningRate CV_DEFAULT(-1));
+
+// Performs FG post-processing using segmentation
+// (all pixels of a region will be classified as foreground if majority of pixels of the region are FG).
+// parameters:
+//      segments - pointer to result of segmentation (for example MeanShiftSegmentation)
+//      bg_model - pointer to CvBGStatModel structure
+CVAPI(void) cvRefineForegroundMaskBySegm( CvSeq* segments, CvBGStatModel*  bg_model );
+
+/* Common use change detection function */
+CVAPI(int)  cvChangeDetection( IplImage*  prev_frame,
+                              IplImage*  curr_frame,
+                              IplImage*  change_mask );
+
+/*
+ Interface of ACM MM2003 algorithm
+ */
+
+/* Default parameters of foreground detection algorithm: */
+#define  CV_BGFG_FGD_LC              128
+#define  CV_BGFG_FGD_N1C             15
+#define  CV_BGFG_FGD_N2C             25
+
+#define  CV_BGFG_FGD_LCC             64
+#define  CV_BGFG_FGD_N1CC            25
+#define  CV_BGFG_FGD_N2CC            40
+
+/* Background reference image update parameter: */
+#define  CV_BGFG_FGD_ALPHA_1         0.1f
+
+/* stat model update parameter
+ * 0.002f ~ 1K frame(~45sec), 0.005 ~ 18sec (if 25fps and absolutely static BG)
+ */
+#define  CV_BGFG_FGD_ALPHA_2         0.005f
+
+/* start value for alpha parameter (to fast initiate statistic model) */
+#define  CV_BGFG_FGD_ALPHA_3         0.1f
+
+#define  CV_BGFG_FGD_DELTA           2
+
+#define  CV_BGFG_FGD_T               0.9f
+
+#define  CV_BGFG_FGD_MINAREA         15.f
+
+#define  CV_BGFG_FGD_BG_UPDATE_TRESH 0.5f
+
+/* See the above-referenced Li/Huang/Gu/Tian paper
+ * for a full description of these background-model
+ * tuning parameters.
+ *
+ * Nomenclature:  'c'  == "color", a three-component red/green/blue vector.
+ *                         We use histograms of these to model the range of
+ *                         colors we've seen at a given background pixel.
+ *
+ *                'cc' == "color co-occurrence", a six-component vector giving
+ *                         RGB color for both this frame and preceding frame.
+ *                             We use histograms of these to model the range of
+ *                         color CHANGES we've seen at a given background pixel.
+ */
+typedef struct CvFGDStatModelParams
+{
+    int    Lc;			/* Quantized levels per 'color' component. Power of two, typically 32, 64 or 128.				*/
+    int    N1c;			/* Number of color vectors used to model normal background color variation at a given pixel.			*/
+    int    N2c;			/* Number of color vectors retained at given pixel.  Must be > N1c, typically ~ 5/3 of N1c.			*/
+    /* Used to allow the first N1c vectors to adapt over time to changing background.				*/
+
+    int    Lcc;			/* Quantized levels per 'color co-occurrence' component.  Power of two, typically 16, 32 or 64.			*/
+    int    N1cc;		/* Number of color co-occurrence vectors used to model normal background color variation at a given pixel.	*/
+    int    N2cc;		/* Number of color co-occurrence vectors retained at given pixel.  Must be > N1cc, typically ~ 5/3 of N1cc.	*/
+    /* Used to allow the first N1cc vectors to adapt over time to changing background.				*/
+
+    int    is_obj_without_holes;/* If TRUE we ignore holes within foreground blobs. Defaults to TRUE.						*/
+    int    perform_morphing;	/* Number of erode-dilate-erode foreground-blob cleanup iterations.						*/
+    /* These erase one-pixel junk blobs and merge almost-touching blobs. Default value is 1.			*/
+
+    float  alpha1;		/* How quickly we forget old background pixel values seen.  Typically set to 0.1  				*/
+    float  alpha2;		/* "Controls speed of feature learning". Depends on T. Typical value circa 0.005. 				*/
+    float  alpha3;		/* Alternate to alpha2, used (e.g.) for quicker initial convergence. Typical value 0.1.				*/
+
+    float  delta;		/* Affects color and color co-occurrence quantization, typically set to 2.					*/
+    float  T;			/* "A percentage value which determines when new features can be recognized as new background." (Typically 0.9).*/
+    float  minArea;		/* Discard foreground blobs whose bounding box is smaller than this threshold.					*/
+} CvFGDStatModelParams;
+
+typedef struct CvBGPixelCStatTable
+{
+    float          Pv, Pvb;
+    uchar          v[3];
+} CvBGPixelCStatTable;
+
+typedef struct CvBGPixelCCStatTable
+{
+    float          Pv, Pvb;
+    uchar          v[6];
+} CvBGPixelCCStatTable;
+
+typedef struct CvBGPixelStat
+{
+    float                 Pbc;
+    float                 Pbcc;
+    CvBGPixelCStatTable*  ctable;
+    CvBGPixelCCStatTable* cctable;
+    uchar                 is_trained_st_model;
+    uchar                 is_trained_dyn_model;
+} CvBGPixelStat;
+
+
+typedef struct CvFGDStatModel
+{
+    CV_BG_STAT_MODEL_FIELDS();
+    CvBGPixelStat*         pixel_stat;
+    IplImage*              Ftd;
+    IplImage*              Fbd;
+    IplImage*              prev_frame;
+    CvFGDStatModelParams   params;
+} CvFGDStatModel;
+
+/* Creates FGD model */
+CVAPI(CvBGStatModel*) cvCreateFGDStatModel( IplImage* first_frame,
+                                           CvFGDStatModelParams* parameters CV_DEFAULT(NULL));
+
+/*
+ Interface of Gaussian mixture algorithm
+
+ "An improved adaptive background mixture model for real-time tracking with shadow detection"
+ P. KadewTraKuPong and R. Bowden,
+ Proc. 2nd European Workshp on Advanced Video-Based Surveillance Systems, 2001."
+ http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
+ */
+
+/* Note:  "MOG" == "Mixture Of Gaussians": */
+
+#define CV_BGFG_MOG_MAX_NGAUSSIANS 500
+
+/* default parameters of gaussian background detection algorithm */
+#define CV_BGFG_MOG_BACKGROUND_THRESHOLD     0.7     /* threshold sum of weights for background test */
+#define CV_BGFG_MOG_STD_THRESHOLD            2.5     /* lambda=2.5 is 99% */
+#define CV_BGFG_MOG_WINDOW_SIZE              200     /* Learning rate; alpha = 1/CV_GBG_WINDOW_SIZE */
+#define CV_BGFG_MOG_NGAUSSIANS               5       /* = K = number of Gaussians in mixture */
+#define CV_BGFG_MOG_WEIGHT_INIT              0.05
+#define CV_BGFG_MOG_SIGMA_INIT               30
+#define CV_BGFG_MOG_MINAREA                  15.f
+
+
+#define CV_BGFG_MOG_NCOLORS                  3
+
+typedef struct CvGaussBGStatModelParams
+{
+    int     win_size;               /* = 1/alpha */
+    int     n_gauss;
+    double  bg_threshold, std_threshold, minArea;
+    double  weight_init, variance_init;
+}CvGaussBGStatModelParams;
+
+typedef struct CvGaussBGValues
+{
+    int         match_sum;
+    double      weight;
+    double      variance[CV_BGFG_MOG_NCOLORS];
+    double      mean[CV_BGFG_MOG_NCOLORS];
+} CvGaussBGValues;
+
+typedef struct CvGaussBGPoint
+{
+    CvGaussBGValues* g_values;
+} CvGaussBGPoint;
+
+
+typedef struct CvGaussBGModel
+{
+    CV_BG_STAT_MODEL_FIELDS();
+    CvGaussBGStatModelParams   params;
+    CvGaussBGPoint*            g_point;
+    int                        countFrames;
+    void*                      mog;
+} CvGaussBGModel;
+
+
+/* Creates Gaussian mixture background model */
+CVAPI(CvBGStatModel*) cvCreateGaussianBGModel( IplImage* first_frame,
+                                              CvGaussBGStatModelParams* parameters CV_DEFAULT(NULL));
+
+
+typedef struct CvBGCodeBookElem
+{
+    struct CvBGCodeBookElem* next;
+    int tLastUpdate;
+    int stale;
+    uchar boxMin[3];
+    uchar boxMax[3];
+    uchar learnMin[3];
+    uchar learnMax[3];
+} CvBGCodeBookElem;
+
+typedef struct CvBGCodeBookModel
+{
+    CvSize size;
+    int t;
+    uchar cbBounds[3];
+    uchar modMin[3];
+    uchar modMax[3];
+    CvBGCodeBookElem** cbmap;
+    CvMemStorage* storage;
+    CvBGCodeBookElem* freeList;
+} CvBGCodeBookModel;
+
+CVAPI(CvBGCodeBookModel*) cvCreateBGCodeBookModel( void );
+CVAPI(void) cvReleaseBGCodeBookModel( CvBGCodeBookModel** model );
+
+CVAPI(void) cvBGCodeBookUpdate( CvBGCodeBookModel* model, const CvArr* image,
+                               CvRect roi CV_DEFAULT(cvRect(0,0,0,0)),
+                               const CvArr* mask CV_DEFAULT(0) );
+
+CVAPI(int) cvBGCodeBookDiff( const CvBGCodeBookModel* model, const CvArr* image,
+                            CvArr* fgmask, CvRect roi CV_DEFAULT(cvRect(0,0,0,0)) );
+
+CVAPI(void) cvBGCodeBookClearStale( CvBGCodeBookModel* model, int staleThresh,
+                                   CvRect roi CV_DEFAULT(cvRect(0,0,0,0)),
+                                   const CvArr* mask CV_DEFAULT(0) );
+
+CVAPI(CvSeq*) cvSegmentFGMask( CvArr *fgmask, int poly1Hull0 CV_DEFAULT(1),
+                              float perimScale CV_DEFAULT(4.f),
+                              CvMemStorage* storage CV_DEFAULT(0),
+                              CvPoint offset CV_DEFAULT(cvPoint(0,0)));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* End of file. */
diff --git a/thirdparty/includes/OpenCV/opencv2/legacy/streams.hpp b/thirdparty/includes/OpenCV/opencv2/legacy/streams.hpp
new file mode 100644
index 0000000..e164bf4
--- /dev/null
+++ b/thirdparty/includes/OpenCV/opencv2/legacy/streams.hpp
@@ -0,0 +1,92 @@
+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_CVSTREAMS_H__
+#define __OPENCV_CVSTREAMS_H__
+
+#ifdef WIN32
+#include <streams.h>  /* !!! IF YOU'VE GOT AN ERROR HERE, PLEASE READ BELOW !!! */
+/***************** How to get Visual Studio understand streams.h ****************\
+
+You need DirectShow SDK that is now a part of Platform SDK
+(Windows Server 2003 SP1 SDK or later),
+and DirectX SDK (2006 April or later).
+
+1. Download the Platform SDK from
+   http://www.microsoft.com/msdownload/platformsdk/sdkupdate/
+   and DirectX SDK from msdn.microsoft.com/directx/
+   (They are huge, but you can download it by parts).
+   If it doesn't work for you, consider HighGUI that can capture video via VFW or MIL
+
+2. Install Platform SDK together with DirectShow SDK.
+   Install DirectX (with or without sample code).
+
+3. Build baseclasses.
+   See <PlatformSDKInstallFolder>\samples\multimedia\directshow\readme.txt.
+
+4. Copy the built libraries (called strmbase.lib and strmbasd.lib
+   in Release and Debug versions, respectively) to
+   <PlatformSDKInstallFolder>\lib.
+
+5. In Developer Studio add the following paths:
+      <DirectXSDKInstallFolder>\include
+      <PlatformSDKInstallFolder>\include
+      <PlatformSDKInstallFolder>\samples\multimedia\directshow\baseclasses
+    to the includes' search path
+    (at Tools->Options->Directories->Include files in case of Visual Studio 6.0,
+     at Tools->Options->Projects and Solutions->VC++ Directories->Include files in case
+     of Visual Studio 2005)
+   Add
+      <DirectXSDKInstallFolder>\lib
+      <PlatformSDKInstallFolder>\lib
+   to the libraries' search path (in the same dialog, ...->"Library files" page)
+
+   NOTE: PUT THE ADDED LINES ON THE VERY TOP OF THE LISTS, OTHERWISE YOU MAY STILL GET
+   COMPILER OR LINKER ERRORS. This is necessary, because Visual Studio
+   may include older versions of the same headers and libraries.
+
+6. Now you can build OpenCV DirectShow filters.
+
+\***********************************************************************************/
+
+#endif
+
+#endif