alvision/alimage.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALVISION_ALVISION_ALIMAGE_H_
#define _LIBALVISION_ALVISION_ALIMAGE_H_

// upstream opencv headers need cstddef
#include <cstddef>
#include <string>
#include <iostream>
#include <vector>
#include <opencv/cv.h>

#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();

    ALValue toALValue();

    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
    { assert( fData != 0);
      std::cout << "getFrame() is deprecated. Please replace by getData()." << std::endl;
      return fData; }

    inline const unsigned char* getData() const { assert( fData != 0); return fData; }

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

    inline unsigned char* getData() { assert( fData != 0); return fData; }

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

    inline void setTimeStamp(const qi::os::timeval pTimeStamp)
    {
      if( (pTimeStamp.tv_usec < 0) || (pTimeStamp.tv_sec < 0) )
      {
        fTimeStamp = -1;
      }
      setTimeStamp(pTimeStamp.tv_sec, 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 (fWidth==640) ? kVGA : (fWidth==320)?kQVGA:kQQVGA; }
    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 fDataAreExternal; }
    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 )
    { 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(IplImage* _src); //TODO(pev): replace argument for compatibility with ALImage by data pointer and sizes
    bool computeBGRimageFromYUV422(const unsigned char* _dest);
    bool computeYYYUUUVVVimageFromYUV422(const unsigned char* _dest);
    bool computeYYYYUUVVimageFromYUV422(const unsigned char* _dest);

  private:
    bool reallocateDataSize(const int resolution, const int nbLayers);


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

    int fHeight;

    int fNbLayers;

    int fColorSpace;

    long long fTimeStamp;

    unsigned char* fData;

    char fCameraId;

    int fAllocatedSize;

    int fMaxResolution;

    int fMaxNumberOfLayers;

    bool fDataAreExternal;

    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_