alimage.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALVISION_ALVISION_ALIMAGE_H_
#define _LIBALVISION_ALVISION_ALIMAGE_H_

#include <string>
#include <iostream>
#include <vector>
#include <cassert>

#include <boost/shared_ptr.hpp>

#include <alvision/alvisiondefinitions.h>
#include <qi/os.hpp>

namespace AL
{
class ALValue;

class ALImage
{
public:
  struct ROI {
    ROI(int left, int top, int width, int height);
    ROI(int left, int top, int width, int height,
        float leftAngle,  float topAngle,
        float rightAngle, float bottomAngle);
    int x;
    int y;
    int w;
    int h;
    float leftAngle;
    float topAngle;
    float rightAngle;
    float bottomAngle;
  };

  // .:: methods ::

public:
  ALImage(int pWidth, int pHeight, int pColorSpace, bool pDataAreExternal = false,
          float pLeftAngle = 0.f, float pTopAngle = 0.f,
          float pRightAngle = 0.f, float pBottomAngle = 0.f);

  ALImage(int pResolution, int pColorSpace, bool pDataAreExternal = false,
          float pLeftAngle = 0.f, float pTopAngle = 0.f,
          float pRightAngle = 0.f, float pBottomAngle = 0.f);

  ~ALImage();

  ALImage deepCopy();

  ALValue toALValue();

  static ALImage* fromALValue(const ALValue& image);

  inline void setWidth( const int width )   { fWidth = width; }
  inline void setHeight( const int height ) { fHeight = height; }
  inline void setLeftAngle( const float leftAngle )     { fFOV.leftAngle = leftAngle; }
  inline void setTopAngle( const float topAngle )       { fFOV.topAngle = topAngle; }
  inline void setRightAngle( const float rightAngle )   { fFOV.rightAngle = rightAngle; }
  inline void setBottomAngle( const float bottomAngle ) { fFOV.bottomAngle = bottomAngle; }
  inline void setAngles( const float leftAngle,  const float topAngle,
                         const float rightAngle, const float bottomAngle )
  { fFOV.leftAngle = leftAngle;   fFOV.topAngle = topAngle;
    fFOV.rightAngle = rightAngle; fFOV.bottomAngle = bottomAngle; }

  bool setSize(int pResolution) { return setResolution(pResolution); }

  bool setResolution(int pResolution);

  bool setColorSpace(int pColorSpace);

  inline const unsigned char* getFrame() const
  { std::cout << "getFrame() is deprecated. Please replace by getData()." << std::endl;
    return rawData(); }

  inline const unsigned char* getData() const { return rawData(); }

  // for the camera
  inline unsigned char* getFrame()
  { std::cout << "getFrame() is deprecated. Please replace by getData()." << std::endl;
    return rawData(); }

  inline unsigned char* getData() { return rawData(); }

  inline void setData(unsigned char* pData) { fData = externalData(pData); }

  inline void setTimeStamp(const qi::os::timeval pTimeStamp)
  {
    if( (pTimeStamp.tv_usec < 0) || (pTimeStamp.tv_sec < 0) )
    {
      fTimeStamp = -1;
      return;
    }
    setTimeStamp(static_cast<int>(pTimeStamp.tv_sec), static_cast<int>(pTimeStamp.tv_usec));
  }

  inline void setTimeStamp(long long pTimeStamp) { fTimeStamp = pTimeStamp; }

  inline void setTimeStamp(int pSeconds, int pMicroSeconds)
  {
    fTimeStamp = (long long)pSeconds*1000000LL + (long long)pMicroSeconds;
  }


  inline void setCameraId(char pCameraId) { fCameraId = pCameraId; }


  inline unsigned int getSize() const { return fWidth*fHeight*fNbLayers; }

  /*
     * Accessor
     */
  inline int getWidth( void )  const { return fWidth; }
  inline int getHeight( void ) const { return fHeight; }
  inline int getResolution( void ) const { return getResolutionFromSize(fWidth, fHeight); }
  inline int getColorSpace( void ) const { return fColorSpace; }
  inline int getNbLayers( void ) const { return fNbLayers; }
  inline long long getTimeStamp( void ) const { return fTimeStamp; }
  inline char getCameraId() const { return fCameraId; }
  inline int getMaxResolution( void ) const { return fMaxResolution; }
  inline int getNbOfLayersMax( void ) const { return fMaxNumberOfLayers; }
  inline bool areDataExternal( void ) const { return !fData || getDeleter().external; }
  int getAllocatedSize() const { return fAllocatedSize; }
  inline float getLeftAngle( void )   const { return fFOV.leftAngle; }
  inline float getTopAngle( void )    const { return fFOV.topAngle; }
  inline float getRightAngle( void )  const { return fFOV.rightAngle; }
  inline float getBottomAngle( void ) const { return fFOV.bottomAngle; }
  inline void getAngles( float& leftAngle, float& topAngle, float& rightAngle, float& bottomAngle )
  const { leftAngle = fFOV.leftAngle; topAngle = fFOV.topAngle;
    rightAngle = fFOV.rightAngle; bottomAngle = fFOV.bottomAngle; }

  /*
     * For debug purpose: print the object in an human format
     */
  std::string toString( void ) const;

  int getNumOfROIs() const { return (int)fROIs.size(); }

  const ROI* getROI(int index) const {
    if (index < 0 || index >= getNumOfROIs())
      return NULL;
    return &(fROIs[index]);
  }

  void addROI(const ROI& rect) {
    fROIs.push_back(rect);
  }

  void cleanROIs() {
    fROIs.clear();
  }

  void setEnableROIs(bool enable) {
    fROIEnabled = enable;
  }

  bool isROIEnabled() const {
    return fROIEnabled;
  }


  int writeFile(const char* _fileNameAndPath);
  int readFile(const char* _fileNameAndPath);
  int savePPM(const char* _fileNameAndPath);

  bool computeYUV422imageFromBGR(int height, int width, char *data);
  bool computeBGRimageFromYUV422(const unsigned char* _dest);
  bool computeYYYUUUVVVimageFromYUV422(const unsigned char* _dest);
  bool computeYYYYUUVVimageFromYUV422(const unsigned char* _dest);
private:
  class deleter
  {
  public:
    deleter(bool external) : external(external) {}
    void operator()(unsigned char* p)
    {
      if (!external && p != NULL)
        delete[] p;
    }
    bool external;
  };
  friend class deleter;

  bool reallocateDataSize(const int resolution, const int nbLayers);
  inline unsigned char* rawData() const { assert( fData ); return fData.get(); }
  inline ALImage::deleter& getDeleter() const
  {
    assert( fData );
    assert( boost::get_deleter<ALImage::deleter>(fData) != NULL );
    return *boost::get_deleter<ALImage::deleter>(fData);
  }
  static boost::shared_ptr<unsigned char[]> internalDataUninitialized(size_t size);
  static boost::shared_ptr<unsigned char[]> internalDataZeroInitialized(size_t size);
  static boost::shared_ptr<unsigned char[]> externalData(unsigned char[]);
  static boost::shared_ptr<unsigned char[]> emptyData(bool external);


  // .:: members ::
private:
  int fWidth;

  int fHeight;

  int fNbLayers;

  int fColorSpace;

  long long fTimeStamp;

  boost::shared_ptr<unsigned char[]> fData;

  char fCameraId;

  int fAllocatedSize;

  int fMaxResolution;

  int fMaxNumberOfLayers;

  struct FOV {
    float leftAngle;
    float topAngle;
    float rightAngle;
    float bottomAngle;
  };
  struct FOV fFOV;

  std::vector<ROI> fROIs;

  bool fROIEnabled;
};
}

// take a pixel in YUV and compute its RGB Value. RGB value are returned directly in params
void computeRgbFromYuv( unsigned char * pYR, unsigned char * pUG, unsigned char * pVB );


#endif  // _LIBALVISION_ALVISION_ALIMAGE_H_