Representations/Perception/Image.cpp

Go to the documentation of this file.

/**
 * @file Image.cpp
 *
 * Implementation of class Image.
 */

#include "Platform/GTAssert.h"
#include "Tools/Streams/InOut.h"
#include "Image.h"
#include "Tools/Math/Common.h"
#include "Modules/ImageProcessor/ImageProcessorTools/ColorModelConversions.h"

Image::Image() : frameNumber(0)
{
  for(int y = 0; y < cameraInfo.resolutionHeight; ++y)
    for(int x = 0; x < cameraInfo.resolutionWidth; ++x)
    {
      image[y][0][x] = 0;
      image[y][1][x] = 128;
      image[y][2][x] = 128;
      image[y][3][x] = 128;
      image[y][4][x] = 128;
      image[y][5][x] = 128;
    }
}

Image::~Image()
{
}

bool Image::hasColorTable(void)
{
  if (colorTable) return true;
  else return false;
}


//int Image::getHeight(void)
//{  return height; }

void Image::setColorTable(const ColorTable* ct)
{
  colorTable = ct;
}


char Image::getClassifiedColor(int x, int y) const
{
  if (colorTable) 
    return colorTable->getColorClass(image[y][0][x], image[y][1][x], image[y][2][x]);
  else return -1;
}

void Image::convertFromYCbCrToRGB(const Image& ycbcrImage)
{
  for(int y=0; y < ycbcrImage.cameraInfo.resolutionHeight; y++)
    for(int x=0; x < ycbcrImage.cameraInfo.resolutionWidth; x++)
      ColorModelConversions::fromYCbCrToRGB(ycbcrImage.image[y][0][x],
                                            ycbcrImage.image[y][1][x],
                                            ycbcrImage.image[y][2][x],
                                            image[y][0][x],
                                            image[y][1][x],
                                            image[y][2][x]);
  this->cameraInfo = ycbcrImage.cameraInfo;
}

void Image::convertFromRGBToYCbCr(const Image& rgbImage)
{
  for(int y=0; y < rgbImage.cameraInfo.resolutionHeight; y++)
    for(int x=0; x < rgbImage.cameraInfo.resolutionWidth; x++)
      ColorModelConversions::fromRGBToYCbCr(rgbImage.image[y][0][x],
                                            rgbImage.image[y][1][x],
                                            rgbImage.image[y][2][x],
                                            image[y][0][x],
                                            image[y][1][x],
                                            image[y][2][x]);
  this->cameraInfo = rgbImage.cameraInfo;
}

void Image::convertFromYCbCrToHSI(const Image& ycbcrImage)
{
  for(int y=0; y < ycbcrImage.cameraInfo.resolutionHeight; y++)
    for(int x=0; x < ycbcrImage.cameraInfo.resolutionWidth; x++)
      ColorModelConversions::fromYCbCrToHSI(ycbcrImage.image[y][0][x],
                                            ycbcrImage.image[y][1][x],
                                            ycbcrImage.image[y][2][x],
                                            image[y][0][x],
                                            image[y][1][x],
                                            image[y][2][x]);
  this->cameraInfo = ycbcrImage.cameraInfo;
}

void Image::convertFromHSIToYCbCr(const Image& hsiImage)
{
  for(int y=0; y < hsiImage.cameraInfo.resolutionHeight; y++)
    for(int x=0; x < hsiImage.cameraInfo.resolutionWidth; x++)
      ColorModelConversions::fromHSIToYCbCr(hsiImage.image[y][0][x],
                                            hsiImage.image[y][1][x],
                                            hsiImage.image[y][2][x],
                                            image[y][0][x],
                                            image[y][1][x],
                                            image[y][2][x]);
  this->cameraInfo = hsiImage.cameraInfo;
}

void Image::convertFromYCbCrToTSL(const Image& ycbcrImage)
{
  for(int y=0; y < ycbcrImage.cameraInfo.resolutionHeight; y++)
    for(int x=0; x < ycbcrImage.cameraInfo.resolutionWidth; x++)
      ColorModelConversions::fromYCbCrToTSL(ycbcrImage.image[y][0][x],
                                            ycbcrImage.image[y][1][x],
                                            ycbcrImage.image[y][2][x],
                                            image[y][0][x],
                                            image[y][1][x],
                                            image[y][2][x]);
  this->cameraInfo = ycbcrImage.cameraInfo;
}

unsigned char Image::getHighResY(int x, int y) const
{
  if ((x & 1) == 0)
    if ((y & 1) == 0)
    {
      // Pixel Top Left       = LL - LH - HL + HH 
      y=y>>1;x=x>>1;
      return (unsigned char) ((int)image[y][0][x] - (int)image[y][3][x] - 128 - (int)image[y][4][x] - 128 + (int)image[y][5][x] - 128);
    } 
    else
    {
      // Pixel Bottom Left    = LL + LH - HL - HH
      y=y>>1;x=x>>1;
      return (unsigned char)((int)image[y][0][x] + (int)image[y][3][x] - 128 - (int)image[y][4][x] - 128 - (int)image[y][5][x] - 128);
    }
  else
    if ((y & 1) == 0)
    {
      // Pixel Top Right      = LL - LH + HL - HH
      y=y>>1;x=x>>1;
      return (unsigned char)((int)image[y][0][x] - (int)image[y][3][x] - 128 + (int)image[y][4][x] - 128 - (int)image[y][5][x] - 128);
    }
    else
    {
      // Pixel Bottom Right   = LL + LH + HL + HH
      y=y>>1;x=x>>1;
      return (unsigned char)((int)image[y][0][x] + (int)image[y][3][x] - 128 + (int)image[y][4][x] - 128 + (int)image[y][5][x] - 128);
    }
}

void Image::setHighResY(int x, int y, unsigned char tl, unsigned char bl, unsigned char tr, unsigned char br) 
{
  image[y][0][x] = ((int) tl + (int)bl + (int)tr + (int)br) / 4;
  image[y][3][x] = ((int)-tl + (int)bl - (int)tr + (int)br) / 4 + 128;
  image[y][4][x] = ((int)-tl - (int)bl + (int)tr + (int)br) / 4 + 128;
  image[y][5][x] = ((int) tl - (int)bl - (int)tr + (int)br) / 4 + 128;
}

Out& operator<<(Out& stream, const Image& image)
{
  stream 
    << image.cameraInfo.resolutionWidth 
    << image.cameraInfo.resolutionHeight 
    << image.frameNumber;

  for(int y = 0; y < image.cameraInfo.resolutionHeight; ++y)
    for(int c = 0; c < 6; ++c)
      stream.write(&image.image[y][c][0], image.cameraInfo.resolutionWidth);

  return stream;
}

void Image::setCameraInfo()
{
  if(cameraInfo.resolutionWidth == cameraResolutionWidth_ERS210)
  {
    cameraInfo.openingAngleWidth = openingAngleWidth_ERS210;
    cameraInfo.openingAngleHeight = openingAngleHeight_ERS210;
    cameraInfo.focalLength = focalLength_ERS210;
    cameraInfo.opticalCenter.x = opticalCenterX_ERS210;
    cameraInfo.opticalCenter.y = opticalCenterY_ERS210;
    cameraInfo.secondOrderRadialDistortion = secondOrderRadialDistortion_ERS210;
    cameraInfo.fourthOrderRadialDistortion = fourthOrderRadialDistortion_ERS210;
  }
  else if(cameraInfo.resolutionWidth == cameraResolutionWidth_ERS7)
  {
    cameraInfo.openingAngleWidth = openingAngleWidth_ERS7;
    cameraInfo.openingAngleHeight = openingAngleHeight_ERS7;
    cameraInfo.focalLength = focalLength_ERS7;
    cameraInfo.opticalCenter.x = opticalCenterX_ERS7;
    cameraInfo.opticalCenter.y = opticalCenterY_ERS7;
    cameraInfo.secondOrderRadialDistortion = secondOrderRadialDistortion_ERS7;
    cameraInfo.fourthOrderRadialDistortion = fourthOrderRadialDistortion_ERS7;
  }
  else
  {
    ASSERT(false); // unknown image size
  }
#ifdef _WIN32
  if(frameNumber > 0x10000000) // is simulated image
  {
    frameNumber -= 0x10000000;
    cameraInfo.focalLength = cameraInfo.resolutionHeight / tan(cameraInfo.openingAngleHeight / 2.0) / 2.0;
    cameraInfo.opticalCenter = Vector2<double>(cameraInfo.resolutionWidth / 2, cameraInfo.resolutionHeight / 2);
    cameraInfo.secondOrderRadialDistortion = cameraInfo.fourthOrderRadialDistortion = 0;
    cameraInfo.simulated = true;
  }
#endif
  cameraInfo.focalLengthInv = 1/cameraInfo.focalLength;
  cameraInfo.focalLenPow2 = cameraInfo.focalLength*cameraInfo.focalLength;  
  cameraInfo.focalLenPow4 = cameraInfo.focalLenPow2*cameraInfo.focalLenPow2;
}

---