Modules/ImageProcessor/GT2005ImageProcessor/GT2005ImageProcessor.h

Go to the documentation of this file.

/**
* @file GT2005ImageProcessor.h
*
* Definition of class GT2005ImageProcessor
*
* @author <a href="mailto:juengel@informatik.hu-berlin.de">Matthias Juengel</a>
* @author <a href="mailto:roefer@tzi.de">Thomas Röfer</a>
*/

#ifndef __GT2005ImageProcessor_h_
#define __GT2005ImageProcessor_h_

//if defined, GuideDogRobotSpecialist will be used
//#define OC_GUIDEDOG

#include "Modules/ImageProcessor/ImageProcessor.h"
#include "Tools/Debugging/DebugDrawings.h"
#include "Tools/Math/Geometry.h"
#include "Tools/Debugging/DebugImages.h"
#include "Tools/RingBuffer.h"
#include "Modules/ImageProcessor/ImageProcessorTools/ColorCorrector.h"
#include "GT2005ImageProcessorTools.h"
#include "GT2005GoalRecognizer.h"
#include "GT2005BallSpecialist.h"
#include "GT2005BeaconDetector.h"
#include "GT2005EdgeSpecialist.h"
#include "GT2005PlayerSpecialist.h"
#include "Tools/Actorics/RobotDimensions.h"
#include "Tools/RobotConfiguration.h"
#include "Tools/Math/Common.h"
#include "GT2005Clustering.h"
#include "GT2005LineFinder_DeterministicApproach.h"
#include "GT2005CenterCircleFinder.h"


#ifdef OC_GUIDEDOG
#include "GuideDogRobotSpecialist.h"
#endif //OC_GUIDEDOG

/**
* @class GT2005ImageProcessor
*
* The lines image processor recognizes characteristic lines in the image.
* Four types of lines are distinguished:
* edges between the skyblue goal and the field, edges between the yellow goal 
* and the field, edges between the border and the field, and edges between the
* field lines and the field.
*
* The module scans vertical and horizontal lines in the image from top to bottom
* and from left to right. As the green of the field is very dark, all edges are
* characterized by a big difference of the y-channel of adjacent pixels. An
* increase in the y-channel followed by a decrease is an indication for an edge.
*
* The projection of the pixels on the field plane is used to determine their
* relative position to the robot.
*
* @author <a href="mailto:juengel@informatik.hu-berlin.de">Matthias Juengel</a>
* @author <a href="mailto:roefer@tzi.de">Thomas Röfer</a>
*/ 
class GT2005ImageProcessor : public ImageProcessor
{
public:
  /** 
   * Constructor.
   * @param interfaces Collection of references to other objects, e.g. the current image, 
   * required by this module.
   */
  GT2005ImageProcessor(const ImageProcessorInterfaces& interfaces);

  /**
   * Main method. Called on every captured image.
   */
  virtual void execute();

  /**
   * Handles an incoming message
   * @param message The message
   */
  virtual bool handleMessage(InMessage& message);

  /** 
   * Parameters for the scanning grid.
   * Only one in four scanlines run from the horizon to the bottom of the image. In between
   * of those, there are one medium and two short lines, so that the grid is more dense near
   * the horizon.
   * The parameter verticalScanlineSpacing specifies the distance between the vertical scan
   * lines.
   */
  static const double verticalScanLineTopAboveHorizon;
  static const double verticalScanLineLength13;
  static const double verticalScanLineLength2;
  static const double verticalScanLineSpacing;


private: // methods

  /**
   * Calculates the vertical lines and calls scan(...) on each of them. The vertical lines
   * are more dense near the horizon, since objects are further away and hence smaller.
   */
  void scanColumns();

  /** 
   * Calculates the horizontal lines and calls scan 
   */
  void scanRows();

  /** 
   * The function scans a line for varous things (??). 
   * @param start The start point of the line.
   * @param end The end point of the line.
   * @param vertical The scanline is a vertical line (for specialist that differentiate 
   *     between vertical and horizontal scanlines).
   * @param noLines If true, don't look for field lines.
   * @param pixelsRelevantForGoals Number of pixels on the scanline (from the top) that 
   *     are relevant for the GoalRecognizer.
   */
  void scan(const Vector2<int>& start, const Vector2<int>& end,
            bool vertical, bool noLines, int pixelsRelevantForGoal);


private:
  static const double minAngleBetweenFlagAndGoal;
  double xFactor, /**< Factor to convert the pixel coordinate space to the anglular coordinate space. */
         yFactor; /**< Factor to convert the pixel coordinate space to the anglular coordinate space. */
  int yThreshold; /**< Brightness increase threshold. */
  int vThreshold; /**< Brightness decrease threshold. */
  int orangeCount,  /**< Number of columns with ball points. */
      noOrangeCount, /**< Number of columns without a ball point. */
      noRedCount, /**< Number of columns without a red robot point. */
      noBlueCount, /**< Number of columns without a blue robot point. */
      noGoalCount, /**< Number of columns without a opponent goal seen. */
      closestBottom; /**< Closest bottom point on the grid. */
  Vector2<int> firstRed, /**< First red robot point in a cluster. */
               closestRed, /**< Closest red robot point in a cluster. */
               lastRed, /**< Last red robot point in a cluster. */
               firstBlue, /**< First blue robot point in a cluster. */
               closestBlue, /**< Closest blue robot point in a cluster. */
               lastBlue, /**< Last blue robot point in a cluster. */
               firstFlag, /**< First flag point in a cluster. */
               lastFlag, /**< Last flag point in a cluster. */
               lastRedMidPoint, /** Needed for debug drawings */
               lastBlueMidPoint; /** Needed for debug drawings */


  bool goalAtBorder; /**< Is the first goal point at the image border? */


    /** Useful information about the current image that is calculated by the ImageProcessor 
      object and may be used by the specialist (avoiding recalculation) like the horizon, 
    etc. */
  ImageInfo imageInfo;


  int longestBallRun;
  Vector2<int> ballCandidate;
  GT2005Clustering ballClustering;
  GT2005LineFinder_DeterministicApproach lineFinder;
  GT2005CenterCircleFinder circleFinder;

  CameraMatrix cmTricot, /**< Camera matrix without tricot height. */
               prevCmTricot; /**< The tricot matrix of the previous image. */
  // prevCameraMatrix moved to ImageInfo!

  ColorCorrector colorCorrector; /**< The color correction tool. */

  /** Goal specialists to recognize the goals (one for each color). */
  GT2005GoalRecognizer goalSpecialistY, goalSpecialistB;

  /** Other specialists. */
  GT2005BeaconDetector beaconDetector; /**< The beacon detector */
  GT2005BallSpecialist ballSpecialist; /**< The ball specialist. */
  GT2005EdgeSpecialist edgeSpecialist; /**< The edge specialist. */
  GT2005PlayerSpecialist playerSpecialist; /**< The player specialist. */

#ifdef OC_GUIDEDOG
  GuideDogRobotSpecialist guideDogRobotSpecialist;
#endif //OC_GUIDEDOG


  /** 
  * The function calculates the distance to a point to horizon. 
  * @param point The two dimenaional point in the camera image
  * @param distance The distance to horizon
  * @return Is below horizon
  */

  bool pixelBelowHorizon(Vector2<int> point, double &distance);

  /** 
  * The function clusters flag points.
  * @param flagType The type of the flag.
  * @param point The center of the pink area.
  */
  //void clusterFlags(Flag::FlagType flagType, const Vector2<int>& point);

  /**
  * The function filters the percepts, i.e. it removes potential misreadings.
  */
  void filterPercepts();

  /**
  * The function filters the line-percepts, i.e. it removes potential misreadings, for the given line-type.
  */
  void filterLinesPercept(LinesPercept& percept, int type, const Image& image);

  /**
   * The function calculates the angle of an edge at an edge point.
   * @param angleInImage The angle in image coordinates to be determined.
   * @param angleOnField The angle in relative robot field coordinates to be determined.
   * @param pointInImage The edge point in image coordinates.
   * @param pointOnField The edge point in field coordinates.
   * @param scanAngle The angle of the scan line the point was found on.
   * @param pixelBuffer The pixels on the scan line around the edge point.
   * @param againstScanline The flag if bright to dark is detected against the direction of the scanline.
   * @param borderOrLine The flag if this edge belongs to a border or a line (white to green edge).
   * @param channel The channel the gradient is calculated in.
   * @return Whether the angle in field coordinates could be determined
   */
  bool calcEdgeAngle(
    double& angleInImage,
    double& angleOnField,
    const Vector2<int>& pointInImage, 
    const Vector2<int>& pointOnField,
    double scanAngle,
    const RingBuffer<const unsigned char*,7>& pixelBuffer,
    const bool againstScanline = false,
    const bool borderOrLine = true,
    int channel = 0);

 /** 
  * The function converts an address to pixel coordinates.
  * @param p An address in image.image.
  * @return The x- and y-coordinates of the corresponding pixel.
  */
  Vector2<int> getCoords(const unsigned char* p) const
  {
    const int diff(p - &image.image[0][0][0]);
    return Vector2<int>(diff % cameraResolutionWidth_ERS7, diff / (cameraResolutionWidth_ERS7 * 6));
  }

  //!@name Helpers for grid drawing
  //!@{
  const unsigned char* last;
  Drawings::Color lineColor;
  void plot(const unsigned char* p,Drawings::Color color);
  //!@}

  double angleBetweenDirectionOfViewAndGround;

  int numberOfScannedPixels;

  Matrix2x2<double> rotation2x2;

  DECLARE_DEBUG_IMAGE(imageProcessorPlayers);
  DECLARE_DEBUG_IMAGE(imageProcessorGeneral);
  DECLARE_DEBUG_COLOR_CLASS_IMAGE(segmentedImage1);
  DECLARE_DEBUG_IMAGE(imageProcessorBall);
  DECLARE_DEBUG_IMAGE(imageProcessorGradients);

  N_DECLARE_DEBUG_IMAGE(colorCorrected);
  N_DECLARE_DEBUG_IMAGE(colorCorrectedAsJpeg);
  N_DECLARE_DEBUG_COLOR_CLASS_IMAGE(segmented);
  N_DECLARE_DEBUG_IMAGE(ball);
  N_DECLARE_DEBUG_IMAGE(edgeDetection);
  N_DECLARE_DEBUG_GRAY_SCALE_IMAGE(scanLines);
};

#endif// __GT2005ImageProcessor_h_

---