WrapBias2Ipl.cpp

// JW 2005
#include <Base/Common/W32Compat.hh>
#include "WrapBias2Ipl.hh"
#include <Base/Debug/Error.hh>
#include <Base/Debug/DebugSimple.hh>
#include <Base/Image/ImageIO.hh>

#include <string> 


#ifdef BIAS_HAVE_OPENCV
#  include <cv.h>
#  include <highgui.h>
#endif


#ifdef BIAS_HAVE_OPENCV

using namespace std;
using namespace BIAS;

WrapBias2Ipl::~WrapBias2Ipl(){
  // do not destruct the BIAS image because it is reference.

  //destroy IplImage because we constructed it.
  //if (p_imgIplDestroyable)
  {
    delete p_imgIpl;
    p_imgIpl=NULL;
  }
}


WrapBias2Ipl::WrapBias2Ipl()
: 
p_imgBias(NULL)
//,p_imgBiasDestroyable(false)
,p_imgIpl(NULL)
,p_imgIplDestroyable(false)
{
}


WrapBias2Ipl::WrapBias2Ipl(const BIAS::ImageBase * PtrImgBias) 
: 
p_imgBias(NULL)
//,p_imgBiasDestroyable(false)
,p_imgIpl(NULL)
,p_imgIplDestroyable(false)
{
  int result=Bind(PtrImgBias) ;
  // destry on exit because we allcoated
  p_imgIplDestroyable=true; 

  if (result!=0) {
    BIASERR("Error on Bind in constructor. result="<<result);
  };
}



//JW
int WrapBias2Ipl::Bind(const BIAS::ImageBase * p_src)
{
  this->p_imgBias = p_src;
  return CreateIplImageShared(p_src, this->p_imgIpl);   
}


// JW p_dest has to be a *& because we need to change the pointer itself by reference.
int WrapBias2Ipl::CreateIplImageShared(const BIAS::ImageBase * p_src, IplImage* &p_dest)
{
  if (p_src==NULL){
    BIASERR("ImageBase ptr p_src is NULL.");
    return -1;
  };
  if (p_dest==NULL) {
    p_dest=new IplImage;
    //if (p_imgIpl==p_dest) p_imgIplDestroyable = true;
  };

  if (!p_src->IsInterleaved() || !((p_src->GetWidth() % 4) == 0) ) {
    BIASERR("Only interleaved images with modulo 4 with are currently supported, sorry.");
    return -1;
  }

  // OpenCV supports only interleaved IPL_DATA_ORDER_PIXEL: 
  if(!p_src->IsInterleaved()) return -2;

  // OpenCV supports only size modulo 4 image width
  // to have pixel boundaries on 32bit aligned memory
  // we would need stride, otherwise
  if ( p_src->GetWidth() % 4 != 0 ) {
    BIASERR("Image width is not multiple of 4 :"<< p_src->GetWidth()
            <<"x"<< p_src->GetHeight());
    return -3;
  }

  // OK
  // initialize only the header without data area: 
  CvSize imgSize;
  imgSize.width  = p_src->GetWidth();    
  imgSize.height = p_src->GetHeight();
  // pixel depth in bits
  int depth=0;
  switch (p_src->GetStorageType()) {
    case BIAS::ImageBase::ST_char:
      depth=IPL_DEPTH_8S; break;
    case BIAS::ImageBase::ST_unsignedchar:
      depth=IPL_DEPTH_8U; break;
    case BIAS::ImageBase::ST_float:
      depth=IPL_DEPTH_32F; break;
    case BIAS::ImageBase::ST_double:
      depth=IPL_DEPTH_64F; break;
    case BIAS::ImageBase::ST_shortint:
      depth=IPL_DEPTH_16S; break;
    case BIAS::ImageBase::ST_unsignedshortint:
      depth=IPL_DEPTH_16U; break;
    case BIAS::ImageBase::ST_int:
      depth=IPL_DEPTH_32S; break;

    case BIAS::ImageBase::ST_unsignedint:
      // unsupported (?)
      BIASERR("you try to wrap a BIAS unsigned int Image with OpenCV. This format may be unsupported by OpenCV! (JW)");
      depth=IPL_DEPTH_32S|IPL_DEPTH_SIGN;
    default:
      BIASERR("unsupported Storagetype in BIAS image for BIAs->ipl image wrapper. GetStorageType="<<p_src->GetStorageType() );
      return -1;
  }

  // fill header struct with useful values: 
  cvInitImageHeader( p_dest, 
    imgSize, 
    depth,
    p_src->GetChannelCount(), 
    IPL_ORIGIN_TL, // origin top left
    4 // alignment
    );

  // share the data area: (pointer to aligned image data) do NOT copy
  p_dest->imageData = (char*)(p_src->GetImageData());


  // get the color model and channel seq. right:
  switch (p_src->GetColorModel()){
    case BIAS::ImageBase::CM_RGB:
      // tested, works on Win32
      strcpy( p_dest->colorModel, "RGB");
      strcpy( p_dest->channelSeq, "RGB");
      break;
    case BIAS::ImageBase::CM_BGR:
      // untested but should work because it's OpenCv native format.
      strcpy( p_dest->colorModel, "RGB");
      strcpy( p_dest->channelSeq, "BGR");
      break;
    case BIAS::ImageBase::CM_BGRA:
      // untested.
      strcpy( p_dest->colorModel, "RGBA");
      strcpy( p_dest->channelSeq, "BGRA");
      break;
    case BIAS::ImageBase::CM_RGBA:
      // untested.
      strcpy( p_dest->colorModel, "RGBA");
      strcpy( p_dest->channelSeq, "RGBA");
      break;

      /* assume grey display for packed pseudo one channel formats */
    case BIAS::ImageBase::CM_Grey:
    case BIAS::ImageBase::CM_Bayer_RGGB:
    case BIAS::ImageBase::CM_Bayer_GBRG:
    case BIAS::ImageBase::CM_Bayer_GRBG:
    case BIAS::ImageBase::CM_Bayer_BGGR:
    case BIAS::ImageBase::CM_PGR_XB3_F7M3_GBRG:
      // untested.
      strcpy( p_dest->colorModel, "GREY");
      strcpy( p_dest->channelSeq, "GREY");
      break;
    default:
      BIASERR("unsupported color model for OpenCV wrapping. "
        "ChannelSeq may be wrong. "
        <<p_src->GetColorModel() );
      return -2;
  };

  return 0;
}


// JW
int WrapBias2Ipl::CreateBiasImageCopy(const IplImage * p_src, BIAS::ImageBase & dest)
{
#ifdef __clang__
  BIASERR("IplImage image loading is not supported in llvm/clang built BIAS binaries.");
#else
  if (p_src==NULL){
    BIASERR("IplImage ptr p_src is NULL.");
    return -1;
  };

  bool recreate=true; // HACK: always recreate
  // TODO: check sizes, depth etc. and set recreate
  if (recreate)
  {
    if (!dest.IsEmpty())
      dest.Release();

    // detremine storage type first because it is required in Init call.
    // pixel depth for corerct casting/type of the void* underlying content
    dest.StorageType_ = ImageBase::ST_invalid;  //< default
    switch (p_src->depth)
    {
    case IPL_DEPTH_8S:
      dest.StorageType_ = ImageBase::ST_char;   
      break;
    case IPL_DEPTH_8U:
      dest.StorageType_ = ImageBase::ST_unsignedchar;
      break;
    case IPL_DEPTH_32F:
      dest.StorageType_ = ImageBase::ST_float;
      break;
    case IPL_DEPTH_64F:
      dest.StorageType_ = ImageBase::ST_double;
      break;
    case IPL_DEPTH_16S:
      dest.StorageType_ = ImageBase::ST_shortint;
      break;
    case IPL_DEPTH_16U:
      dest.StorageType_ = ImageBase::ST_unsignedshortint;
      break;
      //case (int(IPL_DEPTH_32S|IPL_DEPTH_SIGN)):
      //    // unsupported (?)
      //    dest.StorageType_ = ImageBase::ST_unsignedint:
      //    BIASERR("you try to wrap an unsigned int Image with OpenCV to BIAs. This format may be unsupported by OpenCV! (JW)");
      //    break;
    case IPL_DEPTH_32S:
      dest.StorageType_ = ImageBase::ST_int;
      break;
    default:
      BIASERR("unsupported Ipl Storagetype for Ipl->BIAS wrapper.");
      return -1;
    }
    //initialize target image
    unsigned offset =0;
    if(p_src->width%2 != 0) offset =1;
    dest.Init(p_src->width+offset,p_src->height ,p_src->nChannels,dest.GetStorageType(),true);

    // default
    dest.SetColorModel(ImageBase::CM_RGB);

    // get the color model and channel seq. right:
    if (string(p_src->colorModel)=="RGB"){

      if (string(p_src->channelSeq)=="RGB"){
        dest.SetColorModel(ImageBase::CM_RGB);
      } else if (string(p_src->channelSeq)=="BGR"){
        dest.SetColorModel(ImageBase::CM_BGR);
      } else {
        BIASERR("unsupported channelSeq for for OpenCV wrapping of RGB color model");
      }

    } else if (string(p_src->colorModel)=="RGBA"){

      if (string(p_src->channelSeq)=="RGBA"){
        dest.SetColorModel(ImageBase::CM_RGBA);
      } else if (string(p_src->channelSeq)=="BGRA"){
        dest.SetColorModel(ImageBase::CM_BGRA);
      } else {
        BIASERR("unsupported channelSeq for for OpenCV wrapping of of RGBA color model");
      }

    } else if ((string(p_src->colorModel)=="GREY") || (string(p_src->colorModel)=="GRAY")) {
      dest.SetColorModel(ImageBase::CM_Grey);
    } else {

      BIASERR("unsupported color model for OpenCV wrapping.");
      return -2;
    }
  };

  BIASASSERT(p_src!=NULL); 
  BIASASSERT(p_src->origin == IPL_ORIGIN_TL); // we suport only toplleft origin image for now. JW
  BIASASSERT(dest.IsInterleaved() );

  // share the data area: (pointer to aligned image data) do NOT copy
  //dest.ReleaseImageDataPointer();
  //dest.ImageData_ = p_src->imageData;
  //dest.UpdateImageDataArrayFromImageData_();

  // copy nr. of Bytes - no matter of recreate or not
  //const unsigned int nBytes = dest.GetPixelCount()*dest.GetDepth()*dest.GetChannelCount();
  //memcpy( dest.GetImageData(), p_src->imageData, nBytes );
  dest.CopyIn_NoInit( p_src->imageData );
  //ImageIO::Save("test.png",dest);
  //BIASASSERT(dest.GetImageData() == p_src->imageData ); //< only for shared memory
  return 0;
#endif
}



bool WrapBias2Ipl::Consistent() const {
  if ((p_imgBias!=NULL) && (p_imgIpl!=NULL))
  {
    if (p_imgBias->GetImageData() != p_imgIpl->imageData ) {
      BIASERR("data pointers of bias image and wrapped OpenCV imaeg are inconsisten!!!");
      return false;
    } else if ((int)p_imgBias->GetWidth() != p_imgIpl->width ) {
      BIASERR("width is inconsistent!");
      return false;
    } else if ((int)p_imgBias->GetHeight() != p_imgIpl->height ){
      BIASERR("height is inconsistent!");
      return false;
    };
  }
  return true; 
}


//static 
void WrapBias2Ipl::ConvertIPL32to8(const IplImage* src32, 
                                   IplImage* dest8,
                                   const float & scale )
{
  BIASASSERT(src32!=NULL);
  BIASASSERT(dest8!=NULL);
  BIASASSERT(src32->width  == dest8->width);
  BIASASSERT(src32->height == dest8->height);
  BIASASSERT(src32->nChannels==dest8->nChannels);
  BIASASSERT(src32->depth==32);
  BIASASSERT(src32->imageData!=NULL);
  BIASASSERT(dest8->imageData!=NULL);
  BIASASSERT(scale!=0);

  // src pointer, 
  // because imageData is a signed char*
  float *pSS =  reinterpret_cast<float *>(src32->imageData);

  // destination
  unsigned char *pDD = reinterpret_cast<unsigned char*>(dest8->imageData);
  BIASASSERT(pSS!=NULL);
  BIASASSERT(pDD!=NULL);
  const int nX = src32->width * src32->nChannels;
  // for all pixels of all channels
  for (int y=0; y<src32->height; y++) {
    for (int x=0; x<nX; x++) {
      // clipping:  0 <= scale*in <= 255
      pDD[x] = (unsigned char)( max(0.0f, min(255.0f, scale*pSS[x])) );
    }
    // next line
    pSS = reinterpret_cast<float *>       (&src32->imageData[y*src32->widthStep]);
    pDD = reinterpret_cast<unsigned char*>(&dest8->imageData[y*dest8->widthStep]);
  }
}

// static function:
int WrapBias2Ipl::WaitKey(const unsigned int & delay){
  return cvWaitKey(delay);
}


int WrapBias2Ipl::Display(const bool & waitForKey, 
                          const unsigned int & delayMsec,
                          const float & scale) const 
{
  // do not move to topleft because this may be a subsequejt call after teh user moved it himself
  return Display( string( DEFAULT_WrapBias2Ipl_WINNAME ),true, false, waitForKey, delayMsec, scale);
}

int WrapBias2Ipl::Display(const char * DestWin, 
                          const bool & autoresize,
                          const bool & moveToTopLeft,
                          const bool & waitForKey,
                          const unsigned int & delayMsec,
                          const float & scale,
                          const bool & allowAlphaWindow
                          ) const
{
  std::string name(DestWin);
  return Display(name,
    autoresize,
    moveToTopLeft,
    waitForKey,
    delayMsec,
    scale,
    allowAlphaWindow
    );
}


int WrapBias2Ipl::Display(const std::string & DestWin, 
                          const bool & autoresize,
                          const bool & moveToTopLeft,
                          const bool & waitForKey,
                          const unsigned int & delayMsec,
                          const float & scale,
                          const bool & allowAlphaWindow                          
                          ) const
{
  return Display(this->p_imgIpl, DestWin, autoresize, moveToTopLeft, waitForKey, delayMsec, scale, allowAlphaWindow);
}



// jw this is the implementation of the static function: 
int WrapBias2Ipl::Display(const IplImage* img,
                          const std::string & DestWin, 
                          const bool & autoresize,
                          const bool & moveToTopLeft,
                          const bool & waitForKey,
                          const unsigned int & delayMsec,
                          const float & scale,
                          const bool & allowAlphaWindow
                          )
{
  if (img==NULL) {
    BIASERR("NULL img");
    return -2;
  };
  if (img->width==0 || img->height==0) {
    BIASERR("empty image of dim "<<img->width<<"x"<<img->height);
    return -3;
  };

  // create the display window: 
  int winflags=0;
  if (autoresize) winflags = winflags | CV_WINDOW_AUTOSIZE;
  cvNamedWindow(DestWin.c_str(), winflags);
  if (moveToTopLeft) cvMoveWindow(DestWin.c_str(), 0,0);

  switch (img->depth) // bits
  {
  case 8:    
    if (strcmp(img->channelSeq, "BGR")==0)
    {
      // no swap required, is OpenCv native fmt
      cvShowImage(DestWin.c_str(), img);
    } else if (strcmp(img->channelSeq, "RGB")==0) {
      // swap R-B        
      IplImage *p_swapped=NULL;
      // TODO: keep a static copy here and check if sizes remain for higehr performance (avoid new/delete) (jw)
      p_swapped = cvCreateImage( cvSize(img->width, img->height), 
        img->depth, 
        img->nChannels);
      cvConvertImage( img, p_swapped, CV_CVTIMG_SWAP_RB);
      cvShowImage(DestWin.c_str(), p_swapped);
      cvReleaseImage(&p_swapped);
    } else if ((strcmp(img->channelSeq, "GREY")==0) || (strcmp(img->channelSeq, "GRAY")==0)) {
      cvShowImage(DestWin.c_str(), img);
    } else if (strcmp(img->channelSeq, "RGBA")==0) {
      if (allowAlphaWindow)
      { // display extra alpha image?
        // extract image with single alpha channel?
        IplImage *p_alpha=cvCreateImage( cvSize(img->width, img->height), 
          8, // bits
          1  // 1 alpha channel 
          );
        for (int i=0; i<((p_alpha->width) * (p_alpha->height)); i++){
          p_alpha->imageData[i] = img->imageData[4*i+3];
        }
        const string alphaWin = DestWin+"_alpha";
        cvNamedWindow(alphaWin.c_str(), 1);
        cvShowImage(alphaWin.c_str(), p_alpha); // Alpha luminace
        cvReleaseImage(&p_alpha);
      }

      // RGB(A) image
      cvShowImage(DestWin.c_str(), img); // RGBA
    } else {
      BIASERR("Sorry, colorChannelSeq/colorModel unsupported. "<<endl
        <<"bitdepth="<<img->depth<<" channelseq="<<img->channelSeq <<endl
        <<"Please complete switch. Trying to display anyhow.");
      cvShowImage(DestWin.c_str(), img);
    }
    break;
  case 32:
    {
      // convert to 8 bit for display, 
      // asumme scaling from 0..1 to 0..255
      IplImage *p_8bit=NULL;
      p_8bit = cvCreateImage( cvSize(img->width, img->height), 
        8, // bits:  32 --> 8
        img->nChannels);
      // keep channel order.  dest, src, count
      // OpenCv ignores it but we need it for highgui
      memcpy(p_8bit->channelSeq, img->channelSeq, 4);

      // convert the floats to 8 bit (with scaling and clipping):
      ConvertIPL32to8(img, p_8bit, scale);

      // now we may need to additionally swap.
      if (strcmp(p_8bit->channelSeq, "BGR")==0)
      {
        // no swap required, is OpenCv native fmt
        cvShowImage(DestWin.c_str(), p_8bit);
      } else if (strcmp(p_8bit->channelSeq, "RGB")==0) {
        // swap R-B        
        IplImage *p_swapped=NULL;
        // TODO: keep a static copy here and check if sizes remain for higehr performance (avoid new/delete) (jw)
        p_swapped = cvCreateImage( cvSize(p_8bit->width, p_8bit->height), 
          p_8bit->depth, 
          p_8bit->nChannels);
        cvConvertImage( p_8bit, p_swapped, CV_CVTIMG_SWAP_RB);
        cvShowImage(DestWin.c_str(), p_swapped);
        cvReleaseImage(&p_swapped);
      } else if ((strcmp(p_8bit->channelSeq, "GREY")==0) || (strcmp(p_8bit->channelSeq, "GRAY")==0)) {
        cvShowImage(DestWin.c_str(), p_8bit);
      } else {
        BIASERR("Sorry, colorChannelSeq/colorModel/depth unsupported. "<<endl
          <<"bitdepth="<<img->depth<<" channelseq="<<img->channelSeq <<endl
          <<"Please complete switch. Trying to display anyhow.");
        cvShowImage(DestWin.c_str(), p_8bit);
      }
    }
    break;
  default:
    BIASERR("Sorry, colorChannelSeq/colorModel/depth unsupported. "<<endl
      <<"bitdepth="<<img->depth<<" channelseq="<<img->channelSeq <<endl
      <<"Please complete switch. Trying to display anyhow.");
    cvShowImage(DestWin.c_str(), img);
  };

  if (waitForKey) {
    return WrapBias2Ipl::WaitKey(delayMsec);
  } else {
    // always wait 1msec to trigger update of display. 
    WrapBias2Ipl::WaitKey(1);
    return 0;
  };
}


// static function wrappers (JW)

void WrapBias2Ipl::DestroyAllWindows()
{
  cvDestroyAllWindows();
}

void WrapBias2Ipl::DestroyWindow( const char* name )
{
  cvDestroyWindow( name );
}

void WrapBias2Ipl::DestroyWindow( const std::string & name )
{
  DestroyWindow( name.c_str() );
}


void WrapBias2Ipl::ResizeWindow( const char* name, 
                                const unsigned int width, 
                                const unsigned int height )
{
  cvResizeWindow( name, width, height );
}

void WrapBias2Ipl::ResizeWindow( const std::string & name, 
                                const unsigned int width, 
                                const unsigned int height )
{
  ResizeWindow( name.c_str(), width, height );
}


void WrapBias2Ipl::MoveWindow( const char* name, const int newX, const int newY )
{
  cvMoveWindow( name, newX, newY );
}

void WrapBias2Ipl::MoveWindow( const std::string & name, const int newX, const int newY )
{
  MoveWindow( name.c_str(), newX, newY );
}


void WrapBias2Ipl::NamedWindow( const char* name, const int flags)
{
  cvNamedWindow(name, flags);
}

void WrapBias2Ipl::NamedWindow( const std::string & name, const int flags)
{
  cvNamedWindow(name.c_str(), flags);
}



#endif // BIAS_HAVE_OPENCV