FragmentSlicer.hpp

#ifndef __FIBEROPERATIONS_FRAGMENTSLICER_HPP
#define __FIBEROPERATIONS_FRAGMENTSLICER_HPP
 
#include "SliceExtractor.hpp"
#include "RegularCoordinateSlice.hpp"
 
#include <field/Field.hpp>
 
#undef Verbose
#define Verbose(X) AppVerbose("FieldSlice",X)
 
namespace Fiber
{
 
template <class Converter, class InputTypes>
struct  FragmentSlicer : Field::Iterator
{
        RegularCoordinateSlice& myRCS;
        double          myCoordinateValue;
        RefPtr<Field>   myCoordinates;
 
        RefPtr<Field>   &mySliceCoordinateField;
        RefPtr<Field>   OutputField;
 
        const Converter myConverter;
 
        typedef OnDemandCreator<SliceExtractor<Converter, InputTypes> > MyExtractionCreator;
 
        FragmentSlicer(RegularCoordinateSlice&theRCS,
                       double theCoordinateValue,
                       const RefPtr<Field>&theCoordinates,
                       RefPtr<Field>&theSliceCoordinates,
                       const Converter  &theConverter)
        : myRCS(theRCS)
        , myCoordinateValue( theCoordinateValue )
        , myCoordinates( theCoordinates )
        , mySliceCoordinateField( theSliceCoordinates )
        , myConverter( theConverter )
        {}
 
        /*
          Note: the FragmentID is for the external field, my both fields in here have local fragment IDs.
         */
        bool    apply(const RefPtr<FragmentID>&fid, const RefPtr<CreativeArrayBase>&DataCreator) override
        {
        double  CoordinateIndex = -1U;
 
                Verbose(5) << " FragmentSlicer::apply(fid=" << FragmentID::Name(fid) << ")";
 
#ifdef  VERBOSE
                if (fid) printf("  FragmentSlicer::apply(fid=%s)\n", fid->Name().c_str() );
                else     puts  ("  FragmentSlicer::apply(contiguous field)");
#endif
 
                if (!myRCS.getRectilinearIndex(myCoordinateValue,
                                               myCoordinates, fid,
                                               CoordinateIndex) )
                {
#ifdef  VERBOSE
                        puts("  FragmentSlicer::apply(): could not get coordinate index");
#endif
                        // use coordinate value for irregular/curvilinear
                        return true;
                }
#ifdef  VERBOSE
                printf("  FragmentSlicer's getRectilinearIndex() yielded an exact slice value of %lg)\n", CoordinateIndex );
#endif
 
        index_t sliceIndex = index_t(floor(CoordinateIndex+0.5) );
        MultiIndex<3> DataDims;
                if (!makeDimensions(DataDims, DataCreator) )
                {
// might try here to get a field fragment's
// dimension from elsewhere, such as the coordinates, if possible
                        puts("FieldSlice: Could not Make Size Interface in Creator, no field Creatable!");
                        return true;
                }
 
        Verbose(5) << "  FragmentSlicer::apply() Coordinate Index for this slice is " << sliceIndex;
 
 
        RefPtr<FragmentID> SliceFragID;
        MultiIndex<3> SliceDims;
                {
                        if (!mySliceCoordinateField)
                        {
                        RefPtr<FragmentIDCollection> FIC;
                                if (fid) FIC = fid->getFragmentIDCollection();
 
                                Verbose(0) << " No mySliceCoordinateField - Creating a new one!";
                                mySliceCoordinateField = new Field(FIC);
                        }
 
                        if (fid)
                                SliceFragID = mySliceCoordinateField->makeFragmentID( fid->Name() + "_2D" );
 
//                      SliceFragID = fid;
 
                bool    GotSliceDimensions = false;
                        if (RefPtr<CreativeArrayBase>
                            SliceFragmentCreator = mySliceCoordinateField->getCreator( SliceFragID ) )
                        {
                                if (makeDimensions(SliceDims, SliceFragmentCreator) )
                                {
                                        GotSliceDimensions = true;
                                }
                        }
 
                        if (!GotSliceDimensions)
                        {
                        RefPtr<MemBase>
                                SliceCoordinates = mySliceCoordinateField->getData( SliceFragID );
 
                                if (!SliceCoordinates)
                                {
                                        SliceCoordinates = myRCS.getCoordinates(sliceIndex, DataDims,
                                                                                myCoordinates, fid);
 
                                        if (SliceCoordinates)
                                        {
                                                Verbose(5) << "ADDING sliced data set originating from 3D source...";
                                                mySliceCoordinateField->setDiscardableData(SliceCoordinates,  MemCore::Cache::MemCache(), SliceFragID );
                                        }
                                        else
                                        {
                                                Verbose(5) << "   Could not produce slice coordinates for index " << sliceIndex
                                                           <<", call to RegularCoordinateSlice::getCoordinates() failed.";
                                        }
                                }
 
                                if (!SliceCoordinates)
                                {
                                        Verbose(5) << "  --> slice index is out of range for the given coordinate value, no slice data provided.";
 
                                        // slice index out of range for the given coordinate value
                                        // so nothing to be done here.
                                        return true;
                                }
                                if (RefPtr<MemArrayBase<3> > SliceCoordinatesAs3DSubset = SliceCoordinates)
                                {
                                                SliceDims = SliceCoordinatesAs3DSubset->Size();
                                }
                                else
                                {
                                        assert( 0 && "Sorry, slice data has not been specified as 3D array, which is easy to support but has not been implemented for now." );
                                        return true;
                                }
                        }
                }
 
                assert( SliceDims.size()>0 );
 
        SliceConstructor<Converter> MySliceConstructor(myRCS, sliceIndex, SliceDims, DataCreator, myConverter);
                if (!MySliceConstructor.canExtract())
                {
                        printf(__FILE__ " FragmentSlicer: cannot extract slice, destination is too small for input %dx%dx%d\n",
                               int(SliceDims[0]), int(SliceDims[1]), int(SliceDims[2]) );
//                      MemCore::breakpoint();
                        return true;
                }
 
                if (!OutputField)
                {
                        Verbose(5) << "Creating new output field";
                        OutputField = new Field( mySliceCoordinateField->getFragmentIDCollection() );
                }
                else
                {
                        Verbose(5) << "Reusing previous OutputField";
                }
 
                Verbose(5) << "Slicer is setting up slice constructor for "
                           << SliceDims[0] << "x" << SliceDims[1] << "x" << SliceDims[2];
 
                Assert( mySliceCoordinateField->getFragmentIDCollection() == OutputField->getFragmentIDCollection() );
 
                OutputField->setCreator(new MyExtractionCreator(MySliceConstructor, MemCore::Cache::MemCache() ), SliceFragID );
 
                return true;
        }
};
 
 
} // namespace Fiber
 
#endif // __FIBEROPERATIONS_FRAGMENTSLICER_HPP