prip/include/Util.h

Go to the documentation of this file.

#ifndef PRIP_UTIL_H
#define PRIP_UTIL_H

#include "prip.h"
#include <string>
#include <FreeImagePlus.h>
#include <cxcore/include/cxcore.h>


namespace prip {


class Util : private NonCopyable
{
public:
   static std::string base64Encode(const unsigned char*const bytesToEncode, unsigned int len);
   
   static std::string base64Encode(const std::string & stringToEncode);


   static std::string base64Decode(const std::string & stringToDecode);

   static fipImage raw2fipImage(const std::string & rawBuffer);

   static IplImage* raw2IplImage(const std::string & rawBuffer);

public:
   ~Util(void) {}

private:
   Util(void) {}
   
};


inline 
fipImage Util::raw2fipImage(const std::string & rawBuffer) {
   char* buffer = const_cast<char*>(rawBuffer.c_str());
   fipMemoryIO memory(reinterpret_cast<BYTE*>(buffer), static_cast<DWORD>(rawBuffer.length()*sizeof(BYTE)/sizeof(char)));
   fipImage img;
   img.loadFromMemory(memory);
   return img;
}

inline 
IplImage* Util::raw2IplImage(const std::string & rawBuffer)
{
   fipImage fipimg(raw2fipImage(rawBuffer));
   int channels, depth;
   switch (fipimg.getImageType())
   {
   case FIT_UINT16:
      channels = 1;
      depth = IPL_DEPTH_16U;
      break;

   case FIT_INT16:
      channels = 1;
      depth = IPL_DEPTH_16S;
      break;

/* NOT SUPPORTED
   case FIT_UINT32:
      channels = 1;
      depth = IPL_DEPTH_32U;
      break;
      
      */

   case FIT_INT32:
      channels = 1;
      depth = IPL_DEPTH_32S;
      break;

   case FIT_FLOAT:
      channels = 1;
      depth = IPL_DEPTH_32F;
      break;

   case FIT_DOUBLE:
      channels = 1;
      depth = IPL_DEPTH_64F;
      break;

   case FIT_COMPLEX:
      channels = 2;
      depth = IPL_DEPTH_64F;
      break;

   case FIT_RGB16:
      channels = 3;
      depth = IPL_DEPTH_16U;
      break;

   case FIT_RGBA16:
      channels = 4;
      depth = IPL_DEPTH_16U;
      break;

   case FIT_RGBF:
      channels = 3;
      depth = IPL_DEPTH_32F;
      break;

   case FIT_RGBAF:
      channels = 4;
      depth = IPL_DEPTH_32F;
      break;

   case FIT_BITMAP:
      if (fipimg.isGrayscale())
      {
         channels = 1;
         depth = IPL_DEPTH_8U;
      } else {
         switch (fipimg.getColorType())
         {
         case FIC_RGB:
            channels = 3;
            break;
         case FIC_RGBALPHA:
            channels = 4;
            break;
         default:
            channels = -1;
            break;
         }
         if (channels == -1) break;
         switch (fipimg.getBitsPerPixel()/channels)
         {
         case 8:
            depth = IPL_DEPTH_8U;
            break;
         case 16:
            depth = IPL_DEPTH_16U;
            break;
         case 32:
            depth = IPL_DEPTH_32S;
            break;
         default:
            channels = -1;
            break;
         }
      }

   default:
      channels = -1;
      break;

   }

   if (channels == -1) return NULL;
   
   IplImage* img = cvCreateImage(cvSize(fipimg.getWidth(),fipimg.getHeight()),depth,channels);
   
   uchar* imgdata;
   cvGetRawData(img,&imgdata);
   memcpy(imgdata,fipimg.accessPixels(),fipimg.getWidth()*fipimg.getHeight()*fipimg.getBitsPerPixel()/8);
   fipimg.clear();

   return img;
}

}

#endif

---