Representations/Perception/ColorTable64.cpp

Go to the documentation of this file.

/** 
* @file ColorTable64.cpp
* Implementation of class ColorTable64.
*
* @author <A href=mailto:juengel@informatik.hu-berlin.de>Matthias Jüngel</A>
*/

#include "ColorTable64.h"
#include "Platform/GTAssert.h"

void ColorTable64::generateColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage) const
{
  colorClassImage.width = image.cameraInfo.resolutionWidth;
  colorClassImage.height = image.cameraInfo.resolutionHeight;

  for (register int y = 0; y < image.cameraInfo.resolutionHeight; y++) {
    for (register int x = 0; x < image.cameraInfo.resolutionWidth; x++) {
      colorClassImage.image[y][x] 
        = colorClasses[image.image[y][0][x]/4][image.image[y][1][x]/4][image.image[y][2][x]/4];
    }
  }
}

void ColorTable64::convert32Kto64(const unsigned char* c32k, unsigned char c64[64][64][64])
{
  int c32pos;
  unsigned char mask1, mask2;
  for (int y=0; y<32; y++)
    for (int u=0; u<64; u++)
      for (int v=0; v<64; v++){
        c32pos = ((y/4)<<12)|(u<<6)|v;
        mask1 = 0x0f&c32k[c32pos];
        mask2 = 0x0f&(c32k[c32pos]>>4);
        c64[2*y][v][u] = mask1;
        c64[2*y+1][v][u] = mask2;
      }
}

void ColorTable64::generateHighResColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage
    ) const
{
  colorClassImage.width = image.cameraInfo.resolutionWidth * 2;
  colorClassImage.height = image.cameraInfo.resolutionHeight * 2;

  for (register int y = 0; y < image.cameraInfo.resolutionHeight * 2; y++) {
    for (register int x = 0; x < image.cameraInfo.resolutionWidth * 2; x++) {
      colorClassImage.image[y][x] = colorClasses
        [image.getHighResY(x, y)/4]
        [image.image[y / 2][1][x / 2]/4]
        [image.image[y / 2][2][x / 2]/4];
    }
  }
}

void ColorTable64::generateColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage,
    colorClass colorClass
    ) const
{
  colorClassImage.width = image.cameraInfo.resolutionWidth;
  colorClassImage.height = image.cameraInfo.resolutionHeight;

  for (register int y = 0; y < image.cameraInfo.resolutionHeight; y++) {
    for (register int x = 0; x < image.cameraInfo.resolutionWidth; x++) {
      if(colorClasses[image.image[y][0][x]/4][image.image[y][1][x]/4][image.image[y][2][x]/4] == colorClass)
      {
        colorClassImage.image[y][x] = colorClass;
      }
      else
      {
        colorClassImage.image[y][x] = noColor;
      }
    }
  }
}

void ColorTable64::generateHighResColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage,
    colorClass colorClass
    ) const
{
  colorClassImage.width = image.cameraInfo.resolutionWidth * 2;
  colorClassImage.height = image.cameraInfo.resolutionHeight * 2;

  for (register int y = 0; y < image.cameraInfo.resolutionHeight * 2; y++) {
    for (register int x = 0; x < image.cameraInfo.resolutionWidth * 2; x++) {
      if(colorClasses
        [image.getHighResY(x,y)/4]
        [image.image[y / 2][1][x / 2]/4]
        [image.image[y / 2][2][x / 2]/4] 
        == colorClass)
      {
        colorClassImage.image[y][x] = colorClass;
      }
      else
      {
        colorClassImage.image[y][x] = noColor;
      }
    }
  }
}


ColorTable64::ColorTable64() : format(CT64)
{
  clear();
}

ColorTable64::~ColorTable64() {}

void ColorTable64::addColorClass
(
 colorClass colorClass,
 unsigned char y,
 unsigned char u,
 unsigned char v
 )
{
  this->colorClasses[y/4][u/4][v/4] = colorClass;
}

void ColorTable64::addColorClass
(
 colorClass colorClass,
 unsigned char y,
 unsigned char u,
 unsigned char v,
 unsigned char range
 )
{
  y /= 4;
  u /= 4;
  v /= 4;

  if (y < range / 2) y = range / 2;
  if (u < range / 2) u = range / 2;
  if (v < range / 2) v = range / 2;

  for(unsigned char currentY = y - range / 2; currentY < y - range / 2 + range && currentY < 64; currentY++)
  {
    for(unsigned char currentU = u - range / 2; currentU < u - range / 2 + range && currentU < 64; currentU++)
    {
      for(unsigned char currentV = v - range / 2; currentV < v - range / 2 + range && currentV < 64; currentV++)
      {
        ASSERT(currentY < 64);
        ASSERT(currentU < 64);
        ASSERT(currentV < 64);
        this->colorClasses[currentY][currentU][currentV] = colorClass;
      }
    }
  }
}

void ColorTable64::addCuboidToColorClass
(
 colorClass colorClass,
 unsigned char yMin, 
 unsigned char uMin, 
 unsigned char vMin, 
 unsigned char yMax, 
 unsigned char uMax, 
 unsigned char vMax
 )
{
  yMin /= 4; uMin /= 4; vMin /= 4;
  yMax /= 4; uMax /= 4; vMax /= 4;

  for(unsigned char currentY = yMin; currentY <= yMax; currentY++)
  {
    for(unsigned char currentU = uMin; currentU <= uMax; currentU++)
    {
      for(unsigned char currentV = vMin; currentV <= vMax; currentV++)
      {
        this->colorClasses[currentY][currentU][currentV] = colorClass;
        ASSERT(currentY < 64);
        ASSERT(currentU < 64);
        ASSERT(currentV < 64);
      }
    }
  }
}

void ColorTable64::removeColorClass
(
 unsigned char y,
 unsigned char u,
 unsigned char v,
 unsigned char range
 )
{
  y /= 4;
  u /= 4;
  v /= 4;

  if (y < range / 2) y = range / 2;
  if (u < range / 2) u = range / 2;
  if (v < range / 2) v = range / 2;

  for(unsigned char currentY = y - range / 2; currentY < y - range / 2 + range + 1 && currentY < 64; currentY++)
  {
    for(unsigned char currentU = u - range / 2; currentU < u - range / 2 + range + 1 && currentU < 64; currentU++)
    {
      for(unsigned char currentV = v - range / 2; currentV < v - range / 2 + range + 1 && currentV < 64; currentV++)
      {
        this->colorClasses[currentY][currentU][currentV] = noColor;
      }
    }
  }
}


void ColorTable64::clearChannel(colorClass colorClass)
{
  for (unsigned char y = 0; y < 64; y++)
  {
    for (unsigned char u = 0; u < 64; u++)
    {
      for (unsigned char v = 0; v < 64; v++)
      {
        if (colorClasses[y][u][v] == colorClass) colorClasses[y][u][v] = noColor;
      }
    }
  }
}

void ColorTable64::clear()
{
  for (unsigned char y = 0; y < 64; y++)
  {
    for (unsigned char u = 0; u < 64; u++)
    {
      for (unsigned char v = 0; v < 64; v++)
      {
        this->colorClasses[y][u][v] = noColor;
      }
    }
  }
}

void ColorTable64::getBoxAroundColorClass(colorClass color, 
                                          Vector3<int>& pNear, Vector3<int>& pFar)
{
  pNear = Vector3<int>(0,0,0); 
  pFar = Vector3<int>(255,255,255); 
  unsigned char y(0),u(0),v(0);
  while(y<64)
  {
    u = 0;
    while(u<64)
    {
      v = 0;
      while(v<64)
      {
        if(colorClasses[y][u][v] == color)
        {
          Vector3<int> first(y,u,v);
          pNear = first;
          pFar = first;
          v++;
          goto expandBox;
        }
        v++;
      }
      u++;
    }
    y++;
  }
  return; //Return if the color has not been found
  expandBox:
  while(y<64)
  {
    u = 0;
    while(u<64)
    {
      v = 0;
      while(v<64)
      {
        if(colorClasses[y][u][v] == color)
        {
          Vector3<int> expand(y,u,v);
          if(expand.x < pNear.x)
          {
            pNear.x = expand.x;
          }
          else if(expand.x > pFar.x)
          {
            pFar.x = expand.x;
          }
          if(expand.y < pNear.y)
          {
            pNear.y = expand.y;
          }
          else if(expand.y > pFar.y)
          {
            pFar.y = expand.y;
          }
          if(expand.z < pNear.z)
          {
            pNear.z = expand.z;
          }
          else if(expand.z > pFar.z)
          {
            pFar.y = expand.y;
          }
        }
        v++;
      }
      u++;
    }
    y++;
  }
  pNear *= 4;
  pFar *= 4;
}

Out& operator << (Out& stream, const ColorTable64& colorTable64)
{
  // the old version of the streaming operator, can be used for converting
  // old colortables to new ones (with the VC debugger)
//  stream.write(&colorTable64.colorClasses,sizeof(colorTable64.colorClasses));
//  return stream;


  // the current color class in the color table
  unsigned char currentColorClass = (unsigned char)(colorTable64.colorClasses[0][0][0]);

  // the next color class to be compared with the last one 
  unsigned char nextColorClass;

  // a pointer to the begin of the color table
  const unsigned char* colorTable = (const unsigned char*)&colorTable64.colorClasses;

  // the number of bytes in one sequence that have the same color class
  int currentLength = 1;

  for (unsigned int i=1;i<sizeof(colorTable64.colorClasses);i++)
  {
    nextColorClass = colorTable[i];
    
    if (nextColorClass != currentColorClass)
    {
      stream << currentLength << currentColorClass;
      currentColorClass = nextColorClass;
      currentLength = 1;
    }
    else
    {
      currentLength++;
    }
  }
  stream << currentLength << currentColorClass;

  // write a 0 at the end of the stream as a marker for the In streaming operator
  stream << (int)0;

  return stream;
}

//~ In& operator>>(In& stream,ColorTable64& colorTable64)
//~ {
  //~ // the old version of the streaming operator, can be used for converting
  //~ // old colortables to new ones (with the VC debugger)
//~ //  stream.read(&colorTable64.colorClasses,sizeof(colorTable64.colorClasses));
//~ //  return stream;

  //~ // a pointer to the begin of the color table
  //~ unsigned char* colorTable = (unsigned char*)&colorTable64.colorClasses;

  //~ // the current color class in the color table
  //~ unsigned char currentColorClass;

  //~ // the number of bytes in one sequence that have the same color class
  //~ unsigned int currentLength;

  //~ // the position in the color table
  //~ unsigned int pos=0;

  //~ while(pos < sizeof(colorTable64.colorClasses))
  //~ {
    //~ stream >> currentLength;
    //~ if (currentLength == 0)
      //~ if(!pos) // support for old format that contains table size
        //~ stream >> currentLength >> currentLength; // skip length
      //~ else
        //~ break;
    //~ stream >> currentColorClass;
    
    //~ for (unsigned int i=0;i<=currentLength && i + pos < sizeof(colorTable64.colorClasses);i++)
    //~ {
      //~ colorTable[i+pos] = currentColorClass;
      //~ if (i+pos > sizeof(colorTable64.colorClasses) - 1)
        //~ break;;
    //~ }

    //~ pos += currentLength;
  //~ }

  //~ return stream;
//~ }


In& operator>>(In& stream,ColorTable64& colorTable64)
{
  // the old version of the streaming operator, can be used for converting
  // old colortables to new ones (with the VC debugger)
//  stream.read(&colorTable64.colorClasses,sizeof(colorTable64.colorClasses));
//  return stream;

  // a pointer to the begin of the color table
  unsigned char* colorTable;
  unsigned int colorTableSize;
  if (colorTable64.format == ColorTable64::CT32K)
  {
    colorTableSize = ColorTable64::CT32K_SIZE;
    colorTable = new unsigned char[ColorTable64::CT32K_SIZE];
  }
  else
  {
    colorTableSize = ColorTable64::CT64_SIZE;
    colorTable = (unsigned char*)&colorTable64.colorClasses;
  }

  // the current color class in the color table
  unsigned char currentColorClass;

  // the number of bytes in one sequence that have the same color class
  unsigned int currentLength;

  // the position in the color table
  unsigned int pos=0;

  while(pos < colorTableSize)
  {
    stream >> currentLength;
    if (currentLength == 0)
      if(!pos) // support for old format that contains table size
        stream >> currentLength >> currentLength; // skip length
      else
        break;
    stream >> currentColorClass;
    
    for (unsigned int i=0;i<=currentLength && i + pos < colorTableSize; i++)
    {
      colorTable[i+pos] = currentColorClass;
      if (i+pos > colorTableSize - 1)
        break;
    }

    pos += currentLength;
  }

  if (colorTable64.format == ColorTable64::CT32K)
  {
    ColorTable64::convert32Kto64(colorTable, colorTable64.colorClasses);
    delete [] colorTable;
  }
  
  return stream;
}
bool ColorTable64::hasXNeighbors(unsigned char y, unsigned char u, unsigned char v, int x, unsigned char cc[64][64][64])
{
  int neighbours = 0;
  unsigned char c = cc[y][u][v];
  if (y > 0)
  {
    if (cc[y-1][u][v] == c) 
    {
      neighbours++;
    }
  }
  if (u > 0)
  {
    if (cc[y][u-1][v] == c)
    {
      neighbours++;
    }
  }
  if (v > 0)
  {
    if (cc[y][u][v-1] == c) 
    {
      neighbours++;
    }
  }
  if (y < 63)
  {
    if (cc[y+1][u][v] == c) 
    {
      neighbours++;
    }
  }
  if (u < 63)
  {
    if (cc[y][u+1][v] == c) 
    {
      neighbours++;
    }
  }
  if (v < 63)
  {
    if (cc[y][u][v+1] == c) 
    {
      neighbours++;
    }
  }
  if (neighbours >= x) 
  {
    return true;
  }
  else
  {
    return false;
  }
}

unsigned char ColorTable64::getNeighborColor(unsigned char y, unsigned char u, unsigned char v, unsigned char cc[64][64][64])
{
  unsigned char returnColor = cc[y][u][v];
  if(returnColor != noColor) 
  {
    return returnColor;
  }
  else
  {
    if (y > 0)
    {
      if (cc[y-1][u][v] != noColor) 
      {
        returnColor = cc[y-1][u][v];
      }
    }
    if (u > 0)
    {
      if (cc[y][u-1][v] != noColor)
      {
        returnColor = cc[y][u-1][v];
      }
    }
    if (v > 0)
    {
      if (cc[y][u][v-1] != noColor) 
      {
        returnColor = cc[y][u][v-1];
      }
    }
    if (y < 63)
    {
      if (cc[y+1][u][v] != noColor) 
      {
        returnColor = cc[y+1][u][v];
      }
    }
    if (u < 63)
    {
      if (cc[y][u+1][v] != noColor) 
      {
        returnColor = cc[y][u+1][v];
      }
    }
    if (v < 63)
    {
      if (cc[y][u][v+1] != noColor) 
      {
        returnColor = cc[y][u][v+1];
      }
    }  
    return returnColor;
  }
}

void ColorTable64::shrink()
{
  unsigned char cc2[64][64][64];
  memcpy(cc2, colorClasses, sizeof(colorClasses));
  unsigned char y,u,v;
  for (y = 0; y < 64; y++)
  {
    for (u = 0; u < 64; u++)
    {
      for (v = 0; v < 64; v++)
     {
        if (!hasXNeighbors(y,u,v,6,cc2))
        {
          this->colorClasses[y][u][v] = noColor;
        }
      }
    }
  }
}

void ColorTable64::shrink(unsigned char color)
{
  unsigned char cc2[64][64][64];
  memcpy(cc2, colorClasses, sizeof(colorClasses));
  unsigned char y,u,v;
  for (y = 0; y < 64; y++)
  {
    for (u = 0; u < 64; u++)
    {
      for (v = 0; v < 64; v++)
      {
        if (!hasXNeighbors(y,u,v,6,cc2)&&cc2[y][u][v] == color)
        {
          this->colorClasses[y][u][v] = noColor;
        }
      }
    }
  }
}

void ColorTable64::grow()
{
  unsigned char cc2[64][64][64];
  memcpy(cc2, colorClasses, sizeof(colorClasses));
  unsigned char y,u,v;
  for (y = 0; y < 64; y++)
  {
    for (u = 0; u < 64; u++)
    {
      for (v = 0; v < 64; v++)
      {
        if (hasXNeighbors(y,u,v,1,cc2))
        {
          colorClasses[y][u][v] = getNeighborColor(y,u,v,cc2);
        }
      }
    }
  }
}

void ColorTable64::grow(unsigned char color)
{
  unsigned char cc2[64][64][64];
  memcpy(cc2, colorClasses, sizeof(colorClasses));
  unsigned char y,u,v;
  for (y = 0; y < 64; y++)
  {
    for (u = 0; u < 64; u++)
    {
      for (v = 0; v < 64; v++)
      {
        if (hasXNeighbors(y,u,v,1,cc2)&&getNeighborColor(y,u,v,cc2)==color)
        {
          colorClasses[y][u][v] = getNeighborColor(y,u,v,cc2);
        }
      }
    }
  }
}

---