HomgLine2D.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 __HOMGLINE2D_HH__
#define __HOMGLINE2D_HH__
#include "bias_config.h" 

#include <Base/Debug/Error.hh>
#include <Base/Debug/Debug.hh>

#include <Base/Math/Vector3.hh>

#include "HomgPoint2D.hh"

#define HOMGLINE2D_TYPE double
                         // values whose abs is < epsilon are handled as zero
#define HOMGLINE2D_EPS 1E-12

namespace BIAS {
  /** 
      @class HomgLine2D
      @ingroup g_geometry
      a line l = (a b c)^T is a form of the implicit straight line equation
      0 = a*x + b*y + c
      if homogenized, a^2 + b^2 = 1
      beware: (a b) is the vector perpendicular to the line direction
      therefor b could be interpreted as dx,
      but then a is equal to -dy 
      @author woelk 08 2002     
  */
  class BIASGeometryBase_EXPORT HomgLine2D : public Vector3 <HOMGLINE2D_TYPE>
  {   
  public:

    inline HomgLine2D();

    explicit inline HomgLine2D(const Vector3<HOMGLINE2D_TYPE>& vec);

    inline HomgLine2D(HOMGLINE2D_TYPE a, HOMGLINE2D_TYPE b, HOMGLINE2D_TYPE c);

    /// copy constructor
    inline HomgLine2D(const HomgLine2D& line);
    
    /** constructing a line through two points */
    inline HomgLine2D(const HomgPoint2D& p1, const HomgPoint2D& p2);

    /// destructor
    ~HomgLine2D() {};

    /** constructing a line through two points */
    inline void Set(const HomgPoint2D& p1, const HomgPoint2D& p2);

    /** returns length of hypothenuse in gradient triangle */
    inline HOMGLINE2D_TYPE GetW();

    /** aequivalent to homogenize for points 
        the gradient triangle is normed to hypothenuse length of 1 */
    inline void Homogenize();
    
    /** calculates distance of a point from line */
    inline HOMGLINE2D_TYPE Distance(const HomgPoint2D& point)
    { return sqrt(DistanceSquared(point)); };
    
    /** calculates squared distance of a point from line */
    inline HOMGLINE2D_TYPE DistanceSquared(const HomgPoint2D& point);

    /** calculates homogenized intersection of two lines */
    inline void Intersection(const HomgLine2D& line, HomgPoint2D& intersect) const;

    /** calls the above */
    inline HomgPoint2D Intersection(const HomgLine2D& line) const;

    /** ! assumes line is given in pixel coo !
        returns true if line intersects with image of given size
        returns intersections with image ( x1 = coo[0], y1 = coo[1], 
        x2 = coo[2], y2 = coo[3] ) for usage with DrawLine */
    bool GetIntersectionsWithImage(unsigned int width, unsigned int height,
                                   unsigned int coo[4]);

    /** return perpendicular line throug point */
    inline void GetPerpendicularLine(HomgPoint2D& point, HomgLine2D& perpline);

    

  };

  ///////////////////////////////////////////////////////////////////
  // inline implementations
  //////////////////////////////////////////////////////////////////


  inline HomgLine2D::HomgLine2D()
  { data_[0] = 0; data_[1] = -1; data_[2] = 0.0; }

  inline HomgLine2D::HomgLine2D(const Vector3<HOMGLINE2D_TYPE>& vec)
  { data_[0] = vec[0]; data_[1] = vec[1]; data_[2] = vec[2]; }

  inline HomgLine2D::HomgLine2D(HOMGLINE2D_TYPE a, 
                                HOMGLINE2D_TYPE b, 
                                HOMGLINE2D_TYPE c)
  { data_[0] = a; data_[1] = b; data_[2] = c; }

  /// copy constructor
  inline HomgLine2D::HomgLine2D(const HomgLine2D& line)
  { data_[0] = line[0]; data_[1] = line[1]; data_[2] = line[2]; }

  inline  
  HomgLine2D::HomgLine2D(const HomgPoint2D& p1, const HomgPoint2D& p2)
  { 
    Set(p1, p2);
  }

  inline void 
  HomgLine2D::Set(const HomgPoint2D& p1, const HomgPoint2D& p2)
  {
    p1.CrossProduct(p2, *this); 
    Homogenize();
    // deal with compiler precision
    if (data_[0] < HOMGLINE2D_EPS && data_[0] > -HOMGLINE2D_EPS)
      data_[0] = 0.0;
    if (data_[1] < HOMGLINE2D_EPS && data_[1] > -HOMGLINE2D_EPS)
      data_[1] = 0.0;
    if (data_[2] < HOMGLINE2D_EPS && data_[2] > -HOMGLINE2D_EPS)
      data_[2] = 0.0;
  }

  inline HOMGLINE2D_TYPE HomgLine2D::GetW()
  {
    return sqrt(data_[0] * data_[0] + data_[1] * data_[1]);
  }

  inline void HomgLine2D::Homogenize() 
  {
    register HOMGLINE2D_TYPE w = GetW();
    BIASASSERT(w!=0.0);
    data_[0] = data_[0] / -w;
    data_[1] = data_[1] / -w; 
    data_[2] = data_[2] / -w;
  }


  inline HOMGLINE2D_TYPE 
  HomgLine2D::DistanceSquared(const HomgPoint2D& point)
  {
    HOMGLINE2D_TYPE dist = data_[0] * point[0] + data_[1] * point[1] + 
      data_[2] * point[2];
    dist = dist*dist;
    dist/=((data_[0]*data_[0]+data_[1]*data_[1])* point[2]*point[2]);
      
    return (dist>HOMGLINE2D_EPS)? (dist):(0.0);
  }
 

  inline HomgPoint2D 
  HomgLine2D::Intersection(const HomgLine2D& line) const
  {
    HomgPoint2D point;
    Intersection(line, point);
    return point;
  }

  inline void 
  HomgLine2D::Intersection(const HomgLine2D& line, 
                           HomgPoint2D& intersect) const
  {
    CrossProduct(line, intersect);
  }

  inline void 
  HomgLine2D::GetPerpendicularLine(HomgPoint2D& point, HomgLine2D& perpline)
  {
    point.Homogenize();
    // change slope
    perpline[0] = data_[1];
    perpline[1] = -data_[0];
    // point must lie on lie : perpline^T * point = 0
    perpline[2] = - perpline[1]*point[1] - perpline[0]*point[0];
  }
}// namespace BIAS
#endif // __HOMGLINE2D_HH__