Fiber::SliceExtractor< Converter, InputType > Struct Template Reference

Template class to construct an OnDemandCreator to extract a 2D slice from a 3D data array with abitrary data conversion during extraction. More...

#include <SliceExtractor.hpp>

Public Types
typedef SliceExtractor< Converter, META::NIL >::Constructor_t	Constructor_t
typedef Converter::output_type	output_type
typedef InputType	input_type

Public Member Functions
	SliceExtractor (Constructor_t &Params, const WeakPtr< CreativeArrayBase > &CAB)

Detailed Description

template<class Converter, class InputType>
struct Fiber::SliceExtractor< Converter, InputType >

Template class to construct an OnDemandCreator to extract a 2D slice from a 3D data array with abitrary data conversion during extraction.

The slice extractor for a specific input type.

The converter template class argument needs to provides an optional input and mandatory output types, plus a copy() function:

struct  CopyConverter
{
        typedef double  input_type;
        typedef double  output_type;
 
        template <class Dst, class Src>
                void    copy(Dst&dst, const Src&src) const
                {
                        dst = src;
                }
};

Using the SliceExtractor then allows to define a Creator that extracts slices on demand from a list of possible input types:

using namespace META;
typedef OnDemandCreator<SliceExtractor<CopyConverter, LIST<double, LIST<float> > > > MyExtractionCreator;

Usage:

const RefPtr<FragmentID>&fid;
const RefPtr<CreativeArrayBase>&DataCreator;
        ...
 
CopyConverter myConverter;
 
        // Extract 2D data from 3D on demand.
        OutputField->setCreator(new MyExtractionCreator(
                                        SliceConstructor<CopyConverter>(myRCS, sliceIndex, SliceDims, DataCreator, myConverter),
                                        MemCore::Cache::MemCache() ), fid);

Note that some output arrays require the destination type to be a type itself instead of a reference to a type when access to an array is performed via a proxy class. This is the case for instance when using FixedArray<> as argument type:

struct  ToDbl3Converter
{
        typedef FixedArray<double,3> output_type;
 
        template <class Dst, class Src>
        void copy(Dst dst, const Src&src) const
        {
                dst = src;
        }
};
 
template class OnDemandCreator<SliceExtractor<ToDbl3Converter, LIST<FixedArray<double,3> > > >;

As advanced usage, the converter may also perform numerical operations during slice extraction, for instance computing the norm of a vector (actually, a 3-vector's base class in this code snippet):

struct  NormalizingConverter
{
        typedef double output_type;
 
        void copy(double&dst, const FixedArray<double,3>&P) const
        {
        dst = sqrt( P[0]*P[0] + P[1]*P[1] + P[2]*P[2] );
        }
};
 
template class OnDemandCreator<SliceExtractor<NormalizingConverter, LIST<FixedArray<double,3> > > >;

See also

Slicer