EightWaySymmetryHomg.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
*/

// TODO: jw: merge EightWaySymmetry from BIAS/Base/Image and Geometry. (code duplication)

#ifndef __EIGHT_WAY_SYMMETRY_HOMG_HH__
#define __EIGHT_WAY_SYMMETRY_HOMG_HH__

#include <cmath>
#include <Base/Geometry/HomgPoint2D.hh>
#include <Base/ImageUtils/EightWaySymmetry.hh>

namespace BIAS{

  /// direction of line if start is in coordinate origin
  /// as given by compass
  // the following is coming out of BIASIMage
  //    enum TLineType { LT_Invalid, E_NE, NE_N, N_NW, NW_W, W_SW, SW_S, S_SE,
  //           SE_E };

  // ostream& operator<<(ostream& os, const enum TLineType type);

  class EightWaySymmetryHomg : public EightWaySymmetry<double>
  {
  public:

    inline enum TLineType DetermineLineType(double& angle)
      { return EightWaySymmetry<double>::DetermineLineType(angle); };

    /// not tested jet
    inline enum TLineType DetermineLineType(HomgPoint2D& start,
                                            HomgPoint2D& end)
      { double s[2], e[2];
      s[0]=start[0]/start[2];s[1]=start[1]/start[2];
      e[0]=end[0]/end[1];e[1]=end[1]/end[2];
        return EightWaySymmetry<double>::DetermineLineType(s[0], s[1], e[0],
                                                           e[1]); };

    /// transforms Original according to type in a way that
    /// Transformed lies on a line with slope in [0,1)
    inline void Transform(enum TLineType& type, HomgPoint2D& Original,
                          HomgPoint2D& Transformed)
      { double o[2];
      o[0]=Original[0]/Original[2];o[1]=Original[1]/Original[2];
      Transformed[2]=1.0;
      EightWaySymmetry<double>::Transform(type, o[0], o[1],Transformed[0],
                                          Transformed[1]); }

    /// as above
    template <class T>
    inline void Transform(enum TLineType& type, Vector2<T>& Original,
                          Vector2<T>& Transformed)
      { EightWaySymmetry<double>::Transform(type, Original[0], Original[1],
                                            Transformed[0], Transformed[1]); }

    /// executes the inverse transformation to the above
    inline void InverseTransform(enum TLineType& type,
                                 HomgPoint2D& Transformed,
                                 HomgPoint2D& Original)
      { double t[2];
      t[0]=Transformed[0]/Transformed[2];t[1]=Transformed[1]/Transformed[2];
      Original[2]=1.0;
      EightWaySymmetry<double>::InverseTransform(type, t[0], t[1],
                                                 Original[0], Original[1]); };

    /// as above
    template <class T>
    inline void InverseTransform(enum TLineType& type,
                                 Vector2<T>& Transformed,
                                 Vector2<T>& Original)
      { EightWaySymmetry<double>::InverseTransform(type, Transformed[0],
                                                   Transformed[1], Original[0],
                                                   Original[1]); }

  };


} // namespace BIAS

#endif // __8_WAY_SYMMETRY_HOMG_HH__