VoxelsOnCartesianGrid.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2007, Hammersmith Imanet Ltd
    Copyright (C) 2018-2019, 2025, University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
 
#ifndef __stir_VoxelsOnCartesianGrid_H__
#define __stir_VoxelsOnCartesianGrid_H__

#include "stir/DiscretisedDensityOnCartesianGrid.h"
#include "stir/CartesianCoordinate3D.h"
 
START_NAMESPACE_STIR
 
class ProjDataInfo;
template <typename elemT>
class PixelsOnCartesianGrid;

template <class elemT>
class VoxelsOnCartesianGrid : public DiscretisedDensityOnCartesianGrid<3, elemT>
{
#ifdef STIR_COMPILING_SWIG_WRAPPER
  // work-around swig problem. It gets confused when using a private (or protected)
  // typedef in a definition of a public typedef/member
public:
#endif
  typedef VoxelsOnCartesianGrid<elemT> self_type;
  typedef DiscretisedDensityOnCartesianGrid<3, elemT> base_type;
 
public:
#if 0
static VoxelsOnCartesianGrid ask_parameters();
#endif

  VoxelsOnCartesianGrid();

  VoxelsOnCartesianGrid(const Array<3, elemT>& v,
                        const CartesianCoordinate3D<float>& origin,
                        const BasicCoordinate<3, float>& grid_spacing);

  VoxelsOnCartesianGrid(Array<3, elemT>&& v,
                        const CartesianCoordinate3D<float>& origin,
                        const BasicCoordinate<3, float>& grid_spacing);


  VoxelsOnCartesianGrid(const IndexRange<3>& range,
                        const CartesianCoordinate3D<float>& origin,
                        const BasicCoordinate<3, float>& grid_spacing);

  VoxelsOnCartesianGrid(const shared_ptr<const ExamInfo>& exam_info_sptr,
                        const Array<3, elemT>& v,
                        const CartesianCoordinate3D<float>& origin,
                        const BasicCoordinate<3, float>& grid_spacing);

  VoxelsOnCartesianGrid(const shared_ptr<const ExamInfo>& exam_info_sptr,
                        Array<3, elemT>&& v,
                        const CartesianCoordinate3D<float>& origin,
                        const BasicCoordinate<3, float>& grid_spacing);


  VoxelsOnCartesianGrid(const shared_ptr<const ExamInfo>& exam_info_sptr,
                        const IndexRange<3>& range,
                        const CartesianCoordinate3D<float>& origin,
                        const BasicCoordinate<3, float>& grid_spacing);
 
  // KT 10/12/2001 replace 2 constructors with the more general one below

  VoxelsOnCartesianGrid(const ProjDataInfo& proj_data_info_ptr,
                        const float zoom = 1.F,
                        const CartesianCoordinate3D<float>& origin = CartesianCoordinate3D<float>(0.F, 0.F, 0.F),
                        const CartesianCoordinate3D<int>& sizes = CartesianCoordinate3D<int>(-1, -1, -1));


  VoxelsOnCartesianGrid(const shared_ptr<const ExamInfo>& exam_info_sptr,
                        const ProjDataInfo& proj_data_info,
                        const float zoom = 1.F,
                        const CartesianCoordinate3D<float>& origin = CartesianCoordinate3D<float>(0.F, 0.F, 0.F),
                        const CartesianCoordinate3D<int>& sizes = CartesianCoordinate3D<int>(-1, -1, -1));


  VoxelsOnCartesianGrid(const shared_ptr<const ExamInfo>& exam_info_sptr_v,
                        const ProjDataInfo& proj_data_info,
                        const CartesianCoordinate3D<float>& zooms,
                        const CartesianCoordinate3D<float>& origin = CartesianCoordinate3D<float>(0.F, 0.F, 0.F),
                        const CartesianCoordinate3D<int>& sizes = CartesianCoordinate3D<int>(-1, -1, -1));

  VoxelsOnCartesianGrid<elemT>* get_empty_copy() const override;

  VoxelsOnCartesianGrid<elemT>* get_empty_voxels_on_cartesian_grid() const;
 
  VoxelsOnCartesianGrid<elemT>* clone() const override;

  PixelsOnCartesianGrid<elemT> get_plane(const int z) const;

  void set_plane(const PixelsOnCartesianGrid<elemT>& plane, const int z);

  inline CartesianCoordinate3D<float> get_voxel_size() const;

  void set_voxel_size(const BasicCoordinate<3, float>&);

  void grow_z_range(const int min_z, const int max_z);


  inline int get_x_size() const;
 
  inline int get_y_size() const;
 
  inline int get_z_size() const;
 
  inline int get_min_x() const;
 
  inline int get_min_y() const;
 
  inline int get_min_z() const;
 
  inline int get_max_x() const;
 
  inline int get_max_y() const;
 
  inline int get_max_z() const;
 
  BasicCoordinate<3, int> get_lengths() const;
  BasicCoordinate<3, int> get_min_indices() const;
  BasicCoordinate<3, int> get_max_indices() const;



  // tedious reimplementation to fix return types. This could be avoided by using boost::operators.
  // However, reimplementing them explicitly helps SWIG.
  inline self_type& operator+=(const self_type& x)
  {
    base_type::operator+=(x);
    return *this;
  }
  inline self_type& operator-=(const self_type& x)
  {
    base_type::operator-=(x);
    return *this;
  }
  inline self_type& operator*=(const self_type& x)
  {
    base_type::operator*=(x);
    return *this;
  }
  inline self_type& operator/=(const self_type& x)
  {
    base_type::operator/=(x);
    return *this;
  }
  inline self_type& operator+=(const elemT x)
  {
    base_type::operator+=(x);
    return *this;
  }
  inline self_type& operator-=(const elemT x)
  {
    base_type::operator-=(x);
    return *this;
  }
  inline self_type& operator*=(const elemT x)
  {
    base_type::operator*=(x);
    return *this;
  }
  inline self_type& operator/=(const elemT x)
  {
    base_type::operator/=(x);
    return *this;
  }
  inline self_type operator+(const self_type& x) const
  {
    self_type c(*this);
    return c += x;
  }
  inline self_type operator+(const elemT x) const
  {
    self_type c(*this);
    return c += x;
  }
  inline self_type operator-(const self_type& x) const
  {
    self_type c(*this);
    return c -= x;
  }
  inline self_type operator-(const elemT x) const
  {
    self_type c(*this);
    return c -= x;
  }
  inline self_type operator*(const self_type& x) const
  {
    self_type c(*this);
    return c *= x;
  }
  inline self_type operator*(const elemT x) const
  {
    self_type c(*this);
    return c *= x;
  }
  inline self_type operator/(const self_type& x) const
  {
    self_type c(*this);
    return c /= x;
  }
  inline self_type operator/(const elemT x) const
  {
    self_type c(*this);
    return c /= x;
  }
 
private:
  void construct_from_projdata_info(const shared_ptr<const ExamInfo>& exam_info_sptr_v,
                                    const ProjDataInfo& proj_data_info,
                                    const CartesianCoordinate3D<float>& zooms,
                                    const CartesianCoordinate3D<float>& origin,
                                    const CartesianCoordinate3D<int>& sizes);
};
 
END_NAMESPACE_STIR
 
#include "stir/VoxelsOnCartesianGrid.inl"
#endif