BasicCoordinate.h

Go to the documentation of this file.

#ifndef __stir_BasicCoordinate_H__
#define __stir_BasicCoordinate_H__
//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000 - 2011-01-04, Hammersmith Imanet Ltd
    Copyright (C) 2012-06-01 - 2013, Kris Thielemans
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/

 
#include "stir/common.h"
#include <boost/operators.hpp>
#include <iterator>
 
START_NAMESPACE_STIR
template <int num_dimensions, typename coordT>
class BasicCoordinate
    : boost::partially_ordered<BasicCoordinate<num_dimensions, coordT>, // have operator>, <= etc for free
                               boost::equality_comparable<BasicCoordinate<num_dimensions, coordT> // have operator!= for free
                                                          >>
{
 
public:

  typedef std::random_access_iterator_tag iterator_category;
  typedef coordT value_type;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef value_type* iterator;
  typedef value_type* pointer;
  typedef const value_type* const_iterator;
  typedef std::ptrdiff_t difference_type;
  typedef std::size_t size_type;

  inline BasicCoordinate();
  explicit inline BasicCoordinate(const coordT&);
#if 0
  /* disabled. It overlaps with the constructor below and VC 6.0 can't sort it out.
    We don't seem to need it anyway
  */
  inline BasicCoordinate(const BasicCoordinate& c);
#endif

  // Note implementation here for VC 6.0
  template <typename coordT2>
  explicit inline BasicCoordinate(const BasicCoordinate<num_dimensions, coordT2>& c)
  {
    for (int i = 1; i <= num_dimensions; ++i)
      (*this)[i] = static_cast<coordT>(c[i]);
  }
  // virtual destructor, not implemented at the moment
  // It's only needed whenever there is a chance that an object will be deleted
  // through a pointer to its base class and derived classes have extra
  // data members
  // virtual ~BasicCoordinate() {}

  inline BasicCoordinate& operator=(const BasicCoordinate& c);

  inline bool operator==(const BasicCoordinate& c) const;

  inline bool operator<(const BasicCoordinate& c) const;
 
  // access to elements
  inline coordT& operator[](const int d);

  inline coordT const& operator[](const int d) const;

  inline coordT& at(const int d);
  inline coordT const& at(const int d) const;
 
  // check if the coordinate is empty (always returns false)
  inline bool empty() const
  {
    return false;
  }


  inline static int get_min_index();
  inline static int get_max_index();
  inline static unsigned size();
  inline void fill(const coordT&);


  inline BasicCoordinate& operator+=(const BasicCoordinate& c);
  inline BasicCoordinate& operator-=(const BasicCoordinate& c);
  inline BasicCoordinate& operator*=(const BasicCoordinate& c);
  inline BasicCoordinate& operator/=(const BasicCoordinate& c);
 
  inline BasicCoordinate& operator+=(const coordT& a);
  inline BasicCoordinate& operator-=(const coordT& a);
  inline BasicCoordinate& operator*=(const coordT& a);
  inline BasicCoordinate& operator/=(const coordT& a);


  inline BasicCoordinate operator+(const BasicCoordinate& c) const;
  inline BasicCoordinate operator-(const BasicCoordinate& c) const;
  inline BasicCoordinate operator*(const BasicCoordinate& c) const;
  inline BasicCoordinate operator/(const BasicCoordinate& c) const;


  inline BasicCoordinate operator+(const coordT& a) const;
  inline BasicCoordinate operator-(const coordT& a) const;
  inline BasicCoordinate operator*(const coordT& a) const;
  inline BasicCoordinate operator/(const coordT& a) const;
  inline BasicCoordinate operator-() const;


  inline iterator begin();
  inline const_iterator begin() const;
  inline iterator end();
  inline const_iterator end() const;
 
private:

  coordT coords[num_dimensions];
};

 
template <class T>
inline BasicCoordinate<1, T> make_coordinate(const T& a1);
 
template <class T>
inline BasicCoordinate<2, T> make_coordinate(const T& a1, const T& a2);
 
template <class T>
inline BasicCoordinate<3, T> make_coordinate(const T& a1, const T& a2, const T& a3);
 
template <class T>
inline BasicCoordinate<4, T> make_coordinate(const T& a1, const T& a2, const T& a3, const T& a4);
 
template <class T>
inline BasicCoordinate<5, T> make_coordinate(const T& a1, const T& a2, const T& a3, const T& a4, const T& a5);
 
template <class T>
inline BasicCoordinate<6, T> make_coordinate(const T& a1, const T& a2, const T& a3, const T& a4, const T& a5, const T& a6);

 
/*
  General functions on BasicCoordinate objects, like in ArrayFunction.h
*/


template <int num_dimensions, typename coordT>
inline coordT inner_product(const BasicCoordinate<num_dimensions, coordT>& p1, const BasicCoordinate<num_dimensions, coordT>& p2);

template <int num_dimensions, typename coordT>
inline double norm_squared(const BasicCoordinate<num_dimensions, coordT>& p1);

template <int num_dimensions, typename coordT>
inline double norm(const BasicCoordinate<num_dimensions, coordT>& p1);

template <int num_dimensions, typename coordT>
inline double angle(const BasicCoordinate<num_dimensions, coordT>& p1, const BasicCoordinate<num_dimensions, coordT>& p2);


template <int num_dimensions, typename coordT>
inline double cos_angle(const BasicCoordinate<num_dimensions, coordT>& p1, const BasicCoordinate<num_dimensions, coordT>& p2);
 
// Note: gcc 2.8.1 bug:
// It cannot call 'join' (it generates a bad mangled name for the function)

template <int num_dimensions, typename coordT>
inline BasicCoordinate<num_dimensions + 1, coordT> join(const coordT& a, const BasicCoordinate<num_dimensions, coordT>& c);


template <int num_dimensions, class coordT>
inline BasicCoordinate<num_dimensions + 1, coordT> join(const BasicCoordinate<num_dimensions, coordT>& c, const coordT& a);


template <int num_dimensions, class coordT>
inline BasicCoordinate<num_dimensions - 1, coordT> cut_last_dimension(const BasicCoordinate<num_dimensions, coordT>& c);


template <int num_dimensions, typename coordT>
inline BasicCoordinate<num_dimensions - 1, coordT> cut_first_dimension(const BasicCoordinate<num_dimensions, coordT>& c);


template <int num_dimensions>
inline BasicCoordinate<num_dimensions, float> convert_int_to_float(const BasicCoordinate<num_dimensions, int>& cint);
 
END_NAMESPACE_STIR
 
#include "stir/BasicCoordinate.inl"
 
#endif