iplvbasicimage.hxx

Go to the documentation of this file.

/************************************************************************/
/*                                                                      */
/*               Copyright 2004-2005 by Hirotaka Niitsuma               */
/*                                                                      */
/*                                                                      */
/*    This file is part of the STLLCV computer vision library.          */
/*    ( Version 0.1, Sep 28 2005 )                                      */
/*    You may use, modify, and distribute this software according       */
/*    to the terms stated in the LICENSE file included in               */
/*    the STLLCV distribution.                                          */
/*                                                                      */
/*    The STLLCV Website is                                             */
/*        http://www2s.biglobe.ne.jp/~niitsuma/STLLCV/                  */
/*    Please direct questions, bug reports, and contributions to        */
/*        niitsuma@mub.biglobe.ne.jp�@�@�@                              */
/*                                                                      */
/*  THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR          */
/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED      */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
/*                                                                      */
/************************************************************************/


#ifndef IPLV_BASICIMAGE_HXX
#define IPLV_BASICIMAGE_HXX


#include "vigra/multi_array.hxx" 
#include "vigra/imageiterator.hxx"
#include "vigra/stdimage.hxx"
#include "vigra/basicimageview.hxx"
#include "vigra/basicimage.hxx"

#include "vimageoperation.hxx"

#include <boost/mpl/if.hpp>



#include <ipl.h>
#include "cv.h"





template<class PIXELTYPE>class CiplImageDepth   {public: int depth;CiplImageDepth(){depth= sizeof(PIXELTYPE);}};
template<>class CiplImageDepth<unsigned char>   {public: int depth;CiplImageDepth(){depth= IPL_DEPTH_8U;}};
template<>class CiplImageDepth<char>                    {public: int depth;CiplImageDepth(){depth= IPL_DEPTH_8S;}};
template<>class CiplImageDepth<unsigned short>  {public: int depth;CiplImageDepth(){depth= IPL_DEPTH_16U;}};
template<>class CiplImageDepth<short>                           {public: int depth;CiplImageDepth(){depth= IPL_DEPTH_16S;}};
template<>class CiplImageDepth<int>                     {public: int depth;CiplImageDepth(){depth= IPL_DEPTH_32S;}};
template<>class CiplImageDepth<float>                   {public: int depth;CiplImageDepth(){depth= IPL_DEPTH_32F;}};
template<>class CiplImageDepth<double>                  {public: int depth;CiplImageDepth(){depth= IPL_DEPTH_64F;}};

template<class PIXELTYPE>class CipliConstImgDepth       {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(sizeof(PIXELTYPE)){}};
template<>class CipliConstImgDepth<unsigned char>       {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(IPL_DEPTH_8U){}};
template<>class CipliConstImgDepth<char>                        {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(IPL_DEPTH_8S){}};
template<>class CipliConstImgDepth<unsigned short>      {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(IPL_DEPTH_16U){}};
template<>class CipliConstImgDepth<short>                       {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(IPL_DEPTH_16S){}};
template<>class CipliConstImgDepth<int>                         {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(IPL_DEPTH_32S){}};
template<>class CipliConstImgDepth<float>                       {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(IPL_DEPTH_32F){}};
template<>class CipliConstImgDepth<double>                      {public: const int depthConstInt;CipliConstImgDepth():depthConstInt(IPL_DEPTH_64F){}};


/********************************************************/
/*                                                      */
/*                    CiplvBasicImage                   */
/*                                                      */
/********************************************************/

template <
        class PIXELTYPE
        ,class Alloc = std::allocator<PIXELTYPE>
>
class CiplvBasicImage : public CipliConstImgDepth<PIXELTYPE>,public vigra::BasicImageView<PIXELTYPE> //, public IplImage
{
public:
        int iplDepthDef;
        //IplImage *const pIplImage;
        IplImage *pIplImage;    

        IplImage*  initProc(int width,int height)
        {
                CiplImageDepth<PIXELTYPE> iplImageDepth;
                iplDepthDef=iplImageDepth.depth;
                pIplImage=
                        cvCreateImage( cvSize(width, height), 
                        iplDepthDef             
                        , 1 );
                        
                return pIplImage;
        }
        
        IplImage*  initAndCopyProc(IplImage  ipl_imageIn)
        {
                pIplImage=initProc(ipl_imageIn.widthStep/sizeof(PIXELTYPE),ipl_imageIn.height); 
                pIplImage=iplCloneImage (&ipl_imageIn);
                return pIplImage;
        }

        int iplWidth()
        {
                return (pIplImage->width);
        }


        IplImage*  loadImageAndInit(char * filename)
        {
                IplImage* grayImage = cvLoadImage( filename, 0 );//load as gray 
                return grayImage;
        }

        IplImage*  loadImageAndInit(const char * filename)
        {
                IplImage* grayImage = cvLoadImage( filename, 0 );
                return grayImage;
        }

        CiplvBasicImage( char *filename) :
                vigra::BasicImageView< PIXELTYPE >(reinterpret_cast<PIXELTYPE*>(
                        (pIplImage=loadImageAndInit(filename))->imageData), pIplImage->widthStep/sizeof(PIXELTYPE),pIplImage->height)
        {}

        CiplvBasicImage(const char * filename ) :
                vigra::BasicImageView< PIXELTYPE >(reinterpret_cast<PIXELTYPE*>(
                        (pIplImage=loadImageAndInit(filename))->imageData), pIplImage->widthStep/sizeof(PIXELTYPE),pIplImage->height)
        {}


        CiplvBasicImage(int width,int height) :
                vigra::BasicImageView< PIXELTYPE >(reinterpret_cast<PIXELTYPE*>(
                        (pIplImage=initProc(width,height) )->imageData)
                        , pIplImage->widthStep/sizeof(PIXELTYPE),height)
        {}

        CiplvBasicImage(IplImage*  pIplImageIn) :               
                vigra::BasicImageView< PIXELTYPE >(reinterpret_cast<PIXELTYPE*>(
                        pIplImageIn->imageData)
                        , pIplImageIn->widthStep/sizeof(PIXELTYPE),pIplImageIn->height)
        {       
                pIplImage=pIplImageIn;
        }

        CiplvBasicImage(IplImage  ipl_imageIn) :                
                vigra::BasicImageView< PIXELTYPE >(reinterpret_cast<PIXELTYPE*>(
                        (pIplImage=initAndCopyProc(ipl_imageIn))->imageData)
                        ,ipl_imageIn.widthStep/sizeof(PIXELTYPE)
                        ,ipl_imageIn.height)
        {}

        CiplvBasicImage(CiplvBasicImage<PIXELTYPE>  &iplvImageIn) :             
                vigra::BasicImageView< PIXELTYPE >(reinterpret_cast<PIXELTYPE*>(
                        (pIplImage=initProc(iplvImageIn.width(),iplvImageIn.height() ) )->imageData)
                        , pIplImage->widthStep/sizeof(PIXELTYPE),iplvImageIn.height() 
                        )
        {
                iplvResizeCopyImageZeroPad(&iplvImageIn , this);
        }

#if 0
        CiplvBasicImage(CvMat*  im) :           
                vigra::BasicImageView< PIXELTYPE >(reinterpret_cast<PIXELTYPE*>(
                        im->data.ptr)
                        , im->width,im->height)
        {       
                pIplImage = new IplImage ;
                //cvCreateImage( cvSize(width, height), iplImageDepth.depth, 1 )
                //pIplImage=reinterpret_cast< IplImage * >(im);
                pIplImage->imageData=(char *)im->data.ptr;
                pIplImage->width=im->width;
                pIplImage->height=im->height;
        }
#endif

        ~CiplvBasicImage(){
                cvReleaseImage( &pIplImage);
                //cvReleaseImageHeader( &pIplImage);
                //      cvReleaseImage( &pIplImage ); 
        }
};

typedef CiplvBasicImage<unsigned char> CiplvBImage;


#if 1

template <class PIXELTYPE, class Alloc = std::allocator<PIXELTYPE> >
class CviplBasicImage : public CipliConstImgDepth<PIXELTYPE>, public vigra::BasicImage<PIXELTYPE,Alloc>, public IplImage
{
public:
        int iplDepthDef;
        IplImage *const pIplImage;
        //IplImage *pIplImage;


        IplImage*
        viplInitImageHeader( IplImage * image, CvSize size, int depth,
                   int channels, int origin=0,int align=4  )
        {
    IplImage* result = 0;

    char *colorModel, *channelSeq;

    if( !image )
        CV_ERROR( CV_HeaderIsNull, "null pointer to header" );

    memset( image, 0, sizeof( *image ));
    image->nSize = sizeof( *image );

    CV_CALL( icvGetColorModel( channels, &colorModel, &channelSeq ));
    strncpy( image->colorModel, colorModel, 4 );
    strncpy( image->channelSeq, channelSeq, 4 );

    if( size.width < 0 || size.height < 0 )
        CV_ERROR( CV_BadROISize, "Bad input roi" );

    if( (depth != (int)IPL_DEPTH_1U && depth != (int)IPL_DEPTH_8U &&
         depth != (int)IPL_DEPTH_8S && depth != (int)IPL_DEPTH_16U &&
         depth != (int)IPL_DEPTH_16S && depth != (int)IPL_DEPTH_32S &&
         depth != (int)IPL_DEPTH_32F && depth != (int)IPL_DEPTH_64F) ||
         channels < 0 )
        CV_ERROR( CV_BadDepth, "Unsupported format" );
    if( origin != CV_ORIGIN_BL && origin != CV_ORIGIN_TL )
        CV_ERROR( CV_BadOrigin, "Bad input origin" );

    if( align != 4 && align != 8 )
        CV_ERROR( CV_BadAlign, "Bad input align" );

    image->width = size.width;
    image->height = size.height;

    if( image->roi )
    {
        image->roi->coi = 0;
        image->roi->xOffset = image->roi->yOffset = 0;
        image->roi->width = size.width;
        image->roi->height = size.height;
    }

    image->nChannels = MAX( channels, 1 );
    image->depth = depth;
    image->align = align;
    image->widthStep = image->width*sizeof(PIXELTYPE);
    image->origin = origin;
    image->imageSize = image->widthStep * image->height;

    result = image;
    return result;
        }
#if 0
        IplImage*  initIplImage(int width,int height)
        {
                CiplImageDepth<PIXELTYPE> iplImageDepth;
                iplDepthDef=iplImageDepth.depth;
                viplInitImageHeader( 
                        (IplImage *)this,
                        , cvSize(width,height), iplDepthDef,1);
                return (IplImage *)this;
        }
#endif

        CviplBasicImage(int width,int height) :
                CipliConstImgDepth<PIXELTYPE>(),
                vigra::BasicImage<PIXELTYPE,Alloc>(width,height),
                pIplImage(
                        viplInitImageHeader( 
                                reinterpret_cast<IplImage*>this, 
                                cvSize(width,height),depthConstInt,1
                                )
                        )
        {}

        //~CviplBasicImage(){}
};

#endif






#endif /* IPLV_BASICIMAGE_HXX */

---