miscUtils.h

Go to the documentation of this file.

#ifndef _MISCUTILS_H_
#define _MISCUTILS_H_

// includes from STL
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdarg> // va_start
#include <numeric> // accumulate

// includes from BOOST
#include <boost/array.hpp>
#include <boost/type_traits.hpp>

// includes from AIMS
#include "aims/vector/vector.h"

// includes from TIL
#include "til/is_traits.h"
#include "til/Matrix3.h"
#include "til/TExpr.h"
#include "til/TExprOperators.h"

// includes from TIL
#include "globalTraits.h"

namespace til
{
  namespace policy
  {
    //---------------------------------------------------------------
    
    class Radian_CenteredRange {};
    
    //---------------------------------------------------------------

    class Radian_PositiveRange {};

    //---------------------------------------------------------------

  } // namespace policy
  
  

  
  //---------------------------------------------------------------------------  
  /*  
  template < typename TVertexCollection >
  Point3dd
  getAverage(const TVertexCollection &vertices)
  {
    typename TVertexCollection::const_iterator iVertex;
    Point3dd res(0.0, 0.0, 0.0);
  
    // Add position of all vertices
    for (iVertex = vertices.begin(); iVertex != vertices.end(); ++iVertex)
    {
      res += *iVertex;
    }
    // Divide by the number of points
    res *= 1.0/size(vertices);
    return res;
  }
  */  
  
  //---------------------------------------------------------------------------

  template < typename T >
  inline
  T
  norm2(T x, T y, T z)
  { return x*x+y*y+z*z; }
  
  //---------------------------------------------------------------------------

  /*
  template < typename T, typename TPoint3DFrom >
  inline
  typename boost::enable_if_c<is_3DPoint<TPoint3DFrom>::value>::type
  cast(const TPoint3DFrom & x, boost::array<T,3> & y)
  {
    y[0] = p[0];
    y[1] = p[1];
    y[2] = p[2];
  }
  */
  
  /*
  template < typename TTo, typename TFrom >
  typename boost::disable_if_c<
  (is_3DPoint<TFrom>::value && is_3DPoint<TTo>::value) ||
  (is_3DPoint<TFrom>::value && is_BoostArray_N<TTo,3>::value)
  , TTo>::type
  cast(const TFrom & v) { return static_cast<TTo>(v); }
  
  template < typename TPoint3DTo, typename TPoint3DFrom >
  typename boost::enable_if_c<is_3DPoint<TPoint3DFrom>::value && is_3DPoint<TPoint3DTo>::value, TPoint3DTo && !is_BoostArray_N<TPoint3DTo>::value>::type
  cast(const TPoint3DFrom &p)
  {
    return TPoint3DTo(p[0], p[1], p[2]);
  }
  
  template < typename TBoostArray, typename TPoint3DFrom >
  typename boost::enable_if_c<is_3DPoint<TPoint3DFrom>::value && is_BoostArray_N<TBoostArray, 3>::value, TBoostArray>::type
  cast(const TPoint3DFrom & p)
  {
    TBoostArray tmp;
    tmp[0] = p[0];
    tmp[1] = p[1];
    tmp[2] = p[2];
    return tmp;
  }
  */
  
  /*
  namespace til
  {
    // copy process
    template < typename TIterator1, typename TIterator2 >
    void
    copy_convert
    (
     const TIterator1 & begin1,
     const TIterator1 & end1,
     const TIterator2 & begin2
    )
    {
      TIterator1 i1 = begin1;
      TIterator2 i2 = begin2;
      for (; i1 != end1; ++i1, ++i2)
      {
        convert(*i1, *i2);
      }
    }
  }
  */

    
  namespace detail
  {
    template < typename TContainer1, typename TContainer2 >
    typename boost::disable_if_c<
      is_container<typename TContainer1::value_type>::value &&
      is_container<typename TContainer2::value_type>::value
    >::type
    _allocate_sameSize
    (
     const TContainer1 & c1,    
     TContainer2 & c2           
    )
    {
      if (size(c2) != size(c1))
      {
        c2.resize(size(c1));
      }
    }
  
    template < typename TContainer1, typename TContainer2 >
    typename boost::enable_if_c<
      is_container<typename TContainer1::value_type>::value &&
      is_container<typename TContainer2::value_type>::value
    >::type
    _allocate_sameSize
    (
     const TContainer1 & c1,    
     TContainer2 & c2           
    )
    {
      if (size(c2) != size(c1))
      {
        c2.resize(size(c1));
      }
      typename TContainer1::const_iterator iC1 = c1.begin();
      typename TContainer2::iterator iC2 = c2.begin();
      for (; iC1 != c1.end(); ++iC1, ++iC2)
      {
        _allocate_sameSize<typename TContainer1::value_type, typename TContainer2::value_type>(*iC1, *iC2);
      }
    }
  }
  
  
  template < typename TContainer1, typename TContainer2 >
  void
  allocate_sameSize
  (
   const TContainer1 & c1,    
   TContainer2 & c2           
  )
  { detail::_allocate_sameSize<TContainer1, TContainer2>(c1,c2); }
  
  /*
  template < typename TContainer1, typename TContainer2 >
  void
  allocate_sameSize
  (
   const TContainer1 & c1,    ///< The model
   TContainer2 & c2           ///< The container to be allocated
  )
  {
    if (size(c2) != size(c1))
    {
      c2.resize(size(c1));
    }
    if (is_container<typename TContainer1::value_type>::value &&
        is_container<typename TContainer2::value_type>::value)
    {
      typename TContainer1::const_iterator iC1 = c1.begin();
      typename TContainer2::iterator iC2 = c2.begin();
      for (; iC1 != c1.end(); ++iC1, ++iC2)
      {
        allocate_sameSize(*iC1, *iC2);
      }
    }
  }
  */
  
  
  namespace functor
  {
    
    // TODO: I think boost::numeric::converter could be used there but maybe
    // without range checking -- this could really drag performance down.
    template < typename TPrecision, typename TVector3D  >
    inline 
    TPrecision
    diff2(const TVector3D &v1, const TVector3D &v2)
    { return static_cast<TPrecision>(norm2(v1[0]-v2[0], v1[1]-v2[1], v1[2]-v2[2])); }
  
    template < typename TPrecision, typename TVector3D  >
    inline 
    TPrecision
    diff(const TVector3D &v1, const TVector3D &v2)
    { return static_cast<TPrecision>(std::sqrt(diff2<double>(v1,v2))); }
      
    struct Diff2
    {
      template < typename TVector3D, typename TPrecision >
      typename boost::enable_if_c<
        is_3DVector<TVector3D>::value
      >::type
      operator()(const TVector3D &v1, const TVector3D &v2, TPrecision &res) const
      { res = diff2<TPrecision>(v1,v2); }
    };
  
    struct Diff
    {
      template < typename TVector3D, typename TPrecision >
      void operator()(const TVector3D &v1, const TVector3D &v2, TPrecision &res) const
      { res = diff<TPrecision>(v1,v2); }
    };
  
    template < typename TVector3D >
    struct Normalize
    {
      void operator()(const TVector3D &v1, const TVector3D &v2, TVector3D & res) const
      {
        sub(v1, v2, res);
        div(res, norm(res));
      }
    };
  }
 
  //---------------------------------------------------------------------------
  
  template < typename TRes, typename TIterator >
  void mean(TIterator begin, TIterator end, TRes & res);
  
  //---------------------------------------------------------------------------

  // TODO: change this: remove res = T()
  template < typename TRes, typename TCollection >
  void centroid(const TCollection & c, TRes & res)
    __attribute__((__deprecated__("use mean() instead")));

  template < typename TRes, typename TCollection >
  void centroid(const TCollection & c, TRes & res)
  {
    mean(c.begin(), c.end(), res);
  }
  
  //---------------------------------------------------------------------------
  
  template < typename TPoint, typename TPointCollection >
  void stdev(const TPointCollection & c, TPoint & res);
  
  //---------------------------------------------------------------------------
  
  template < typename T1, typename T2 >
  inline bool 
  same_sign(const T1 & x, const T2 & y)
  {
    if (x >= 0) return (y >= 0);
    else        return (y <= 0);
  }
  
  //---------------------------------------------------------------------------

  template < typename T1, typename T2 >
  inline T1 sign(T1 x, T2 y)
  { return (y >= 0 ? x : -x); }
    
  //---------------------------------------------------------------------------

  template < typename T >
  char * sprintf(T format, ... )
  {
    static char *s = new char[1024];
    va_list vl;
    va_start(vl, format);
    vsprintf(s, format, vl);
    return s;
  }
  
  //---------------------------------------------------------------------------

  template < typename T >
  struct Lexicographical_compare
  {
    bool operator()(const T & x, const T & y) const
    { return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }
  };

  //---------------------------------------------------------------------------

  template < typename TIndexCollection >
  std::vector<std::list<std::size_t> >
  invertIndices(const std::vector<TIndexCollection> & c);
  
  //-----------------------------------------------------------------
  
  template < typename TIterator >
  struct Lesser_PointeeAddress
  {
    bool operator()(TIterator i, TIterator j) const
    { return &*i < &*j; }
  };

  //-----------------------------------------------------------------
  
  template < typename T1, typename T2 >
  struct Lesser_Pair2
  {
    bool operator()(const std::pair<T1,T2> & p1, const std::pair<T1,T2> & p2) const
    { return p1.second < p2.second; }
  };
  
  //-----------------------------------------------------------------
  
  template < typename T1, typename T2 >
  struct Greater_Pair2
  {
    bool operator()(const std::pair<T1,T2> & p1, const std::pair<T1,T2> & p2) const
    { return p1.second > p2.second; }
  };
  
  //-----------------------------------------------------------------

  template < typename T1, typename T2 >
  struct Return_pair1
  {
    inline T1 operator()(std::pair<T1, T2> const & p) const { return p.first; }
  };
    
  //-----------------------------------------------------------------

  template < typename T >
  inline std::size_t max_index(T x0, T x1, T x2);

  //---------------------------------------------------------------------------

  template < typename T >
  inline std::size_t min_index(T x0, T x1, T x2);

  //---------------------------------------------------------------------------

  template < typename T >
  inline bool is_nan(T x);
   
  //---------------------------------------------------------------------------

  template < typename TPrec >
  struct SquaredEuclideanDist
  {
    template < typename T, std::size_t D >
    TPrec operator() (const numeric_array<T,D> & a1, const numeric_array<T,D> & a2) const
    {
      return dist2(a1, a2, prec<TPrec>());
    }
  };
  
  //---------------------------------------------------------------------------

  // TODO: add a test so that it works only for signed integers... or is >> working only on signed integers anyway?
  template < typename T >
  bool is_dyadic(T n);

  //---------------------------------------------------------------------------

  template < typename T >
  inline int log2(T n);

  //---------------------------------------------------------------------------

  template < typename T >
  inline T exp2(unsigned int n);
  
  //---------------------------------------------------------------------------

  template < typename T >
  inline T lower_dyadic(T n);
  
  //-------------------------------------------------------------------------------------------
  
  // TODO: shouldn't this guy be in functor or something? Or something like source or generator?
  template < typename T >
  class Incrementor
  {
  public: // constructors
    Incrementor(T i0) : m_i(i0) {}
  public: // operator
    T operator()() { return m_i++; }
  private: // data
    T m_i;
  };
    
  //-------------------------------------------------------------------------------------------

    
} // namespace til

// package include
#include "misc_utils.tpp"


#endif //_MISCUTILS_H_