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