Representations/Perception/ColorTable64.h

Go to the documentation of this file.

/** 
* @file ColorTable64.h
* Declaration of class ColorTable64.
*
* @author <A href=mailto:juengel@informatik.hu-berlin.de>Matthias Jüngel</A>
* @author <A href=mailto:martin@martin-loetzsch.de>Martin Lötzsch</A>
*/

#ifndef _ColorTable64_h_
#define _ColorTable64_h_

// forward declaration
class ColorTable64;

#include "ColorTable.h"
#include "Tools/Streams/InOut.h"
#include "Tools/Math/Vector3.h"
#include "ColorClassImage.h"
#include "Image.h"

/**
* @class ColorTable64
*
* Contains a ColorTable64 which can decode the color for
* every 4 * 4 * 4 cube in the 255 * 255 * 255 YUV color space.
*
* @author <A href=mailto:juengel@informatik.hu-berlin.de>Matthias Jüngel</A>
* @author <A href=mailto:martin@martin-loetzsch.de>Martin Lötzsch</A>
*/
class ColorTable64 : public ColorTable
{
public:
  /** Constructor */
  ColorTable64();

  /** Destructor */
  ~ColorTable64();

  enum Format {CT32K, CT64};

  /** 
  * Calculates the color class of a pixel.
  * @param y the y value of the pixel
  * @param u the u value of the pixel
  * @param v the v value of the pixel
  * @return the color class
  */
  virtual colorClass getColorClass (const unsigned char y, 
    const unsigned char u, 
    const unsigned char v) const
  {
    return (colorClass) colorClasses[y/4][u/4][v/4];
  }

  /**
  * Computes an axis aligned box around all positions of a specified color
  * in YUV space
  * @param color The color
  * @param pNear The corner of the box nearest to the origin
  * @param pFar The corner of the box farthest to the origin
  */
  void getBoxAroundColorClass(colorClass color, 
                              Vector3<int>& pNear, Vector3<int>& pFar);
  /**
  * Segments an image to an color class image.
  * 
  * This doesn't need to used in the image processor, but is needed for visualisation
  * of color tables.
  * @param image A reference to the image to be segmented
  * @param colorClassImage A reference to the color class image to be created
  */
  virtual void generateColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage) const;

  /**
  * Generates an image that contains all pixels that have the specified color class.
  * 
  * @param image A reference to the image to be segmented
  * @param colorClassImage A reference to the color class image to be created
  * @param colorClass The color class. 
  */
  virtual void generateColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage,
    colorClass colorClass
    ) const;

  /**
  * Segments an image to an color class image.
  * 
  * This doesn't need to used in the image processor, but is needed for visualisation
  * of color tables.
  * @param image A reference to the image to be segmented
  * @param colorClassImage A reference to the color class image to be created
  */
  virtual void generateHighResColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage) const;

  /**
  * Generates an image that contains all pixels that have the specified color class.
  * 
  * @param image A reference to the image to be segmented
  * @param colorClassImage A reference to the color class image to be created
  * @param colorClass The color class. 
  */
  virtual void generateHighResColorClassImage(const Image& image, 
    ColorClassImage& colorClassImage,
    colorClass colorClass
    ) const;

  /** 
  * The color table.
  * Each element in the array contains the color class of a 4x4x4 cube in the color space.
  */
  unsigned char colorClasses[64][64][64];

  //!@name Members to be used by the ColorTable64 dialog
  //!@{

  /** Sets the color class of every 4x4x4 to noColor */
  void clear();
  
  /** Sets all cubes that have the given color class to noColor */
  void clearChannel(colorClass colorClass);
  
  /** 
  * Sets the color class for a pixel in the color space given by y, u, v
  * to the given color class.
  */
  void addColorClass(
    colorClass colorClass,
    unsigned char y,
    unsigned char u,
    unsigned char v
    );

  /** 
  * Sets the color class for a cube with the size "range" around a pixel
  * given by y,u,v to the given color class.
  */
  void addColorClass(
    colorClass colorClass,
    unsigned char y, 
    unsigned char u, 
    unsigned char v, 
    unsigned char range
    );

  /**
  * Sets the color class for all sub cubes within the specified cuboid to the given color class.
  */
  void addCuboidToColorClass(
    colorClass colorClass,
    unsigned char yMin, 
    unsigned char uMin, 
    unsigned char vMin, 
    unsigned char yMax, 
    unsigned char uMax, 
    unsigned char vMax
    );
  
  /**
  * Sets the color class for a cube with the size "range" around a pixel
  * given by y,u,v to noColor.
  */
  void removeColorClass(
    unsigned char y, 
    unsigned char u, 
    unsigned char v, 
    unsigned char range
    );

  void setFormat(Format form)
  {
    format = form;
  }
  
  enum {CT32K_SIZE = 8*64*64, CT64_SIZE = 64*64*64};

  /**
   * Streaming operator that reads a ColorTable64 from a stream.
   * @param stream The stream from which is read.
   * @param colorTable64 The ColorTable64 object.
   * @return The stream.
   */ 
  friend In& operator>>(In& stream,ColorTable64& colorTable64);
  //!@}

  /**
  * This function marks the outer pixels of all segmented colors in the colorspace as noColor.
  */
  void shrink();

  /**
  * This function marks the outer pixels of the parameter color in the colorspace as noColor.
  * &param color The color to shrink
  */
  void shrink(unsigned char color);

  /**
  * This function marks all noColor pixels in the colorspace, which are neighbors of segmented 
  * pixels, with the neighboring color.
  */
  void grow();

  /**
  * This function marks all noColor pixels in the colorspace, which are neighbors of the parameter color, 
  * with the neighboring color.
  */
  void grow(unsigned char color);

private:   
  
  Format format;

  static void convert32Kto64(const unsigned char* c32k, unsigned char c64[64][64][64]);
  
  /**
  * Returns true if the pixel y,u,v in the  colorClassesArray has more than x or x neighbors.
  * @param y the y coordinate of the pixel in the colorspace
  * @param u the u coordinate of the pixel in the colorspace
  * @param v the v coordinate of the pixel in the colorspace
  * @param x the number of desired pixels
  * @param colorClassesArray the Array with the colorClasses
  */
  bool hasXNeighbors(unsigned char y, unsigned char u, unsigned char v, int x, unsigned char colorClassesArray[64][64][64]);

  /**
  * Returns the color of one of the neighboring pixels of the pixel y,u,v.
  * If no direct neighbor is present, noColor s returned.
  * @param y the y coordinate of the pixel in the colorspace
  * @param u the u coordinate of the pixel in the colorspace
  * @param v the v coordinate of the pixel in the colorspace
  * @param colorClassesArray the Array with the colorClasses
  */
  unsigned char getNeighborColor(unsigned char y, unsigned char u, unsigned char v, unsigned char colorClassesArray[64][64][64]);

};

/**
 * Streaming operator that writes a ColorTable64 to a stream.
 * @param stream The stream to write on.
 * @param colorTable64 The ColorTable64 object.
 * @return The stream.
 */ 
Out& operator<<(Out& stream, const ColorTable64& colorTable64);

#endif   //  _ColorTable64_h_

---