more_interpolators.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2005- 2005, Hammersmith Imanet Ltd
    For internal GE use only.
*/
#ifndef __stir_numerics_more_interpolators_H__
#define __stir_numerics_more_interpolators_H__

#include "stir/BasicCoordinate.h"
#include "stir/Array.h"

START_NAMESPACE_STIR

template <class elemT, class positionT>
elemT pull_nearest_neighbour_interpolate(const Array<3, elemT>& in, const BasicCoordinate<3, positionT>& point_in_input_coords);

template <int num_dimensions, class elemT, class positionT, class valueT>
void push_nearest_neighbour_interpolate(Array<num_dimensions, elemT>& out,
                                        const BasicCoordinate<num_dimensions, positionT>& point_in_output_coords,
                                        valueT value);

template <class elemT, class positionT>
elemT pull_linear_interpolate(const Array<3, elemT>& in, const BasicCoordinate<3, positionT>& point_in_input_coords);

template <class elemT, class positionT, class valueT>
void push_transpose_linear_interpolate(Array<3, elemT>& out,
                                       const BasicCoordinate<3, positionT>& point_in_output_coords,
                                       valueT value);

template <class elemT>
class PullLinearInterpolator
{
public:
  PullLinearInterpolator()
      : _input_ptr(0)
  {}

  void set_input(const Array<3, elemT>& input) const { this->_input_ptr = &input; }

  template <class positionT>
  elemT operator()(const BasicCoordinate<3, positionT>& point_in_input_coords) const
  {
    return pull_linear_interpolate(*(this->_input_ptr), point_in_input_coords);
  }

private:
  // todo terribly dangerous
  // we have it such that we can have a default constructor without any arguments
  // this means we cannot use a reference
  // we could use a shared_ptr, but then we can only interpolate data for which we have a shared_ptr
  mutable const Array<3, elemT>* _input_ptr;
};

template <class elemT>
class PushTransposeLinearInterpolator
{
public:
  PushTransposeLinearInterpolator()
      : _output_ptr(0)
  {}

  void set_output(Array<3, elemT>& output) const { this->_output_ptr = &output; }

  template <class positionT, class valueT>
  void add_to(const BasicCoordinate<3, positionT>& point_in_output_coords, const valueT value) const
  {
    push_transpose_linear_interpolate(*(this->_output_ptr), point_in_output_coords, value);
  }

private:
  // todo terribly dangerous
  // we have it such that we can have a default constructor without any arguments
  // this means we cannot use a reference
  // we could use a shared_ptr, but then we can only interpolate data for which we have a shared_ptr
  mutable Array<3, elemT>* _output_ptr;
};

template <class elemT>
class PullNearestNeighbourInterpolator
{
public:
  PullNearestNeighbourInterpolator()
      : _input_ptr(0)
  {}

  void set_input(const Array<3, elemT>& input) const { this->_input_ptr = &input; }

  template <class positionT>
  elemT operator()(const BasicCoordinate<3, positionT>& point_in_input_coords) const
  {
    return pull_nearest_neighbour_interpolate(*(this->_input_ptr), point_in_input_coords);
  }

private:
  // todo terribly dangerous
  // we have it such that we can have a default constructor without any arguments
  // this means we cannot use a reference
  // we could use a shared_ptr, but then we can only interpolate data for which we have a shared_ptr
  mutable const Array<3, elemT>* _input_ptr;
};

template <class elemT>
class PushNearestNeighbourInterpolator
{
public:
  PushNearestNeighbourInterpolator()
      : _output_ptr(0)
  {}

  void set_output(Array<3, elemT>& output) const { this->_output_ptr = &output; }

  template <class positionT, class valueT>
  void add_to(const BasicCoordinate<3, positionT>& point_in_output_coords, const valueT value) const
  {
    push_nearest_neighbour_interpolate(*(this->_output_ptr), point_in_output_coords, value);
  }

private:
  // todo terribly dangerous
  // we have it such that we can have a default constructor without any arguments
  // this means we cannot use a reference
  // we could use a shared_ptr, but then we can only interpolate data for which we have a shared_ptr
  mutable Array<3, elemT>* _output_ptr;
};

END_NAMESPACE_STIR

#include "stir_experimental/numerics/more_interpolators.inl"

#endif