Modules/ImageProcessor/ImageProcessorTools/ImageProcessorUtilityClasses.h

Go to the documentation of this file.

#ifndef __ImageProcessorUtilityClasses_h_
#define __ImageProcessorUtilityClasses_h_


#include "Tools/Math/Vector2.h"
#include "Tools/Math/Matrix2x2.h"

/**
* @class ImageInfo
*
* Useful information about the current image, computed by the ImageProcessor. The 
* Specialists may use this information without the need to recompute it.
*/
class ImageInfo
{

public:
  /** The horizon (normalized) */
  Geometry::Line horizon;
  /** A line perpendicular to the horizon (normalized) */
  Geometry::Line vertLine;
  /** Flag, indicates whether the horizon is in the image or not*/
  bool horizonInImage;
  /** The starting point of the horizon*/
  Vector2<int> horizonStart;
  /** The end point of the horizon*/
  Vector2<int> horizonEnd;
  /** The bottom right corner of the image*/
  Vector2<int> maxImageCoordinates;

  /** The cameraMatrix of the previous image (more precisely, the last image processed by the 
      ImageProcessor. */
  CameraMatrix previousCameraMatrix;

  /** 
   * The rotation from a horizon-aligned coordinate system to the image coordinate 
   * system. The horizon-aligned coordinate system is defined as follows:
   *  - the x-coordinate points parallel to the horizon to the right
   *  - the y-coordinate points perpendicular to the horizon downwards
   *  - the origin is the top left corner of the image, i.e. the same as the the origin
   *    of the image coordinate system. Thus the transformation from horizon-aligned to
   *    image coordinates only requires the rotation matrix. 
   * @author <a href="oberlies@sim.tu-darmstadt.de">Tobias Oberlies</a>
   */
  Matrix2x2<double> rotation;

  /**
   * The rotation from the image coordinates to the horizon-aligned coordinates.
   */
  Matrix2x2<double> invRotation;

  /**
   * The distance of the top left corner to the horizon. This value is the same as the 
   * y-coordinate of the horizon in the horizon-aligned coordinate system.
   */
  double distanceTopLeftCorner;

  /**
   * Converts image coordintates into coordinates in the horizon-aligned coordinate system.
   * @param point The point in image coordinates.
   * @return The point in horizon-aligned coordinates.
   */
  inline Vector2<double> toHorizonAligned(const Vector2<int>& imageCoord) const
  {
    return invRotation * Vector2<double>(static_cast<double>(imageCoord.x), static_cast<double>(imageCoord.y));
  }

  /**
   * Calculates the x-coordinate in the horizon-aligned coordinate system of a point in 
   * image coordinates.
   * @param point The point in image coordinates.
   * @return The x-coordinate of the point in horizon-aligned coordinates.
   */
  inline double horizonAlignedXOf(const Vector2<int>& imageCoord) const
  {
    return invRotation.c[0].x * static_cast<double>(imageCoord.x)
         + invRotation.c[1].x * static_cast<double>(imageCoord.y);
  }

  /**
   * Calculates the y-coordinate in the horizon-aligned coordinate system of a point in 
   * image coordinates.
   * @param point The point in image coordinates.
   * @return The y-coordinate of the point in horizon-aligned coordinates.
   */
  inline double horizonAlignedYOf(const Vector2<int>& imageCoord) const
  {
    return invRotation.c[0].y * static_cast<double>(imageCoord.x)
         + invRotation.c[1].y * static_cast<double>(imageCoord.y);
  }

  /**
   * Converts coordintates in the horizon-aligned coordinate system into image coordinates.
   * No clipping is done.
   * @param point The point in horizon-aligned coordinates.
   * @return The point in image coordinates.
   */
  inline Vector2<int> toImageCoordinates(const Vector2<double>& horizonAlignedCoord) const
  {
    Vector2<double> result = rotation * horizonAlignedCoord;
    return Vector2<int>(static_cast<int>(result.x), static_cast<int>(result.y));
  }

  /**
   * Converts coordintates in the horizon-aligned coordinate system into image coordinates.
   * No clipping is done.
   * @param x The x-coordinate in the horizon-aligned coordinate system.
   * @param y The y-coordinate in the horizon-aligned coordinate system.
   * @return The point in image coordinates.
   */
  inline Vector2<int> toImageCoordinates(double x, double y) const
  {
    return Vector2<int>(static_cast<int>(rotation.c[0].x*x + rotation.c[1].x*y), 
                        static_cast<int>(rotation.c[0].y*x + rotation.c[1].y*y));
  }

  /**
   * Clip the point to the image boundary.
   * @param point Point that is moved so that it is within the image boundary.
   */
  inline void clipToImageBoundary(Vector2<int>& point) const
  {
    if (point.x < 0)
      point.x = 0;
    if (point.x > maxImageCoordinates.x)
      point.x = maxImageCoordinates.x;
    if (point.y < 0)
      point.y = 0;
    if (point.y > maxImageCoordinates.y)
      point.y = maxImageCoordinates.y;
  }
};


/**
* @class Run
*
* Describes a sequence of pixels of the same colour
*/
class Run
{
public:
  /** Constructor*/
  Run():length(0) {}

  /** The first point*/
  Vector2<int> start;
  /** The last point*/
  Vector2<int> end;
  /** The first point of the corresponding scan line*/
  Vector2<int> scanLineStart;
  /** The length of the run*/
  int length;
  /** The color*/
  colorClass color;
};


/**
* @class TransformedRun
*
* Special class for comparing and clustering runs
*/
class TransformedRun
{
public:
  /** Computes values
  * @param run An original run
  * @param rotMat The rotation matrix
  * @param numOfRun The number of the transformed run
  */
  void transform(const Run& run, const Matrix2x2<double>& rotMat, int numOfRun)
  {
    start.x = (double)(run.start.x - run.scanLineStart.x);
    start.y = (double)(run.start.y - run.scanLineStart.y);
    end.x = (double)(run.end.x - run.scanLineStart.x);
    end.y = (double)(run.end.y - run.scanLineStart.y);
    start = (rotMat*start);
    end = (rotMat*end);
    start.x += (double)run.scanLineStart.x;
    start.y += (double)run.scanLineStart.y;
    end.x += (double)run.scanLineStart.x;
    end.y += (double)run.scanLineStart.y;
    this->numOfRun = numOfRun;
  }

  /** The first point*/
  Vector2<double> start;
  /** The last point*/
  Vector2<double> end;
  /** Number of corresponding real run*/
  int numOfRun;
};


#endif

---