EightWaySymmetry.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 __EIGHT_WAY_SYMMETRY_HH__
#define __EIGHT_WAY_SYMMETRY_HH__
#include "bias_config.h" 

// BIAS jw: math.h defines required for non-standard symbols: 
#define _USE_MATH_DEFINES 
#include <math.h>
//#include <cmath>
#include <iostream>

#include <Base/Debug/Error.hh>




namespace BIAS{

  /** @enum TLineType
   *  @brief direction of line if start is in coordinate origin as given by compass
   */
  enum TLineType { LT_Invalid, E_NE, NE_N, N_NW, NW_W, W_SW, SW_S, S_SE, SE_E };

  /**
   *  @brief class for transforming any point to first octant
   *  @ingroup g_image_other
   *  @author Jan Woetzel
   */
  template <class T>
  class EightWaySymmetry{

  public:
    /// assumes angle is between (-pi, pi] as given by atan2
    inline enum TLineType DetermineLineType(double& angle);

    /// not tested jet
    inline enum TLineType DetermineLineType(const T& startx, const T& starty,
                                            const T& endx, const T& endy);

    /// 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, 
                          const T& Originalx, const T& Originaly, 
                          T& Transformedx, T& Transformedy);

    /// executes the inverse transformation to the above
    inline void InverseTransform(enum TLineType& type, 
                                 const T& Transformedx, const T& Transformedy,
                                 T& Originalx, T& Originaly);

    inline void Transform(enum TLineType& type, 
                          const T orig[2], T transf[2]);

    inline void InverseTransform(enum TLineType& type, 
                                 const T transf[2], T orig[2]);
  }; // end of class 



  // implementations: 


  //for old compilers 'enum TLineType'
  template <class T> inline TLineType 
  EightWaySymmetry<T>::DetermineLineType(double& angle)
  {
    enum TLineType type = LT_Invalid;

    if (angle >= 0 && angle <= M_PI_4)
      type = SE_E;
    if (angle > M_PI_4 && angle <= M_PI_2)
      type = S_SE;
    if (angle > M_PI_2 && angle <= 3 * M_PI_4)
      type = SW_S;
    if (angle > 3 * M_PI_4 && angle <= M_PI)
      type = W_SW;
    if (angle > -M_PI && angle <= -3 * M_PI_4)
      type = NW_W;
    if (angle > -3 * M_PI_4 && angle <= -M_PI_2)
      type = N_NW;
    if (angle > -M_PI_2 && angle <= -M_PI_4)
      type = NE_N;
    if (angle > -M_PI_4 && angle < 0)
      type = E_NE;

    return type;
  }

  template <class T> inline TLineType              //for old compilers 'enum TLineType'
  EightWaySymmetry<T>::DetermineLineType(const T& startx, const T& starty,
                                         const T& endx, const T& endy)
  {
    enum TLineType type = LT_Invalid;
    double dx, dy;
    dx = (double)endx - (double)startx;
    dy = (double)endy - (double)starty;
  
    if (dx>=0){
      if (dy>=0){
        if (dx>dy){
          type = SE_E;
        } else {
          type = S_SE;
        }
      } else { // dx >=0 && dy < 0
        if(dx>-dy){
          type = E_NE;
        } else {
          type = NE_N;
        }
      }
    } else { // dx < 0
      if (dy>=0){
        if (-dx>dy){
          type = W_SW;
        } else {
          type = SW_S;
        }
      } else { // dx <0 && dy <0
        if (dx<dy) { //(-dx>-dy){
          type = NW_W;
        } else {
          type = N_NW;
        }
      }
    }
    return type;
  }

  template <class T> inline void
  EightWaySymmetry<T>::Transform(enum TLineType& type, const T& Originalx, 
                                 const T& Originaly, T& Transformedx,
                                 T& Transformedy)
  {
    switch(type){
    case SE_E:
      Transformedx = Originalx;
      Transformedy = Originaly;
      break;
    case S_SE:
      Transformedx = Originaly;
      Transformedy = Originalx;
      break;
    case SW_S:
      Transformedx = Originaly;
      Transformedy = -Originalx;
      break;
    case W_SW:
      Transformedx = -Originalx;
      Transformedy = Originaly;
      break;
    case NW_W:
      Transformedx = Originalx * (-1);
      Transformedy = Originaly * (-1);
      break;
    case N_NW:
      Transformedx = -Originaly;
      Transformedy = -Originalx;
      break;
    case NE_N:
      Transformedx = -Originaly;
      Transformedy = Originalx;
      break;
    case E_NE:
      Transformedx = Originalx;
      Transformedy = -Originaly;
      break;
    case LT_Invalid:
      BIASERR("Invalid LineType, maybe wrong slope in EpipolarLine");
      break;
    }
  }


  template <class T> inline void 
  EightWaySymmetry<T>::InverseTransform(enum TLineType& type, 
                                        const T& Transformedx,
                                        const T& Transformedy,
                                        T& Originalx, 
                                        T& Originaly)
  {
    switch(type){
    case SE_E:
      Originalx = Transformedx;
      Originaly = Transformedy;
      break;
    case S_SE:
      Originalx = Transformedy;
      Originaly = Transformedx;
      break;
    case SW_S:
      Originalx = -Transformedy;
      Originaly = Transformedx;
      break;
    case W_SW:
      Originalx = -Transformedx;
      Originaly = Transformedy;
      break;
    case NW_W:
      Originalx = Transformedx * (-1);
      Originaly = Transformedy * (-1);
      break;
    case N_NW:
      Originalx = -Transformedy;
      Originaly = -Transformedx;
      break;
    case NE_N:
      Originalx = Transformedy;
      Originaly = -Transformedx;
      break;
    case E_NE:
      Originalx = Transformedx;
      Originaly = -Transformedy;
      break;
    case LT_Invalid:
      BIASERR("Invalid LineType, maybe wrong slope in EpipolarLine");
      break;
    }
  }

  template <class T> inline void 
  EightWaySymmetry<T>::Transform(enum TLineType& type, 
                                 const T orig[2], T transf[2])
  {
    return EightWaySymmetry<T>::Transform(type, orig[0], orig[1], transf[0],
                                          transf[1]);
  }

  template <class T> inline void 
  EightWaySymmetry<T>::InverseTransform(enum TLineType& type, 
                                        const T transf[2], T orig[2])
  {
    return 
      EightWaySymmetry<T>::InverseTransform(type, transf[0],
                                            transf[1], orig[0], orig[1]);
  }
  
} // namespace BIAS

#endif // __8_WAY_SYMMETRY_HH__