what is this error?: able to solve?

by: Infinity08Posted on 2009-08-10 at 05:52:57ID: 25059443

It means that at the specified line in the specified source file, an assignment is done of an errno_t value to a char*, and the compiler doesn't know how to do that (it's not a valid conversion).

by: gen12324Posted on 2009-08-10 at 06:02:15ID: 25059503

So how am i suppose to solve it? hmmm... when i click on the error, it open another files which is not created by me. File name: CVVIDSURV.hpp

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        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 __CVVIDEOSURVEILLANCE_H__
#define __CVVIDEOSURVEILLANCE_H__
 
/* Turn off the functionality until cvaux/src/Makefile.am gets updated: */
//#if _MSC_VER >= 1200
 
#include <stdio.h>
 
#if _MSC_VER >= 1200 || defined __BORLANDC__
#define cv_stricmp stricmp
#define cv_strnicmp strnicmp
#elif defined __GNUC__
#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()
    {
        m_pNickName = NULL;
        m_pParamList = NULL;
        m_pModuleTypeName = NULL;
        m_pModuleName = NULL;
        m_Wnd = 0;
        AddParam("DebugWnd",&m_Wnd);
    }
    virtual ~CvVSModule()
    {
        CvDefParam* p = m_pParamList;
        for(;p;)
        {
            CvDefParam* pf = p;
            p=p->next;
            FreeParam(&pf);
        }
        m_pParamList=NULL;
        if(m_pModuleTypeName)free(m_pModuleTypeName);
        if(m_pModuleName)free(m_pModuleName);
    }
private: /* Internal functions: */
    void    FreeParam(CvDefParam** pp)
    {
        CvDefParam* p = pp[0];
        if(p->Str)free(p->Str);
        if(p->pName)free(p->pName);
        if(p->pComment)free(p->pComment);
        cvFree((void**)pp);
    }
    CvDefParam* NewParam(const char* name)
    {
        CvDefParam* pNew = (CvDefParam*)cvAlloc(sizeof(CvDefParam));
        memset(pNew,0,sizeof(CvDefParam));
        pNew->pName = _strdup(name);
        if(m_pParamList==NULL)
        {
            m_pParamList = pNew;
        }
        else
        {
            CvDefParam* p = m_pParamList;
            for(;p->next;p=p->next);
            p->next = pNew;
        }
        return pNew;
    };
 
    CvDefParam* GetParamPtr(int index)
    {
        CvDefParam* p = m_pParamList;
        for(;index>0 && p;index--,p=p->next);
        return p;
    }
    CvDefParam* GetParamPtr(const char* name)
    {
        CvDefParam* p = m_pParamList;
        for(;p;p=p->next)
        {
            if(_stricmp(p->pName,name)==0) break;
        }
        return p;
    }
protected: /* INTERNAL INTERFACE */
    int  IsParam(const char* name)
    {
        return GetParamPtr(name)?1:0;
    };
    void AddParam(const char* name, double* pAddr)
    {
        NewParam(name)->pDouble = pAddr;
    };
    void AddParam(const char* name, float* pAddr)
    {
        NewParam(name)->pFloat=pAddr;
    };
    void AddParam(const char* name, int* pAddr)
    {
        NewParam(name)->pInt=pAddr;
    };
    void AddParam(const char* name, char** pAddr)
    {
        CvDefParam* pP = NewParam(name);
        char* p = pAddr?pAddr[0]:NULL;
        pP->pStr = pAddr?pAddr:&(pP->Str);
        if(p)
        {
            pP->Str = _strdup(p);
            pP->pStr[0] = pP->Str;
        }
    };
    void AddParam(const char* name)
    {
        CvDefParam* p = NewParam(name);
        p->pDouble = &p->Double;
    };
    void CommentParam(const char* name, const char* pComment)
    {
        CvDefParam* p = GetParamPtr(name);
        if(p)p->pComment = pComment ? _strdup(pComment) : 0;
    };
    void SetTypeName(const char* name){m_pModuleTypeName = _strdup(name);}
    void SetModuleName(const char* name){m_pModuleName = _strdup(name);}
    void DelParam(const char* name)
    {
        CvDefParam* p = m_pParamList;
        CvDefParam* pPrev = NULL;
        for(;p;p=p->next)
        {
            if(_stricmp(p->pName,name)==0) break;
            pPrev = p;
        }
        if(p)
        {
            if(pPrev)
            {
                pPrev->next = p->next;
            }
            else
            {
                m_pParamList = p->next;
            }
            FreeParam(&p);
        }
    }/* DelParam */
 
public: /* EXTERNAL INTERFACE */
    char* GetParamName(int index)
    {
        CvDefParam* p = GetParamPtr(index);
        return p?p->pName:NULL;
    }
    char* GetParamComment(const char* name)
    {
        CvDefParam* p = GetParamPtr(name);
        if(p && p->pComment) return p->pComment;
        return NULL;
    }
    double GetParam(const char* name)
    {
        CvDefParam* p = GetParamPtr(name);
        if(p)
        {
            if(p->pDouble) return p->pDouble[0];
            if(p->pFloat) return p->pFloat[0];
            if(p->pInt) return p->pInt[0];
        }
        return 0;
    };
 
    const char* GetParamStr(const char* name)
    {
        CvDefParam* p = GetParamPtr(name);
        return p?p->Str:NULL;
    }
    void   SetParam(const char* name, double val)
    {
        CvDefParam* p = m_pParamList;
        for(;p;p=p->next)
        {
            if(_stricmp(p->pName,name) != 0) continue;
            if(p->pDouble)p->pDouble[0] = val;
            if(p->pFloat)p->pFloat[0] = (float)val;
            if(p->pInt)p->pInt[0] = cvRound(val);
        }
    }
    void   SetParamStr(const char* name, const char* str)
    {
        CvDefParam* p = m_pParamList;
        for(; p; p=p->next)
        {
            if(_stricmp(p->pName,name) != 0) continue;
            if(p->pStr)
            {
                if(p->Str)free(p->Str);
                p->Str = NULL;
                if(str)p->Str = _strdup(str);
                p->pStr[0] = p->Str;
            }
        }
        /* Convert to double and set: */
        if(str) SetParam(name,atof(str));
    }
    void TransferParamsFromChild(CvVSModule* pM, char* prefix = NULL)
    {
        char    tmp[1024];
        char*   FN = NULL;
        int i;
        for(i=0;;++i)
        {
            char* N = pM->GetParamName(i);
            if(N == NULL) break;
            FN = N;
            if(prefix)
            {
                strcpy_s(tmp,prefix);
                strcat_s(tmp,"_");
                FN = strcat_s(tmp,N);
            }
 
            if(!IsParam(FN))
            {
                if(pM->GetParamStr(N))
                {
                    AddParam(FN,(char**)NULL);
                }
                else
                {
                    AddParam(FN);
                }
            }
            if(pM->GetParamStr(N))
            {
                const char* val = pM->GetParamStr(N);
                SetParamStr(FN,val);
            }
            else
            {
                double val = pM->GetParam(N);
                SetParam(FN,val);
            }
            CommentParam(FN, pM->GetParamComment(N));
        }/* transfer next param */
    }/* Transfer params */
 
    void TransferParamsToChild(CvVSModule* pM, char* prefix = NULL)
    {
        char    tmp[1024];
        int i;
        for(i=0;;++i)
        {
            char* N = pM->GetParamName(i);
            if(N == NULL) break;
            if(prefix)
            {
                strcpy_s(tmp,prefix);
                strcat_s(tmp,"_");
                strcat_s(tmp,N);
            }
            else
            {
                strcpy_s(tmp,N);
            }
 
            if(IsParam(tmp))
            {
                if(GetParamStr(tmp))
                    pM->SetParamStr(N,GetParamStr(tmp));
                else
                    pM->SetParam(N,GetParam(tmp));
            }
        }/* Transfer next parameter */
        pM->ParamUpdate();
    }/* Transfer params */
 
    virtual void ParamUpdate(){};
    const char*   GetTypeName()
    {
        return m_pModuleTypeName;
    }
    int     IsModuleTypeName(const char* name)
    {
        return m_pModuleTypeName?(_stricmp(m_pModuleTypeName,name)==0):0;
    }
    char*   GetModuleName()
    {
        return m_pModuleName;
    }
    int     IsModuleName(const char* name)
    {
        return m_pModuleName?(_stricmp(m_pModuleName,name)==0):0;
    }
    void SetNickName(const char* pStr)
    {
        if(m_pNickName)
            free(m_pNickName);
 
        m_pNickName = NULL;
 
        if(pStr)
            m_pNickName = _strdup(pStr);
    }
    const char* GetNickName()
    {
        return m_pNickName ? m_pNickName : "unknown";
    }
    virtual void SaveState(CvFileStorage*){};
    virtual void LoadState(CvFileStorage*, CvFileNode*){};
 
    virtual void Release() = 0;
};/* CvVMModule */
void inline cvWriteStruct(CvFileStorage* fs, const char* name, void* addr, char* desc, int num=1)
{
    cvStartWriteStruct(fs,name,CV_NODE_SEQ|CV_NODE_FLOW);
    cvWriteRawData(fs,addr,num,desc);
    cvEndWriteStruct(fs);
}
void inline cvReadStructByName(CvFileStorage* fs, CvFileNode* node, const char* name, void* addr, char* desc)
{
    CvFileNode* pSeqNode = cvGetFileNodeByName(fs, node, name);
    if(pSeqNode==NULL)
    {
        printf("WARNING!!! Can't read structure %s\n",name);
    }
    else
    {
        if(CV_NODE_IS_SEQ(pSeqNode->tag))
        {
            cvReadRawData( fs, pSeqNode, addr, desc );
        }
        else
        {
            printf("WARNING!!! Structure %s is not sequence and can not be read\n",name);
        }
    }
}
 
 
/* FOREGROUND DETECTOR INTERFACE */
class CV_EXPORTS CvFGDetector: public CvVSModule
{
public:
    virtual IplImage* GetMask() = 0;
    /* Process current image: */
    virtual void    Process(IplImage* pImg) = 0;
    /* Release foreground detector: */
    virtual void    Release() = 0;
};
inline void cvReleaseFGDetector(CvFGDetector** ppT )
{
    ppT[0]->Release();
    ppT[0] = 0;
}
/* FOREGROUND DETECTOR INTERFACE */
 
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_s(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(char* str){strcat_s(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))
    {
        m_pMem = cvCreateMemStorage();
        m_pSeq = cvCreateSeq(0,sizeof(CvSeq),TrackSize,m_pMem);
    }
    virtual ~CvBlobTrackSeq()
    { 
        Clear();
        cvReleaseMemStorage(&m_pMem);
    };
    virtual CvBlobTrack* GetBlobTrack(int TrackIndex)
    {
        return (CvBlobTrack*)cvGetSeqElem(m_pSeq,TrackIndex);
    };
    virtual CvBlobTrack* GetBlobTrackByID(int TrackID)
    {
        int i;
        for(i=0; i<m_pSeq->total; ++i)
        {
            CvBlobTrack* pP = GetBlobTrack(i);
            if(pP && pP->TrackID == TrackID)
                return pP;
        }
        return NULL;
    };
    virtual void DelBlobTrack(int TrackIndex)
    {
        CvBlobTrack* pP = GetBlobTrack(TrackIndex);
        if(pP && pP->pBlobSeq) delete pP->pBlobSeq;
        cvSeqRemove(m_pSeq,TrackIndex);
    };
    virtual void DelBlobTrackByID(int TrackID)
    {
        int i;
        for(i=0; i<m_pSeq->total; ++i)
        {
            CvBlobTrack* pP = GetBlobTrack(i);
            if(TrackID == pP->TrackID)
            {
                DelBlobTrack(i);
                return;
            }
        }
    };
    virtual void Clear()
    {
        int i;
        for(i=GetBlobTrackNum();i>0;i--)
        {
            DelBlobTrack(i-1);
        }
        cvClearSeq(m_pSeq);
    };
    virtual void AddBlobTrack(int TrackID, int StartFrame = 0)
    {
        CvBlobTrack N;
        N.TrackID = TrackID;
        N.StartFrame = StartFrame;
        N.pBlobSeq = new CvBlobSeq;
        cvSeqPush(m_pSeq,&N);
    };
    virtual int GetBlobTrackNum()
    {
        return m_pSeq->total;
    };
protected:
    CvMemStorage*   m_pMem;
    CvSeq*          m_pSeq;
};
 
/* simple TRACKLIST */
 
 
/* BLOB DETECTOR INTERFACE */
class CV_EXPORTS CvBlobDetector: public CvVSModule
{
public:
    /* 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: */
inline void cvReleaseBlobDetector(CvBlobDetector** ppBD)
{
    ppBD[0]->Release();
    ppBD[0] = NULL;
}
/* END BLOB DETECTOR INTERFACE */
 
/* 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 false; }
 
    /* Return min detector window size: */
    CvSize GetMinWindowSize() const { return cvSize(0,0); }
    
    /* Return max border: */
    int GetMaxBorderSize() const { return 0; }
 
    /*
     * 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:
    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(){SetTypeName("BlobTracker");};
 
    /* 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)
    {
        CvBlob* pB;
        int ID = 0;
        assert(pBlob);
        //pBlob->ID;
        pB = GetBlob(BlobIndex);
        if(pB)
            pBlob[0] = pB[0];
        pBlob->ID = ID;
    };
 
    /* Get confidence/wieght/probability (0-1) for blob: */
    virtual double  GetConfidence(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL)
    {
        return 1;
    };
 
    virtual double GetConfidenceList(CvBlobSeq* pBlobList, IplImage* pImg, IplImage* pImgFG = NULL)
    {
        int     b,bN = pBlobList->GetBlobNum();
        double  W = 1;
        for(b=0;b<bN;++b)
        {
            CvBlob* pB = pBlobList->GetBlob(b);
            int     BI = GetBlobIndexByID(pB->ID);
            W *= GetConfidence(BI,pB,pImg,pImgFG);
        }
        return W;
    };
 
    virtual void UpdateBlob(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL){};
 
    /* Update all blob models: */
    virtual void Update(IplImage* pImg, IplImage* pImgFG = NULL)
    {
        int i;
        for(i=GetBlobNum();i>0;i--)
        {
            CvBlob* pB=GetBlob(i-1);
            UpdateBlob(i-1, pB, pImg, pImgFG);
        }
 
    };
 
    /* Return pointer to blob by its unique ID: */
    virtual int     GetBlobIndexByID(int BlobID)
    {
        int i;
        for(i=GetBlobNum();i>0;i--)
        {
            CvBlob* pB=GetBlob(i-1);
            if(CV_BLOB_ID(pB) == BlobID) return i-1;
        }
        return -1;
    };
 
    /* Return pointer to blob by its unique ID: */
    virtual CvBlob* GetBlobByID(int BlobID){return GetBlob(GetBlobIndexByID(BlobID));};
 
    /* Delete blob by its ID: */
    virtual void    DelBlobByID(int BlobID){DelBlob(GetBlobIndexByID(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)
    {
        SetBlob(GetBlobIndexByID(BlobID),pBlob);
    };
 
    /*  ===============  MULTI HYPOTHESIS INTERFACE ==================  */
 
    /* Return number of position hyposetis of currently tracked blob: */
    virtual int     GetBlobHypNum(int /*BlobIdx*/){return 1;};
 
    /* Return pointer to specified blob hypothesis by index blob: */
    virtual CvBlob* GetBlobHyp(int BlobIndex, int /*hypothesis*/){return GetBlob(BlobIndex);};
 
    /* Set new parameters for specified (by index) blob hyp
     * (can be called several times for each hyp ):
     */
    virtual void    SetBlobHyp(int /*BlobIndex*/, CvBlob* /*pBlob*/){};
};
inline void cvReleaseBlobTracker(CvBlobTracker**ppT )
{
    ppT[0]->Release();
    ppT[0] = 0;
}
/* 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:
    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:
    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:
    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:
    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 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:
    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:
    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 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, CvRandState* 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. */

Select all Open in new window

by: Infinity08Posted on 2009-08-10 at 06:12:43ID: 25059583

>> when i click on the error, it open another files which is not created by me. File name: CVVIDSURV.hpp

That's what the error message indicated :

>> 1>c:\program files\opencv\cvaux\include\cvvidsurv.hpp(285)

The error was detected in file cvvidsurv.hpp at line 285.

Line 285 is this :

>> FN = strcat_s(tmp,N);

strcat_s returns an errno_t :

http://msdn.microsoft.com/en-us/library/d45bbxx4%28VS.80%29.aspx

but FN is defined as a char* :

>> char* FN = NULL;

It seems that a normal strcat call has been replaced by a strcat_s call without making up for the differences in how they are called.
Or, the code was written for a different platform.

Where did you get that code ?

by: gen12324Posted on 2009-08-10 at 06:18:34ID: 25059631

Sorry.. By right it was strcat call in the first place. Because before this error( FN = strcat_s(tmp,N);
), it shows this error(strcat) have to use _s so therefore i changed it.

by: Infinity08Posted on 2009-08-10 at 06:33:38ID: 25059745

>> it shows this error(strcat) have to use _s so therefore i changed it.

That wasn't an error. It was a warning put in by MS Visual C++ to promote its own non-standard functions.

You can safely ignore the warning :)

by: Infinity08Posted on 2009-08-10 at 06:36:00ID: 25059766

So, if you revert to strcat, and ignore the warning about strcat_s, it should work better.

by: gen12324Posted on 2009-08-10 at 06:56:02ID: 25059898

oh i see... but it seems like i still cannot get through it.

by: gen12324Posted on 2009-08-10 at 06:57:23ID: 25059918

i having this error.

1>optical flow.obj : error LNK2019: unresolved external symbol _cvCreateGaussianBGModel referenced in function _main
1>C:\Documents and Settings\Others\My Documents\Visual Studio 2008\Projects\optical flow\Debug\optical flow.exe : fatal error LNK1120: 1 unresolved externals

by: gen12324Posted on 2009-08-10 at 06:58:09ID: 25059922

Anyway i got to go soon.. Can you tell me all possible ans and ways then, later in the morning i will try it out again. Thanks.

by: Infinity08Posted on 2009-08-10 at 07:01:04ID: 25059951

>> 1>optical flow.obj : error LNK2019: unresolved external symbol _cvCreateGaussianBGModel referenced in function _main

That is because you haven't linked in the library that contains that specific symbol.

>> Can you tell me all possible ans and ways then, later in the morning i will try it out again.

That's fine. But if your original question has been answered, then you should probably close this question.

If you then have further problems, you can open new question(s) for those.

by: gen12324Posted on 2009-08-10 at 07:11:42ID: 25060021

hmm.. i think my original question is linked to this. So you mean which library files i have link yet?

by: Infinity08Posted on 2009-08-10 at 07:15:34ID: 25060066

The original question was about what the cause of the C2440 error was. That was answered, and you should no longer have that error.

What you have now is a completely different error, and is due to not linking to the library (add the library file in the linker settings of your project).

by: gen12324Posted on 2009-08-10 at 18:05:44ID: 25065492

oh ok. Thanks. Hopefully you can help me again.

by: gen12324Posted on 2009-08-10 at 18:21:15ID: 31613680

Hopefully you can help me again! Thanks for your help!

by: Infinity08Posted on 2009-08-10 at 22:22:22ID: 25066320

The reason we like questions to stay on topic, is to ensure the quality of the PAQ database. If someone looks for an answer to a certain question, we want them to easily find it. Splitting up different questions is one way to ensure that :)

by: gen12324Posted on 2009-08-10 at 22:40:07ID: 25066379

i see. ok thanks for the remainder. Can help me solve other question?

by: Infinity08Posted on 2009-08-10 at 22:47:08ID: 25066415

I see that another expert is already helping you, so unless that doesn't lead to anything, I'll hold off for now. But I am monitoring it :)

Question

what is this error?

Subscribe now for full access to Experts Exchange and get

Instant Access to this Solution

able to solve?

Microsoft Visual C++

Windows Programming

Algorithms

Trusted by hundreds of thousands everyday for fast, accurate and reliable tech support.

See what Experts Exchange can do for you.

Got a question?

We've got the answer.

Need individual assistance?

Our experts are ready to help.

Want to learn from the best?

Read articles from industry experts.

Working on a long term project?

Store your work and research.

What Makes Experts Exchange Unique?

Trusted by the world's most respected brands.

Faithfully serving IT professionals since 1996.

Related Solutions

Free Tech Articles

Cloud Class Webinars

Join the Community

Give a Little. Get a Lot.

Answers

3 Ways to Join

The Experts

The Experts

Testimonials

Testimonials

Testimonials

Business Clients

Business Clients

In the Press

In the Press

In the Press