ExtractSlice.hpp

#ifndef __FIBEROPERATIONS_EXTRACT_SLICE
#define __FIBEROPERATIONS_EXTRACT_SLICE
 
#include <field/MemBase.hpp>
#include <meta/LIST.hpp>
#include "SliceSelection.hpp"
 
namespace Fiber
{
 
template <class Array2D>
struct  ArrayCollector
{
        typedef RefPtr<Array2D> result_t;
 
        result_t        result;
        Array2D & dst;
 
        ArrayCollector(const MultiIndex<2>&Dims)
        : result( new Array2D(Dims) )
        , dst( *result )
        {
 
        }
 
        template <class ElementType>
        void collect(const MultiIndex<2>&Dims, const ElementType&T)
        {
                dst[ Dims ] = T;
        }
 
static  result_t Invalid()
        {
                return MemCore::NullPtr();
        }
};
 
template <class Operator, class Array3D>
struct  ExtractSlice
{
 
static  typename Operator::result_t get(const MultiIndex<3>&Dims,
                                        const RefPtr<MemBase>&Data, const SliceSelection&GO,
                                        index_t SliceID, const MultiIndex<3>&FragmentOffset)
        {
        RefPtr<Array3D> src = Data; 
                if (!src)
                        return Operator::Invalid();
 
        index_t Xsize = Dims[ GO.X ];
        index_t Ysize = Dims[ GO.Y ];
 
        Operator Op( MIndex(Xsize, Ysize) ); 
 
        const Array3D&Src = *src;
 
                for(index_t iy = 0; iy<Ysize; iy++)
                for(index_t ix = 0; ix<Xsize; ix++)
                {
                MultiIndex<3> P = FragmentOffset;
                        P[GO.X] += ix; P[GO.Y] += iy; P[GO.Z] += SliceID;
 
                MultiIndex<2> Pdst;
                        Pdst[ 0 ] = ix;
                        Pdst[ 1 ] = iy;
 
                        Op.collect( Pdst, Src[ P ] );
                } 
 
                return Op.result;
        }
};
 
template <class Operator, class Array3D, class NEXT>
struct  ExtractSlice<Operator, META::LIST<Array3D, NEXT> >
{
 
static  typename Operator::result_t get(const MultiIndex<3>&Dims,
                                        const RefPtr<MemBase>&Data, const SliceSelection&O,
                                        index_t SliceID, const MultiIndex<3>&FragmentOffset)
        {
                if (typename Operator::result_t result =
                    ExtractSlice<Operator, Array3D>::get(Dims, Data, O, SliceID, FragmentOffset) )
                {
                        return result;
                }
                return ExtractSlice<Operator, NEXT>::get(Dims, Data, O, SliceID, FragmentOffset);
        }
};
 
template <class Operator>
struct  ExtractSlice<Operator, META::NIL >
{
 
static  typename Operator::result_t get(const MultiIndex<3>&Dims,
                                        const RefPtr<MemBase>&Data, const SliceSelection&O,
                                        index_t SliceID, const MultiIndex<3>&FragmentOffset)
        {
                return Operator::Invalid();
        }
};
 
} // namespace Fiber
 
#endif //__FIBEROPERATIONS_EXTRACT_SLICE