EpipolarLine.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#ifndef __EPIPOLARLINE_HH__
#define __EPIPOLARLINE_HH__
#include "bias_config.h"

#include <Base/Geometry/HomgPoint2D.hh>
#include <Base/Geometry/HomgLine2D.hh>
#include <Base/ImageUtils/EightWaySymmetry.hh>
#include <Base/Debug/Debug.hh>
#include <Base/Image/Image.hh>
#include <Geometry/Projection.hh>

#include "EightWaySymmetryHomg.hh"

#include <fstream>
#include <cmath>

#define LOWER 10E-6
#define TWICEPI 6.2831853071795864769252867665590058

#define D_EL_SLOPE 1<<0
#define D_EL_TRANSF 1<<1
#define D_EL_STARTEND 1<<2
#define D_EL_NEWSTARTEND 1<<3
#define D_EL_ROUND 1<<4
#define D_EL_NEXTLINE 1<<5
#define D_EL_OFFSET 1<<6
#define D_EL_BRES 1<<7
#define D_EL_BRESROUND 1<<8
#define D_EL_INT 1<<9


enum TEdge { TopEdge, BottomEdge, LeftEdge, RightEdge, InvalidEdge };

BIASGeometry_EXPORT std::ostream& operator<<(std::ostream& os, const enum TEdge edge);

namespace BIAS{
  /** @ingroup g_geometry
      @brief A class for representing epipolar lines with useful functions like ScanLine().

      Coordinate system is image coo system with origin in upper left image corner.
      Epipole and point at infinty is also stored
      @author Felix Woelk
  */
  class BIASGeometry_EXPORT EpipolarLine : public HomgLine2D, public Debug
  {

  public:

    EpipolarLine();

    EpipolarLine(const EpipolarLine& line);

    EpipolarLine(const Vector3<HOMGLINE2D_TYPE>& vec);

    virtual EpipolarLine& operator=(const EpipolarLine& line);

    virtual ~EpipolarLine();

    inline void SetEpipole(HomgPoint2D& ep)
    { Epipole_ = ep; };

    virtual inline HomgPoint2D& GetEpipole()
    { return Epipole_; };

    virtual inline HomgPoint2D GetCopyOfEpipole() const
    { return Epipole_; };

    /** return type,
        E_NE if 0 < slope < 45 degree
        NE_N if 45 < slop < 90 ... */
    inline enum TLineType GetLineType() const
    { return Type_; }

    /// angle to abszissa (-pi, pi]
    inline double GetAngle() const
    { return Angle_; };

    // returns (unsigned int)ceil(RMin(whole image) - RMin(epipolar line))
    inline double GetROffset() const
    { return ROffset_; };

    inline double GetDx() const
    { return dx_; };

    inline double GetDy() const
    { return dy_; };

    inline HomgPoint2D& GetTransformedStart()
    { return TransformedStart_; };

    inline HomgPoint2D& GetTransformedEnd()
    { return TransformedEnd_; };

    inline HomgPoint2D GetTransformedStart() const
    { return TransformedStart_; };

    inline HomgPoint2D GetTransformedEnd() const
    { return TransformedEnd_; };

    ///
    virtual inline double GetDeltaR() const
    { return DeltaR_; };

    /// distance epipole - close intersection with image border
    virtual inline double GetRMin() const
    { return RMinLine_; }

    /// distance epipole - far intersection with image border
    virtual inline double GetRMax() const
    { return RMaxLine_; }

    ///
    virtual inline HomgPoint2D& GetFarIntersectionWithImageBorder()
    { return FarIntersection_; };

    ///
    virtual inline HomgPoint2D& GetCloseIntersectionWithImageBorder()
    { return CloseIntersection_; };

    ///
    virtual inline HomgPoint2D GetCopyOfFarIntersectionWithImageBorder() const
    { return FarIntersection_; };

    ///
    virtual inline HomgPoint2D GetCopyOfCloseIntersectionWithImageBorder()const
    { return CloseIntersection_; };

    virtual inline enum TEdge GetFarEdge() const
    { return FarEdge_; };

    virtual inline enum TEdge GetCloseEdge() const
    { return CloseEdge_; };

    virtual inline unsigned int GetImageWidth() const
    { return (unsigned int)(rint(maxx_-minx_)+1); };

    virtual inline unsigned int GetImageHeight() const
    { return (unsigned int)(rint(maxy_-miny_)+1); };

    inline void GetImageBoundaries(double& minx, double& miny,
                                   double& maxx, double& maxy) const {
      minx = minx_;
      miny = miny_;
      maxx = maxx_;
      maxy = maxy_;
    }


    virtual inline enum HomgPoint2D::EPosition GetEpipolePosition() const
    { return EpipolePosition_; };

    /** returns next line with maximal possible distance without pixel loss */
    virtual void GetNextLine(bool clockwise, EpipolarLine& next,
                             double dist=1.0);

    /** assumes that data_ is already set
        @author woelk
        @return 0 on success, -1 on error (line out of image) */
    int Recalc(unsigned int width, unsigned int height,
               HomgPoint2D& epipole, enum HomgPoint2D::EPosition epos);

    /** assumes that data_ is already set
        @author koeser
        @return 0 on success, -1 on error (line out of image) */
    int Recalc(const double& minx, const double& miny,
               const double& maxx,const double& maxy,
               HomgPoint2D& epipole, enum HomgPoint2D::EPosition epos);

    /** assumes Width, Height_, data_ and Epipole_ are set correct before
        @author woelk
        @return 0 on success, -1 on error (line out of image) */
    int Recalc();


    virtual void Init(const double& minx, const double& miny,
                      const double& maxx, const double& maxy,
                      HomgPoint2D& epipole, HomgPoint2D& otherpoint,
                      enum HomgPoint2D::EPosition epos);


    virtual void Init(unsigned int width, unsigned int height,
                      HomgPoint2D& epipole, HomgPoint2D& otherpoint,
                      enum HomgPoint2D::EPosition epos);

    /** initialize epipolar line with the two endpoints */
    virtual void Init(unsigned int width, unsigned int height,
                      HomgPoint2D& epipole, HomgPoint2D& otherpoint);

    /** scans epipolar line using bresenham, midpint alg. and 8-way symmetry
        using minimal necessairy pixel step
        fills resulting linear interpolated pixels values in Destination
        allocates Destination if NULL to necessairy size
        sets length to length of Destination
        Destination is filled from ROffset on, only if Destination != NULL
        assumes that HomgLine2D::Vector3<double>::data_ is set
        @return distance image-epipole on ep. line, negative value if error
        @author Felix Woelk */
    virtual double ScanLine(Image<unsigned char>& source,
                            HomgPoint2D& epipole,
                            enum HomgPoint2D::EPosition epos, double RMin,
                            double RMax,
                            bool forward, unsigned int& length,
                            unsigned char* Destination);

    /** draws (*this) into image (only from Pinf to epipole*/
    template <class PixelType>
    void Draw(Image<PixelType>& im);

    /** draws infinite line in image, not stopping at epipole */
    template <class PixelType>
    void DrawWhole(Image<PixelType>& im);

    /** @brief project the plane given by two local rays and the camera center
     *         into the image (ANY projection) using cubemapping
     *  @author koeser 12/2006
     *
     *  Constructs a cubemap with 90 degrees fov for each cube face and
     *  computes the projection of the plane onto the cubefaces (bresenham on
     *  the lines). Forward mapping is used to determine the pixels in the
     *  original image which are marked as being on the line
     *
     *  */
    template <class PixelType>
    static void DrawDistortedLine(const Vector3<double>& epipoleRayOrigImage,
                                  const Vector3<double>& infRayOrigImage,
                                  Image<PixelType>& image,
                                  ProjectionParametersBase* paramsOrig,
                                  PixelType* Color = NULL,
                                  int lineWidth = 1);


    /** @brief visualize the epipolar plane/line as a curve in the image for
     *         any Projection
     *  @author koeser 12/2006
     *
     *  The epipolar plane is defined by the centers of two cameras  (baseline)
     *  and some viewing ray in one of the cameras. This function determines
     *  the plane and uses cube-mapping to project it into some image with
     *  given arbitrary projection. Forward mapping is used, therefore
     *  the line may not be absolutely exact.
     *  Calls DrawDistortedLine() after determining paramerters */
    template <class PixelType>
    static void ProjectEpipolarPlane(const Projection& thisP,
                                     Image<PixelType> &thisIm,
                                     const Vector3<double>& otherCamCenter,
                                     const Vector3<double>& RayDir,
                                     PixelType* Color = NULL,
                                     int lineWidth = 1);

  protected:
    HomgPoint2D Epipole_;
    enum HomgPoint2D::EPosition EpipolePosition_;
    HomgPoint2D PInfinity_;
    enum HomgPoint2D::EPosition PInfinityPosition_;

    enum TLineType Type_;
    ///int Width_; // width of image
    ///int Height_; // height of image
    /// image borders in xdir, typically 0, width-1
    double minx_, maxx_;
    /// image borders in xdir, typically 0, height-1
    double miny_, maxy_;
    double Angle_;  // angle of edge (-pi, pi]
    double DeltaR_; // distance on line resulting from step = 1 on x axis
    HomgPoint2D FarIntersection_; // intersection with close image border
    HomgPoint2D CloseIntersection_; // intersection with far image border
    enum TEdge FarEdge_, CloseEdge_; //
    double RMinLine_, RMaxLine_; // range for r values for this line
    // distance rectified image border, image
    unsigned int ROffset_;
    unsigned int Length_;
    // steps resulting in step=1 on epipolarline, always positive
    // for transformed line
    double dx_, dy_;
    EightWaySymmetryHomg Sym_;
    // just for drawing
    bool SearchOverInf_;

    // used for modified bresenham
    HomgPoint2D Current_;
    HomgPoint2D TransformedStart_, TransformedEnd_;
    HomgPoint2D TransformedCurrent_;
    HomgPoint2D Start_, End_;

    virtual double ScanLine_(Image<unsigned char>& source,
                             unsigned int ROffset,
                             unsigned int& length, unsigned char *Destination,
                             bool forward);
    virtual void CalcTransformed_();

    bool DetermineIntersectionsAndEpipoleDistances_(HomgPoint2D& point);

    virtual void Interpolate_(enum TLineType& type, unsigned char **ida,
                              int& x, int& y, double& g,
                              unsigned char& result);
  };

    /** \struct TIntersect
     * \brief Used in function DetermineStartEnd_
     * \internal */
    struct TIntersect {
        enum TEdge Edge;
        BIAS::HomgPoint2D Point;
        bool IntersectsInImage;
        double EpipoleDistance;
    };

} // namespace

#endif // __EPIPOLARLINE_HH__