gen12324
asked on
what is this error?
May i know what causes this error?
1>c:\program files\opencv\cvaux\include \cvvidsurv .hpp(285) : error C2440: '=' : cannot convert from 'errno_t' to 'char *'
Below are the codes i got it from website
1>c:\program files\opencv\cvaux\include
Below are the codes i got it from website
#include "stdafx.h"
#include "cv.h"
#include "cvaux.h"
#include "highgui.h"
#include <ctype.h>
#include <stdio.h>
IplImage *frame1 = NULL, *frame2 = NULL, *frame3 = NULL;
IplImage *diff1 = NULL, *diff2 = NULL, *result = NULL;
IplImage* cannyImg;
IplImage *grayImg = 0; // gray image
int main(int argc, char** argv)
{
int height,width,step,channels;
uchar *data1, *data2, *data3, *diffData1, *diffData2, *resultData;
int i, j;
int threshold = 30;
int diff;
/* Start capturing */
CvCapture* capture = 0;
/*capturing from cam
if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 &&
isdigit(argv[1][0])))
capture = cvCaptureFromCAM( argc == 2 ? argv[1][0] - '0' : 0 );
else if( argc == 2 )
capture = cvCaptureFromAVI( argv[1] );
*/
capture = cvCaptureFromAVI( "car.avi" );
int mode = CV_RETR_EXTERNAL;
mode = CV_RETR_CCOMP; //detect both outside and inside contour
if( !capture )
{
fprintf(stderr,"Could not initialize...\n");
return -1;
}
/* Capture 1 video frame for initialization */
frame2 = cvQueryFrame(capture); // retrive from the video
frame3 = cvQueryFrame(capture);
/* Create windows */
cvNamedWindow("Actual Video", 1); // creating window
cvNamedWindow("With Differencing", 1);
cvMoveWindow("With Differencing", 500,0);
cvNamedWindow("BackGround", 1);
cvMoveWindow("BackGround", 0,350);
cvNamedWindow("canny Edge",1);
cvMoveWindow("canny Edge", 750, 350);
CvBGStatModel* bg_model;
bg_model =cvCreateGaussianBGModel( frame2 );
/* Get properties of frame */
width = frame2->width;
height = frame2->height;
step = frame2->widthStep;
channels = frame2->nChannels;
int key=-1;
while(key != 'q')
{
/* Get consecutive frames */
frame1 = cvCloneImage(frame2);
// cvReleaseData(frame2);
// cvReleaseImage(&frame2);
frame2 = cvCloneImage(frame3);
// cvReleaseData(frame3);
// cvReleaseImage(&frame);
frame3 = cvQueryFrame(capture);
/* Initialize difference and result frames */
diff1 = cvCloneImage(frame3);
diff2 = cvCloneImage(frame3);
result = cvCloneImage(frame3);
/* Image is treated as as unsigned char data hence we use an
unsigned char pointer to point to the same to access pixels */
data1 = (uchar *)frame1->imageData;
data2 = (uchar *)frame2->imageData;
data3 = (uchar *)frame2->imageData;
diffData1 = (uchar *)diff1->imageData;
diffData2 = (uchar *)diff2->imageData;
resultData = (uchar *)result->imageData;
/* Get difference of frames */
cvAbsDiff(frame2,frame1,diff1);
cvAbsDiff(frame3,frame2,diff2);
cvUpdateBGStatModel( frame2, bg_model );
// canny edge detection
// Check for threshold
for(i=0;i<=height-1;i++)
{
for(j=0;j<=width-1;j++)
{
//Difference depends on sum of pixels on each channel
if(((diffData1[i*step+j*channels+0] +
diffData1[i*step+j*channels+1] + diffData1[i*step+j*channels+2]) >
threshold) && ((diffData2[i*step+j*channels+0] +
diffData2[i*step+j*channels+1] + diffData2[i*step+j*channels+2]) >
threshold))
{
resultData[i*step+j*channels+0] = 255;
resultData[i*step+j*channels+1] = 255;
resultData[i*step+j*channels+2] = 255;
}
else
{
resultData[i*step+j*channels+0] = 0;
resultData[i*step+j*channels+1] = 0;
resultData[i*step+j*channels+2] = 0;
}
}
}
//end of frame differencing with binarization
grayImg = cvCreateImage( cvSize(result->width, result->height),
IPL_DEPTH_8U, 1 );
//convert original color image (3 channel rgb color image) to gray-level image
cvCvtColor( result, grayImg, CV_BGR2GRAY );
cannyImg = cvCreateImage(cvGetSize(result), IPL_DEPTH_8U, 1);
cvCanny(grayImg, cannyImg, 50, 150, 3);
cvShowImage("Actual Video",frame2);
cvShowImage("With Differencing",result);
cvShowImage("BackGround", bg_model->background);
cvShowImage("canny Edge", cannyImg);
// cvReleaseData(frame1);
cvReleaseImage(&frame1);
// cvReleaseData(diff1);
cvReleaseImage(&diff1);
// cvReleaseData(diff2);
cvReleaseImage(&diff2);
// cvReleaseData(result);
cvReleaseImage(&result);
key = cvWaitKey(10);
}//end of while
cvDestroyWindow("Actual Video");
cvDestroyWindow("With Differencing");
cvDestroyWindow("BackGround");
cvDestroyWindow("canny");
cvReleaseCapture(&capture);
return 0;
}
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).
ASKER
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. */
>> 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 ?
That's what the error message indicated :
>> 1>c:\program files\opencv\cvaux\include
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 ?
ASKER
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.
), it shows this error(strcat) have to use _s so therefore i changed it.
>> 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 :)
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 :)
ASKER CERTIFIED SOLUTION
membership
This solution is only available to members.
To access this solution, you must be a member of Experts Exchange.
ASKER
oh i see... but it seems like i still cannot get through it.
ASKER
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
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
ASKER
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.
>> 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.
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.
ASKER
hmm.. i think my original question is linked to this. So you mean which library files i have link yet?
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).
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).
ASKER
oh ok. Thanks. Hopefully you can help me again.
ASKER
Hopefully you can help me again! Thanks for your help!
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 :)
ASKER
i see. ok thanks for the remainder. Can help me solve other question?
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 :)