aibocam.h

Go to the documentation of this file.

// ***************************************************************************
//                           aibocam.h
//
//    copyright            : (C) 2003 by tbaier
//    email                : tbaier@informatik.uni-hamburg.de
// ***************************************************************************

#ifndef AIBOCAM_H
#define AIBOCAM_H
  

//std includes
#include <math.h>
#include <stdio.h>

//AIBO includes
#include <OPENR/ODataFormats.h>
#include <OPENR/OFbkImage.h>
#include <OPENR/OPENRAPI.h>
#include <OPENR/OSyslog.h>
#include <Types.h>

#include "BMP.h"

static const char* const FBK = "PRM:/r1/c1/c2/c3/i1-FbkImageSensor:F1";

static const int NUM_CDT_SEG      = 32;

static const double  FIELD_VIEW_H = 57.6;
static const double  FIELD_VIEW_V = 47.8;


struct CdtData{
  int segment; 
  byte cr_max; 
  byte cr_min; 
  byte cb_max; 
  byte cb_min; 
};


enum WHITE_BALANCE{
  INDOOR  = 1,              
  DEFAULT = 2,              
  OUTDOOR = 3               
};

enum SHUTTER_SPEED{
  SLOW   = 1,               
  MEDIUM = 2,               
  FAST   = 3                
};

enum CAM_GAIN{
  LOW  = 1,                 
  MID  = 2,                 
  HIGH = 3                  
};

enum LAYER{
  RAW_Y,
  RAW_Cr,
  RAW_Cb,
  RAW_GradX,
  RAW_GradY,
  RAW_Mag
};

class AiboCam {

 public:
  AiboCam();

  virtual ~AiboCam();
  
  void OpenPrimitive();



  void SetCdtChannels(const int numChannels);


  int GetCdtChannels() const;


  void SetCdtVectorDataOfPinkBall(const int channel=0);

  void SetCdtVectorDataOfPinkBallSpecial(const int channel = 0);

   void SetCdtTable(const int channel, const CdtData table[32]);

   int GetColorFrequency(OFbkImageVectorData* imageVec, const int channel = 0);
   
   int GetColorFrequency(OFbkImageVectorData* imageVec, const OCdtChannel channel = ocdtCHANNEL0);


   bool GetCenter(OFbkImageVectorData* imageVec, int cdtChannel, int &xCenter, int &yCenter);

   bool GetCenter(OFbkImageVectorData* imageVec, 
                  int cdtChannel, 
                  int *xCenter, int *yCenter);

   bool GetCenter(const OFbkImage& cdtImage, 
                  const int cdtChannel , 
                  int *xCenter, int *yCenter);
          

   bool GetCenter(const OFbkImage& cdtImage, 
                  const OCdtChannel& cdtChannel , 
                  int *xCenter, int *yCenter);
          
   void saveCDT(char *fileName, CdtData cdt[32]) const ;

   CdtData * loadCDT(char *fileName);



  void SetWhiteBalance(WHITE_BALANCE balance);

  void SetShutterSpeed(SHUTTER_SPEED speed);
  
  void SetGain(CAM_GAIN gain);
 


  void SaveRawData(char* path,
                   OFbkImageVectorData* imageVec, 
                   const OFbkImageLayer layer) const;
 
  void SaveBMP(char *path, 
               OFbkImageVectorData* imageVec,
               const OFbkImageLayer layer) const;
  
  
  void SaveCdtBMP(char *basepath,
                  OFbkImageVectorData* imageVec) const;
  
  


  
  OFbkImage GetYImage(OFbkImageVectorData* imageVec,
                      const OFbkImageLayer layer);

  OFbkImage GetCbImage(OFbkImageVectorData* imageVec,
                       const OFbkImageLayer layer);

  OFbkImage GetCrImage(OFbkImageVectorData* imageVec,
                       const OFbkImageLayer layer);

  OFbkImage GetCdtImage(OFbkImageVectorData* imageVec);

  int GetImageWidth(OFbkImage *image) const;


  int GetImageHeight(OFbkImage *image) const;

  byte * GetImageData(OFbkImageVectorData* imageVec, const OFbkImageLayer layer);

  void GetYCrCbData(byte *ycrcbImage, 
                    OFbkImageVectorData* imageVec, const OFbkImageLayer layer) const;



  //  void GetYCrCbDataOPENR(byte *ycrcbImage, 
  //                     OFbkImageVectorData* imageVec, const OFbkImageLayer layer) const;


  byte * GetImageData(OFbkImage *image);
    
    
  byte * GetImageData(const OFbkImage& image);
    


  // 
  // /** Sets the local OFbkImageVectorData 
  //  * @param vecData The image vector 
  //  * @see *FbkImageVectorData
  //  */
  // void SetImageVectorData(OFbkImageVectorData *vecData);
  

  //OFbkImageVectorData** GetImageVectorData();


  void RAW2(byte *outImage,  
            byte *rawImage, 
            const int width, const int height, 
            const LAYER l) const;
  

 protected:
  //Functions:


  void YCrCb2RGB(byte y, byte cr, byte cb, byte* r, byte* g, byte* b) const;

  
  void YCrCb2RGB(byte *rgbImage,  
                 byte *ycrcbImage, 
                 const int width, const int height) const;
    

  void RAW2RGB(byte *rgbImage,  
               byte *rawImage, 
               const int width, const int height) const;



  void RAW2YCrCb(byte *ycrcbImage,  
                 byte *rawImage, 
                 const int width, const int height) const;
  

  //VARS:
  OPrimitiveID        FbkID;
  
  OCdtVectorData      *CdtVector;
  
  MemoryRegionID      CdtVectorID;

  // /** Vector of image data*/
  // OFbkImageVectorData *FbkImageVectorData;
};


// *******************************
// *                             *
// *******************************
inline int AiboCam::GetCdtChannels() const
{
  return (CdtVector->vectorInfo.numData);
};


// *******************************
// *                             *
// *******************************
inline int AiboCam::GetImageWidth(OFbkImage *image) const
{
  return image->Width();
};

// *******************************
// *                             *
// *******************************
inline int AiboCam::GetImageHeight(OFbkImage *image) const
{
  return image->Height();
};



// *******************************
// *                             *
// *******************************
inline byte * AiboCam::GetImageData(OFbkImage *image) 
{
  return image->Pointer();
};

// *******************************
// *                             *
// *******************************
inline byte * AiboCam::GetImageData(const OFbkImage& image)
{
  return image.Pointer();
};



// *******************************
// *                             *
// *******************************
inline void AiboCam::YCrCb2RGB(byte y, byte cr, byte cb, byte* r, byte* g, byte* b) const
{
    // offset binary [0, 255] -> signed char [-128, 127]
    sbyte scr = (sbyte)(cr ^ 0x80);
    sbyte scb = (sbyte)(cb ^ 0x80);

    double Y  = (double)y / 255.0;   //  0.0 <= Y  <= 1.0
    double Cr = (double)scr / 128.0; // -1.0 <= Cr <  1.0
    double Cb = (double)scb / 128.0; // -1.0 <= Cb <  1.0

    double R = 255.0 * (Y + Cr);
    double G = 255.0 * (Y - 0.51*Cr - 0.19*Cb);
    double B = 255.0 * (Y + Cb);

    if (R > 255.0) {
        *r = 255;
    } else if (R < 0.0) {
        *r = 0;
    } else {
        *r = (byte)R;
    }

    if (G > 255.0) {
        *g = 255;
    } else if (G < 0.0) {
        *g = 0;
    } else {
        *g = (byte)G;
    }

    if (B > 255.0) {
        *b = 255;
    } else if (B < 0.0) {
        *b = 0;
    } else {
        *b = (byte)B;
    }
};


// *******************************
// *                             *
// *******************************
inline void AiboCam::RAW2YCrCb(byte *ycrcbImage,  
                               byte *rawImage, 
                               const int width, const int height) const
{
  byte *dstPtr = ycrcbImage;

  byte in1, in2, in3;
  byte out1, out2, out3;

  int counter = 0;
  int line = 0;

  dstPtr += 3;
  for(int x = 0; x < width*height ; x++){
    
    if(line == width-1){
      //        std::cout << " 1: jump from " << counter ;
      counter += 5*width+1; 
      //std::cout << " to " << counter << std::endl; 
      line = 0;
    }
    else{
      counter++;
      line++;
    }
    
    *dstPtr++ = rawImage[counter];
    *dstPtr++ = rawImage[counter+width];
    *dstPtr++ = rawImage[counter+width*2];
  }
};



// *******************************
// *                             *
// *******************************
inline void AiboCam::RAW2RGB(byte *rgbImage,  
                             byte *rawImage, 
                             const int width, const int height) const
{
  byte *dstPtr = rgbImage;

  byte in1, in2, in3;
  byte out1, out2, out3;

  int counter = 0;
  int line = 0;

  dstPtr += 3;
  for(int x = 0; x < width*height ; x++){

      if(line == width-1){
        //      std::cout << " 1: jump from " << counter ;
        counter += 5*width+1; 
        //std::cout << " to " << counter << std::endl; 
        line = 0;
      }
      else{
        counter++;
        line++;
      }

    in1 = rawImage[counter];
    in2 = rawImage[counter+width];
    in3 = rawImage[counter+width*2];

    YCrCb2RGB(in1, in2, in3, &out1, &out2, &out3);

    *dstPtr++ = out1;
    *dstPtr++ = out2;
    *dstPtr++ = out3;
  }
};

// *******************************
// *                             *
// *******************************
inline void AiboCam::YCrCb2RGB(byte *rgbImage,  
                               byte *ycrcbImage, 
                               const int width, const int height) const
{
  byte *srcPtr = ycrcbImage;
  byte *dstPtr = rgbImage;

  byte in1, in2, in3;
  byte out1, out2, out3;

  for(int x = 0; x < width*height ; x++){

    in1 = *srcPtr++;
    in2 = *srcPtr++;
    in3 = *srcPtr++;

    YCrCb2RGB(in1, in2, in3, &out1, &out2, &out3);

    *dstPtr++ = out1;
    *dstPtr++ = out2;
    *dstPtr++ = out3;
  }

};


// *******************************
// *                             *
// *******************************
inline void AiboCam::RAW2(byte *outImage,  
                          byte *rawImage, 
                          const int width, const int height, 
                          const LAYER l) const
{
  int line = 0;
  int add = l*width;
  
  for(int x = 1; x < width*height+1; x++){
    
    if(line == width-1){
      add += 5*width+1; 
      line = 0;
    }
    else{
      add++;
      line++;
    }
    
    outImage[x] = rawImage[add];
  }
  
};



#endif //define AIBOCAM_H

---

Tim Baier AiboLib v0.2.4

Generated Thu Jan 19 11:54:29 2006 by 1.4.3