volumebase.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#ifndef CARTODATA_VOLUME_VOLUMEBASE_H
#define CARTODATA_VOLUME_VOLUMEBASE_H
//--- cartodata --------------------------------------------------------------
#include <cartodata/config/config.h>
#include <cartodata/volume/volumeproxy.h>
#include <cartodata/transformation/referential.h>
//--- soma-io ----------------------------------------------------------------
#include <soma-io/utilities/allocatedvector.h>
#include <soma-io/utilities/creator.h>
//--- cartobase --------------------------------------------------------------
#include <cartobase/allocator/allocator.h>
#include <cartobase/smart/rcptr.h>
#include <cartobase/type/datatypetraits.h>
//--- blitz ------------------------------------------------------------------
  #ifdef _WIN32
    // disable thread-safe operations in blitz++ on windows since it uses pthread
    #ifdef _REENTRANT
      #define CARTO_REENTRANT_MEMO
      #undef _REENTRANT
    #endif
    #include <blitz/blitz.h>
    #ifdef CARTO_REENTRANT_MEMO
      #define _REENTRANT
      #undef CARTO_REENTRANT_MEMO
    #endif
  #endif
  #include <blitz/array.h>
  
namespace carto {
  typedef ptrdiff_t BlitzStridesType;
}
 
 
//--- std --------------------------------------------------------------------
#include <vector>
//--- forward declarations ---------------------------------------------------
namespace carto {
  class AllocatorContext;
  class PropertyFilter;
}
//----------------------------------------------------------------------------
 
namespace carto
{
//============================================================================
//   V O L U M E
//============================================================================
  template < typename T >
  class Volume : public VolumeProxy< T >
  {
  public:
    //========================================================================
    //   TYPES
    //========================================================================
    class Position4Di;
    typedef std::vector<int> Position;

    typedef T datatype;

    // static const int DIM_MAX = 8; leads to build issues on old GCC versions
    // so we need to use enum to be able to declare DIM_MAX in carto::Volume
    enum { DIM_MAX = 8 };
    typedef typename blitz::Array<T,Volume<T>::DIM_MAX>::iterator iterator;
    typedef typename blitz::Array<T,Volume<T>::DIM_MAX>::const_iterator const_iterator;
 
    //========================================================================
    //   CONSTRUCTORS
    //========================================================================
    explicit Volume( int sizeX = 1, int sizeY = 1, int sizeZ = 1,
                     int sizeT = 1,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    explicit Volume( const Position4Di & size,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    explicit Volume( int sizeX, int sizeY, int sizeZ,
                     int sizeT, int bordersize,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    explicit Volume( const Position4Di & size, int bordersize,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    explicit Volume( int sizeX, int sizeY, int sizeZ, int sizeT,
                     const Position4Di & border,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    explicit Volume( const Position4Di & size,
                     const Position4Di & border,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    explicit Volume( const std::vector<int> & size,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    explicit Volume( const std::vector<int> & size,
                     const std::vector<int> & border,
                     const AllocatorContext& allocatorContext
                      = AllocatorContext(),
                     bool allocated = true );
    Volume( int sizeX, int sizeY, int sizeZ, int sizeT, T* buffer,
            const std::vector<long> *strides = 0 );
    Volume( const Position4Di & size, T* buffer,
            const std::vector<long> *strides = 0 );
    Volume( const std::vector<int> & size, T* buffer,
            const std::vector<long> *strides = 0 );
    Volume( rc_ptr<Volume<T> > other,
            const Position4Di & pos = Position4Di( 0, 0, 0, 0 ),
            const Position4Di & size = Position4Di( -1, -1, -1, -1 ),
            const AllocatorContext & allocContext = AllocatorContext() );
    Volume( rc_ptr<Volume<T> > other,
            const Position & pos,
            const Position & size = Position(),
            const AllocatorContext & allocContext = AllocatorContext() );
    Volume( rc_ptr<Volume<T> > other,
            const Position & pos,
            const Position & size,
            T* buffer, const std::vector<long> & strides );
    Volume( const Volume< T >& other );
    virtual ~Volume();
 
    Volume< T >& operator=( const Volume< T >& other );
 
    //========================================================================
    //   ITERATORS
    //========================================================================

    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
 
    //========================================================================
    //   ACCESSORS
    //========================================================================

    const T& operator()( long x, long y = 0, long z = 0, long t = 0 ) const;
//     T& operator() ( long x );
    T& operator() ( long x, long y = 0, long z = 0, long t = 0 );
    const T& at( long x, long y = 0, long z = 0, long t = 0 ) const;
    T& at( long x, long y = 0, long z = 0, long t = 0 );
    const T& operator() ( const Position4Di & position ) const;
    T& operator() ( const Position4Di & position );
    const T& at( const Position4Di & position ) const;
    T& at( const Position4Di & position );
    const T & at( const std::vector<int> & ) const;
    T & at( const std::vector<int> & );
    const T& operator() ( const std::vector<int> & position ) const;
    T& operator() ( const std::vector<int> & position );
 
    const T & at( const blitz::TinyVector<int,1> & ) const;
    T & at( const blitz::TinyVector<int,1> & );
    const T & at( const blitz::TinyVector<int,2> & ) const;
    T & at( const blitz::TinyVector<int,2> & );
    const T & at( const blitz::TinyVector<int,3> & ) const;
    T & at( const blitz::TinyVector<int,3> & );
    const T & at( const blitz::TinyVector<int,4> & ) const;
    T & at( const blitz::TinyVector<int,4> & );
    const T & at( const blitz::TinyVector<int,Volume<T>::DIM_MAX> & ) const;
    T & at( const blitz::TinyVector<int,Volume<T>::DIM_MAX> & );
    blitz::Array<T,Volume<T>::DIM_MAX> at( const blitz::RectDomain<Volume<T>::DIM_MAX>
      & subdomain ) const;
    blitz::Array<T,Volume<T>::DIM_MAX> at( const blitz::StridedDomain<Volume<T>::DIM_MAX>
      & subdomain ) const;
    blitz::Array<T,Volume<T>::DIM_MAX> at( const blitz::Range & r0 ) const;
    blitz::Array<T,Volume<T>::DIM_MAX> at( const blitz::Range & r0,
                          const blitz::Range & r1 ) const;
    blitz::Array<T,Volume<T>::DIM_MAX> at( const blitz::Range & r0,
                                const blitz::Range & r1,
                                const blitz::Range & r2 ) const;
    blitz::Array<T,Volume<T>::DIM_MAX> at( const blitz::Range & r0,
                                const blitz::Range & r1,
                                const blitz::Range & r2,
                                const blitz::Range & r3 ) const;
    // to get beyond 4 dimensions
    const T & at( long x1, long x2, long x3, long x4, long x5, long x6=0,
                  long x7=0, long x8=0 ) const;
    T & at( long x1, long x2, long x3, long x4, long x5, long x6=0,
            long x7=0, long x8=0 );
    const T& operator()( long x1, long x2, long x3, long x4, long x5,
                         long x6=0, long x7=0, long x8=0 ) const;
    T& operator() ( long x1, long x2, long x3, long x4, long x5, long x6=0,
                    long x7=0, long x8=0 );
 
    //========================================================================
    //   INIT / ALLOCATION
    //========================================================================

    virtual void initialize();
    const AllocatorContext & allocatorContext() const;
    void allocate();
    virtual void reallocate( int sizeX = 1, int sizeY = 1, int sizeZ = 1,
                             int sizeT = 1, bool keepcontents = false,
                             const AllocatorContext& allocatorContext
                             = AllocatorContext(), bool allocate = true,
                             const std::vector<long> *strides = 0 );
    virtual void reallocate( const Position4Di & size,
                             bool keepcontents = false,
                             const AllocatorContext& allocatorContext
                             = AllocatorContext(), bool allocate = true,
                             const std::vector<long> *strides = 0 );
    virtual void reallocate( const std::vector<int> & size,
                             bool keepcontents = false,
                             const AllocatorContext& allocatorContext
                             = AllocatorContext(), bool allocate = true,
                             const std::vector<long> *strides = 0 );
    void allocateBorders( int bsx, int bsy = -1, int bsz = -1 );
    void allocateBorders( const std::vector<int> & border );
 
    //========================================================================
    //   COPY / VIEW
    //========================================================================

    Volume<T> copy() const;
    template <typename OUTP>
    Volume<OUTP> copy() const;
    Volume<T> deepcopy() const;
    template <typename OUTP>
    Volume<OUTP> deepcopy() const;

    Volume<T> copyStructure() const;
    template <typename OUTP>
    Volume<OUTP> copyStructure() const;

    void copySubVolume( const Volume<T> & source,
                        const std::vector<int> & pos = std::vector<int>() );
    void copySubVolume( const rc_ptr<Volume<T> > & source,
                        const std::vector<int> & pos = std::vector<int>() );

    template <typename OUTP>
    operator Volume<OUTP>() const;
    
    int getLevelsCount() const;
    
    int refLevel(const int level) const;

    rc_ptr<Volume<T> > refVolume() const;
    
    rc_ptr<Volume<T> > refVolumeAtLevel(const int level) const;
    
    void setRefVolume(const rc_ptr<Volume<T> > & refvol);
    const Position & posInRefVolume() const;
    Position posInRefVolumeAtLevel(const int level) const;

    void setPosInRefVolume(const Position4Di & pos);
    void setPosInRefVolume(const Position & pos);
    

    std::vector<int> getBorders() const;

    std::vector<long> getStrides() const;
 
    //========================================================================
    //   BOOLEANS / ACCUMULATED VALUES
    //========================================================================
    operator bool() const;
    bool all() const;
    bool any() const;
    T min() const;
    T max() const;
    typename DataTypeTraits<T>::LongType sum() const;
 
    //========================================================================
    //   FILL / REPLACE
    //========================================================================
    void fill( const T & value );
    void fillBorder( const T & value );

    const Referential & referential() const;
    Referential & referential();

    Volume<T> & operator= ( const T & value );

    void flipToOrientation( const std::string & orient );
    void flipToOrientation( const std::string & orient,
                            const std::string & force_memory_layout );
    Object reorientedHeader( const std::string & orient ) const;
    std::vector<int> memoryLayoutOrientation() const;
    std::vector<int> storageLayoutOrientation() const;
 
  protected:
    //========================================================================
    //   PRIVATE UTILS
    //========================================================================
    void allocate( int oldSizeX, int oldSizeY, int oldSizeZ, int oldSizeT,
                   bool allocate, const AllocatorContext& allocatorContext,
                   const std::vector<long> *strides = 0 );
    void allocate( const std::vector<int> & oldSize,
                   bool allocate, const AllocatorContext& allocatorContext,
                   const std::vector<long> *strides = 0 );
    void slotSizeChanged( const PropertyFilter& propertyFilter );
    void updateItemsBuffer();
 
    void constructBorders( const Position & bordersize,
                           const AllocatorContext& allocatorContext,
                           bool allocated );
 
    AllocatedVector<T> _items;
    // in case of negative strides, _start adds an offset to _items 1st element
    T *_start;
    blitz::Array<T, Volume<T>::DIM_MAX>  _blitz;
    rc_ptr<Volume<T> >  _refvol;
    std::vector<int>    _pos;
    Referential _referential;
  };
 
//============================================================================
//   POSITION VECTOR
//============================================================================
  template <typename T>
  class Volume<T>::Position4Di
  {
  public:
    explicit Position4Di( int x = 0, int y = 0, int z = 0, int t = 0 )
      : _coords( 4 )
    {
      _coords[0] = x;
      _coords[1] = y;
      _coords[2] = z;
      _coords[3] = t;
    }

    template <typename U>
    Position4Di( const U & other ):
      _coords(4)
    {
      for( size_t i = 0; i < size_t( other.size() ) && i < 4; ++i )
        _coords[i] = other[i];
      for( size_t i = size_t( other.size() ); i < 4; ++i )
        _coords[i] = 0;
    }
 
    Position4Di( const Position4Di & pos ) : _coords( pos._coords )
    {
    }
 
    ~Position4Di() {}
 
          int & operator [] ( int coord )       { return _coords[ coord ]; }
    const int & operator [] ( int coord ) const { return _coords[ coord ]; }
 
    bool operator==(const Position4Di& p) const
    {
      return ( _coords == p._coords );
    }
    bool operator!=(const Position4Di& p) const
    { return !(this->operator ==(p)); }
 
    unsigned size() const { return _coords.size(); }
    const std::vector<int> & toVector() const
    { return _coords; }
 
    /* utility functions, not really related, but which we don't really know
       where to put them */
    static std::vector<int> fixed_position( const std::vector<int> & vec )
    {
      if( vec.size() >= 4 )
        return vec;
      std::vector<int> fixed( vec );
      fixed.resize( 4 );
      for( int i=vec.size(); i<4; ++i )
        fixed[i] = 0;
      return fixed;
    }
 
    static std::vector<int> fixed_size( const std::vector<int> & vec )
    {
      if( vec.size() >= 4 )
        return vec;
      std::vector<int> fixed( vec );
      fixed.resize( 4 );
      for( int i=vec.size(); i<4; ++i )
        fixed[i] = 1;
      return fixed;
    }
 
    static unsigned long long size_num_elements( const std::vector<int> & vec )
    {
      int i, n = vec.size();
      unsigned long long num = 1;
      for( i=0; i<n; ++i )
        num *= vec[i];
      return num;
    }
 
  private:
    std::vector<int>  _coords;
  };
 
//============================================================================
//   UTILITIES
//============================================================================
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
 
  template <typename T>
  class DataTypeCode<Volume<T> >
  {
  public:
    static std::string objectType()
    { return "CartoVolume"; }
    static std::string dataType()
    { return DataTypeCode<T>::dataType(); }
    static std::string name()
    {
      return std::string("carto_volume of ") + DataTypeCode< T >::name();
    }
  };
 
  template <typename T>
  class Creator<Volume<T> >
  {
  public:
    static Volume<T>* create( Object, const AllocatorContext &, Object );
    static void setup( Volume<T> &, Object, const AllocatorContext &, Object );
  };
 
#endif
 
//============================================================================
// STREAM
//============================================================================
 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
 
  // Warper for output streams that integrates parameters for volume
  // printing
  class VolumeOStream // : public std::ostream // is not really a stream
  {
  public:
    VolumeOStream( std::ostream & ostream );
    VolumeOStream( const VolumeOStream & other );
    ~VolumeOStream();
 
    std::ostream & ostream() const;
 
    const size_t & maxT() const;
    const size_t & maxZ() const;
    const size_t & maxY() const;
    const size_t & maxX() const;
 
    size_t & maxT();
    size_t & maxZ();
    size_t & maxY();
    size_t & maxX();
 
  private:
    size_t _maxT;
    size_t _maxZ;
    size_t _maxY;
    size_t _maxX;
    std::ostream & _ostream;
  };
 
  // Object returned by setMaxDim used to set Volume printing parameters
  class VolumeOStreamSetter
  {
  public:
    VolumeOStreamSetter();
 
    const size_t & maxT() const;
    const size_t & maxZ() const;
    const size_t & maxY() const;
    const size_t & maxX() const;
 
    size_t & maxT();
    size_t & maxZ();
    size_t & maxY();
    size_t & maxX();
 
  private:
    size_t _maxT;
    size_t _maxZ;
    size_t _maxY;
    size_t _maxX;
  };
 
  VolumeOStream operator<< ( std::ostream & out,
                             const VolumeOStreamSetter & setter );
 
  template <typename T>
  std::ostream & operator<< ( const VolumeOStream & out,
                              const Volume<T> & volume );
 
  // Method used to set Volume printing parameters
  VolumeOStreamSetter setMaxDim( size_t m );
  VolumeOStreamSetter setMaxDim( size_t mx, size_t my, size_t mz, size_t mt );
 
  #endif // DOXYGEN_HIDE_INTERNAL_CLASSES
 

  template <typename T>
  std::ostream & operator<< ( std::ostream & out,
                              const Volume<T> & volume );
 

  template <typename T>
  void displayRefVolumes(const Volume<T> & vol);
 
} // namespace carto:
 
 
// the CT macro defined in blitz++ interferes with QColor::CT in Qt
#    ifdef CT
#      undef CT
#    endif
 
#endif // CARTODATA_VOLUME_VOLUMEBASE_H