cxcore/include/cxcore.hpp - platform/external/opencv - Git at Google

 /*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 _CXCORE_HPP_
 #define _CXCORE_HPP_

 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 );
     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 );
     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;
 };


 // classes for automatic module/RTTI data registration/unregistration
 struct CV_EXPORTS CvModule
 {
     CvModule( CvModuleInfo* _info );
     ~CvModule();
     CvModuleInfo* info;

     static CvModuleInfo* first;
     static CvModuleInfo* last;
 };

 struct CV_EXPORTS CvType
 {
     CvType( const char* type_name,
             CvIsInstanceFunc is_instance, CvReleaseFunc release=0,
             CvReadFunc read=0, CvWriteFunc write=0, CvCloneFunc clone=0 );
     ~CvType();
     CvTypeInfo* info;

     static CvTypeInfo* first;
     static CvTypeInfo* last;
 };

 #endif /*_CXCORE_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 _CXCORE_HPP_
	#define _CXCORE_HPP_

	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 );
	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 + yimage->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 + yimage->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 );
	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;
	};


	// classes for automatic module/RTTI data registration/unregistration
	struct CV_EXPORTS CvModule
	{
	CvModule( CvModuleInfo* _info );
	~CvModule();
	CvModuleInfo* info;

	static CvModuleInfo* first;
	static CvModuleInfo* last;
	};

	struct CV_EXPORTS CvType
	{
	CvType( const char* type_name,
	CvIsInstanceFunc is_instance, CvReleaseFunc release=0,
	CvReadFunc read=0, CvWriteFunc write=0, CvCloneFunc clone=0 );
	~CvType();
	CvTypeInfo* info;

	static CvTypeInfo* first;
	static CvTypeInfo* last;
	};

	#endif /_CXCORE_HPP_/