SliceExtractor.hpp

#ifndef __FIBEROPERATIONS_SLICEEXTRACTOR_HPP
#define __FIBEROPERATIONS_SLICEEXTRACTOR_HPP
 
#include "gridopDllApi.h"
#include "RegularCoordinateSlice.hpp"
 
#include <field/OnDemandCreator.hpp>
 
namespace Fiber
{
 
template <class Converter>
struct  SliceConstructor : RegularCoordinateSlice
{
        RefPtr<CreativeArrayBase> myFullDomainDataCreator;
        index_t                   mySliceIndex;
        MultiIndex<3>             mySliceDims;
        const Converter           myConverter;
 
        SliceConstructor(const RegularCoordinateSlice&RCS,
                         index_t theSliceIndex,
                         const MultiIndex<3>&theSliceDims,
                         const WeakPtr<CreativeArrayBase>&theFullDomainDataCreator,
                         const Converter                 &theConverter)
        : RegularCoordinateSlice(RCS)
        , myFullDomainDataCreator(theFullDomainDataCreator)
        , mySliceIndex(theSliceIndex)
        , mySliceDims(theSliceDims)
        , myConverter( theConverter )
        {}
 
        bool    canExtract() const
        {
                if (RefPtr<SizeInterface> SourceSize = getSize(myFullDomainDataCreator) )
                {
                MultiIndex<3> SrcDims;
                        if (SourceSize->get(SrcDims))
                        {
                        const MultiIndex<3>&DstDims = mySliceDims;
 
                                // if the source is large than the destination, we can't perform slicing
                                if (SrcDims[X] > DstDims[X] )
                                {
                                        Assertion( SrcDims[X] <= DstDims[X], "if the source is large than the destination, we can't perform slicing in X" );
                                        return false;
                                }
                                if (SrcDims[Y] > DstDims[Y] )
                                {
                                        Assertion( SrcDims[Y] <= DstDims[Y], "if the source is large than the destination, we can't perform slicing in Y" );
                                        return false;
                                }
                        }
                }
                return true;
        }
 
};
 
 
template <class Converter, class InputType = typename Converter::input_type>
        struct  SliceExtractor;
 
 
template <class Converter>
struct  SliceExtractor<Converter, META::NIL>
{
        typedef SliceConstructor<Converter> Constructor_t;
 
        typedef typename Converter::output_type output_type;
 
        typedef MemArray<3,output_type> ResultArray_t;
        RefPtr<ResultArray_t>           result_storage;
 
        SliceExtractor(Constructor_t&Params, const WeakPtr<CreativeArrayBase>&)
        {}
 
        RefPtr<ResultArray_t> result() const
        {
                return result_storage;
        }
};
 
 
template <class Converter, class InputType>
struct  SliceExtractor : SliceExtractor<Converter, META::NIL>
{
        typedef typename SliceExtractor<Converter, META::NIL>::Constructor_t Constructor_t;
 
        typedef typename Converter::output_type output_type;
        typedef InputType                       input_type;
 
        SliceExtractor(Constructor_t&Params, const WeakPtr<CreativeArrayBase>&CAB)
        : SliceExtractor<Converter, META::NIL>(Params, CAB)
        {
                /*
                  Extract 2D data from 3D.
                */
                if (RefPtr<MemArray<3, input_type> >
                    D = Params.myFullDomainDataCreator->create() )
                {
                const MultiArray<3, input_type>&Src = *D;
 
                MemCore::Ref<MemArray<3, output_type> > OutputArray( Params.mySliceDims );
                MultiArray  <3, output_type> Dst = *OutputArray;
 
#ifdef  VERBOSE
                puts("Performing actual Data slicing 3D --> 2D"); fflush(stdout);
#endif
 
                        if (Params.extractDataToOriented3D(Dst, 0, Src, Params.mySliceIndex, Params.myConverter) )
                                this->result_storage = OutputArray;
                }
                else
                {
                        Verbose(0) << "Unsupported data type for data extraction." << typeid(input_type).name()
                                   << " --> " << typeid(output_type).name();
                }
        }
};
 
 
template <class Converter, class InputType, class NextType>
struct  SliceExtractor<Converter, META::LIST<InputType, NextType> > : SliceExtractor<Converter, NextType>
{
        typedef typename SliceExtractor<Converter, META::NIL>::Constructor_t Constructor_t;
 
        typedef typename Converter::output_type output_type;
        typedef InputType                       input_type;
 
        SliceExtractor(Constructor_t&Params, const WeakPtr<CreativeArrayBase>&CAB)
        : SliceExtractor<Converter, NextType>(Params, CAB)
        {
                assert( Params.myFullDomainDataCreator );
                if (!Params.myFullDomainDataCreator ) return;
 
                /*
                  Extract 2D data from 3D.
                */
                if (RefPtr<MemArray<3, input_type> >
                    S = Params.myFullDomainDataCreator->create() )
                {
                const MultiArray<3, input_type>&Src = *S;
                MemCore::Ref<MemArray<3, output_type> > OutputArray( Params.mySliceDims );
                MultiArray  <3, output_type>&Dst = *OutputArray;
 
#ifdef  VERBOSE
                printf("SliceExtractor: 3D --> 2D src (%dx%dx%d) ==> dst (%dx%dx%d) \n",
                       int(Src.Size()[0]), int(Src.Size()[1]), int(Src.Size()[2]),
                       int(Dst.Size()[0]), int(Dst.Size()[1]), int(Dst.Size()[2]) );
                fflush(stdout);
#endif
                        if (Params.extractDataToOriented3D(Dst, 0, Src, Params.mySliceIndex, Params.myConverter) )
                        {
                                this->result_storage = OutputArray;
                        }
                }
        }
};
 
 
 
} // namespace Fiber
 
#endif // __FIBEROPERATIONS_SLICEEXTRACTOR_HPP