/scr/tee1/isis/lib/Core/DataStorage/chunk.hpp

Go to the documentation of this file.

//
// C++ Interface: chunk
//
// Description:
//
//
// Author: Enrico Reimer<reimer@cbs.mpg.de>, (C) 2009
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef CHUNK_H
#define CHUNK_H

#include "valuearray.hpp"
#include "../CoreUtils/log.hpp"
#include "../CoreUtils/propmap.hpp"
#include "common.hpp"
#include <string.h>
#include <list>
#include "ndimensional.hpp"
#include "../CoreUtils/vector.hpp"

#include <boost/numeric/ublas/matrix.hpp>

namespace isis
{
namespace data
{

class Chunk;

namespace _internal
{
class ChunkBase : public NDimensional<4>, public util::PropertyMap
{
protected:
    ChunkBase() {}; //do not use this
public:
    //  static const dimensions dimension[n_dims]={rowDim,columnDim,sliceDim,timeDim};
    typedef isis::util::_internal::GenericReference<ChunkBase > Reference;

    ChunkBase( size_t nrOfColumns, size_t nrOfRows, size_t nrOfSlices, size_t nrOfTimesteps );
    virtual ~ChunkBase(); //needed to make it polymorphic
    static const char *neededProperties;
};
}

template <typename TYPE> class VoxelOp: std::unary_function<bool, TYPE>
{
public:
    virtual bool operator()( TYPE &vox, const util::vector4<size_t> &pos ) = 0;
    virtual ~VoxelOp() {}
};

class Chunk : public _internal::ChunkBase, protected ValueArrayReference
{
    friend class Image;
    friend class std::vector<Chunk>;
protected:
    template<typename TYPE, typename D> Chunk( TYPE *src, D d, size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1 ):
        _internal::ChunkBase( nrOfColumns, nrOfRows, nrOfSlices, nrOfTimesteps ), ValueArrayReference( ValueArray<TYPE>( src, getVolume(), d ) ) {}

    Chunk() {}; //do not use this
public:

    typedef ValueArrayBase::value_iterator iterator;
    typedef ValueArrayBase::const_value_iterator const_iterator;
    typedef iterator::reference reference;
    typedef const_iterator::reference const_reference;

    Chunk( const isis::data::ValueArrayReference &src, size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1, bool fakeValid = false );

    template<typename TYPE> TYPE &voxel( size_t nrOfColumns, size_t nrOfRows = 0, size_t nrOfSlices = 0, size_t nrOfTimesteps = 0 ) {
        const size_t idx[] = {nrOfColumns, nrOfRows, nrOfSlices, nrOfTimesteps};
        LOG_IF( ! isInRange( idx ), Debug, isis::error )
                << "Index " << util::vector4<size_t>( idx ) << " is out of range " << getSizeAsString();
        ValueArray<TYPE> &ret = asValueArray<TYPE>();
        return ret[getLinearIndex( idx )];
    }

    const util::ValueReference getVoxelValue( size_t nrOfColumns, size_t nrOfRows = 0, size_t nrOfSlices = 0, size_t nrOfTimesteps = 0 )const;
    void setVoxelValue( const util::ValueReference &val, size_t nrOfColumns, size_t nrOfRows = 0, size_t nrOfSlices = 0, size_t nrOfTimesteps = 0 );

    template<typename TYPE> const TYPE &voxel( size_t nrOfColumns, size_t nrOfRows = 0, size_t nrOfSlices = 0, size_t nrOfTimesteps = 0 )const {
        const size_t idx[] = {nrOfColumns, nrOfRows, nrOfSlices, nrOfTimesteps};

        if ( !isInRange( idx ) ) {
            LOG( Debug, isis::error )
                    << "Index " << util::vector4<size_t>( idx ) << nrOfTimesteps
                    << " is out of range (" << getSizeAsString() << ")";
        }

        const ValueArray<TYPE> &ret = const_cast<Chunk &>( *this ).asValueArray<TYPE>();

        return ret[getLinearIndex( idx )];
    }

    void copySlice( size_t thirdDimS, size_t fourthDimS, Chunk &dst, size_t thirdDimD, size_t fourthDimD ) const;

    template <typename TYPE> size_t foreachVoxel( VoxelOp<TYPE> &op, util::vector4<size_t> offset ) {
        const util::vector4<size_t> imagesize = getSizeAsVector();
        util::vector4<size_t> pos;
        TYPE *vox = &asValueArray<TYPE>()[0];
        size_t ret = 0;

        for( pos[timeDim] = 0; pos[timeDim] < imagesize[timeDim]; pos[timeDim]++ )
            for( pos[sliceDim] = 0; pos[sliceDim] < imagesize[sliceDim]; pos[sliceDim]++ )
                for( pos[columnDim] = 0; pos[columnDim] < imagesize[columnDim]; pos[columnDim]++ )
                    for( pos[rowDim] = 0; pos[rowDim] < imagesize[rowDim]; pos[rowDim]++ ) {
                        if( op( *( vox++ ), pos + offset ) == false )
                            ++ret;
                    }

        return ret;
    }

    template<typename TYPE> size_t foreachVoxel( VoxelOp<TYPE> &op ) {
        return foreachVoxel<TYPE>( op, util::vector4<size_t>() );
    }

    iterator begin();
    iterator end();
    const_iterator begin()const;
    const_iterator end()const;

    ValueArrayBase &asValueArrayBase() {return operator*();}
    const ValueArrayBase &getValueArrayBase()const {return operator*();}

    template<typename TYPE> ValueArray<TYPE> &asValueArray() {return asValueArrayBase().castToValueArray<TYPE>();}
    template<typename TYPE> const ValueArray<TYPE> getValueArray()const {return getValueArrayBase().castToValueArray<TYPE>();}

    size_t useCount()const;

    Chunk cloneToNew( size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1 )const;

    static Chunk createByID( short unsigned int ID, size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1, bool fakeValid = false );

    bool convertToType( short unsigned int ID, scaling_pair scaling = scaling_pair() );

    template<typename T> bool copyToMem( T *dst, size_t len, scaling_pair scaling = scaling_pair() )const {
        return getValueArrayBase().copyToMem<T>( dst, len,  scaling ); // use copyToMem of ValueArrayBase
    }
    Chunk copyByID( unsigned short ID = 0, scaling_pair scaling = scaling_pair() )const;

    scaling_pair getScalingTo( unsigned short typeID, autoscaleOption scaleopt = autoscale )const;
    scaling_pair getScalingTo( unsigned short typeID, const std::pair<util::ValueReference, util::ValueReference> &minmax, autoscaleOption scaleopt = autoscale )const;

    size_t getBytesPerVoxel()const;
    std::string getTypeName()const;
    unsigned short getTypeID()const;
    template<typename T> bool is()const {return getValueArrayBase().is<T>();}

    void copyRange( const size_t source_start[], const size_t source_end[], Chunk &dst, const size_t destination[] )const;

    size_t compare( const Chunk &dst )const;
    size_t compareRange( const size_t source_start[], const size_t source_end[], const Chunk &dst, const size_t destination[] )const;

    std::pair<util::ValueReference, util::ValueReference> getMinMax()const;

    Chunk &operator=( const Chunk &ref );

    std::list<Chunk> autoSplice( uint32_t acquisitionNumberStride = 0 )const;

    std::list<Chunk> splice( dimensions atDim )const;

    bool transformCoords( boost::numeric::ublas::matrix<float> transform_matrix, bool transformCenterIsImageCenter = false ) {
        LOG_IF(  !hasProperty( "rowVec" ) || !hasProperty( "columnVec" ) || !hasProperty( "sliceVec" )
                 || !hasProperty( "voxelSize" ) || !hasProperty( "indexOrigin" ), Debug, error )
                << "Cannot do Chunk::transformCoords because of missing properties!";

        if( !isis::data::_internal::transformCoords( *this, getSizeAsVector(), transform_matrix, transformCenterIsImageCenter ) ) {
            LOG( Runtime, error ) << "Error during transforming the coords of the chunk.";
            return false;
        }

        return true;
    }
    void swapAlong( const dimensions dim ) const;

    util::PropertyValue &propertyValueAt( const util::PropertyMap::KeyType &key, size_t at );
    const util::PropertyValue &propertyValueAt( const util::PropertyMap::KeyType &key, size_t at )const;
};

template<typename TYPE> class MemChunk : public Chunk
{
public:
    MemChunk( size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1 ):
        Chunk( ValueArrayReference( ValueArray<TYPE>( nrOfColumns *nrOfRows *nrOfSlices *nrOfTimesteps ) ), nrOfColumns, nrOfRows, nrOfSlices, nrOfTimesteps ) {}
    template<typename T> MemChunk( const T *const org, size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1 ):
        Chunk( ValueArrayReference( ValueArray<TYPE>( nrOfColumns *nrOfRows *nrOfSlices *nrOfTimesteps ) ), nrOfColumns, nrOfRows, nrOfSlices, nrOfTimesteps ) {
        util::checkType<T>();
        asValueArrayBase().copyFromMem( org, getVolume() );
    }
    MemChunk( const Chunk &ref ): Chunk( ref ) {
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID ) );
    }
    MemChunk( const Chunk &ref, const scaling_pair &scaling ): Chunk( ref ) {
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID, scaling ) );
    }
    MemChunk( const MemChunk<TYPE> &ref ): Chunk( ref ) { //this is needed, to prevent generation of default-copy constructor
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID ) );
    }
    MemChunk &operator=( const Chunk &ref ) {
        LOG_IF( useCount() > 1, Debug, warning )
                << "Not overwriting current chunk memory (which is still used by " << useCount() - 1 << " other chunk(s)).";
        Chunk::operator=( ref ); //copy the chunk of ref
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID ) );
        return *this;
    }
    MemChunk &operator=( const MemChunk<TYPE> &ref ) { //this is needed, to prevent generation of default-copy operator
        return operator=( static_cast<const Chunk &>( ref ) );
    }
};


template<typename TYPE> class MemChunkNonDel : public Chunk
{
public:
    //
    MemChunkNonDel( size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1 ):
        Chunk(
            ( TYPE * )calloc( nrOfTimesteps *nrOfSlices *nrOfRows *nrOfColumns, sizeof( TYPE ) ),
            typename ValueArray<TYPE>::NonDeleter(),
            nrOfColumns, nrOfRows, nrOfSlices, nrOfTimesteps
        ) {}
    template<typename T> MemChunkNonDel( const T *const org, size_t nrOfColumns, size_t nrOfRows = 1, size_t nrOfSlices = 1, size_t nrOfTimesteps = 1 ):
        Chunk(
            ( TYPE * )malloc( sizeof( TYPE )*nrOfTimesteps *nrOfSlices *nrOfRows *nrOfColumns ),
            typename ValueArray<TYPE>::NonDeleter(),
            nrOfColumns, nrOfRows, nrOfSlices, nrOfTimesteps
        ) {
        util::checkType<T>();
        asValueArrayBase().copyFromMem( org, getVolume() );
    }
    MemChunkNonDel( const Chunk &ref ): Chunk( ref ) {
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID ) );
    }
    MemChunkNonDel( const Chunk &ref, const util::ValueBase &min, const  util::ValueBase &max ): Chunk( ref ) {
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID, min, max ) );
    }
    MemChunkNonDel( const MemChunk<TYPE> &ref ): Chunk( ref ) { //this is needed, to prevent generation of default-copy constructor
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID ) );
    }
    MemChunkNonDel &operator=( const Chunk &ref ) {
        LOG_IF( useCount() > 1, Debug, warning )
                << "Not overwriting current chunk memory (which is still used by " << useCount() - 1 << " other chunk(s)).";
        Chunk::operator=( ref ); //copy the chunk of ref
        //get rid of my ValueArray and make a new copying/converting the data of ref (use the reset-function of the scoped_ptr Chunk is made of)
        ValueArrayReference::operator=( ref.getValueArrayBase().copyByID( ValueArray<TYPE>::staticID ) );
        return *this;
    }
    MemChunkNonDel &operator=( const MemChunkNonDel<TYPE> &ref ) { //this is needed, to prevent generation of default-copy operator
        return operator=( static_cast<const Chunk &>( ref ) );
    }
};
}
}
namespace std
{
template<typename charT, typename traits>
basic_ostream<charT, traits>& operator<<( basic_ostream<charT, traits> &out, const isis::data::Chunk &s )
{
    return out << static_cast<const isis::util::PropertyMap &>( s );
}
}
#endif // CHUNK_H