200-SpatialSorting.cpp File Reference

[← Previous Example] [Next Example → 300-Interpolator.cpp ]. More...

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <memcore/Console.hpp>
#include <fish/fiber/baseop/ExpandBBox.hpp>
#include <string>

Classes
struct	MyProgress
struct	FragIt
class	SliceIterator

Functions
int	main (int argc, char **argv)

Detailed Description

[← Previous Example] [Next Example → 300-Interpolator.cpp ].

In FiberLib Tutorial

/**
 *  small infrastructure to implement spatial sorting
 *  @author: Doeby & Werner
 *  @date: 2015/10/19
 */
 
#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <memcore/Console.hpp>
#include <fish/fiber/baseop/ExpandBBox.hpp>
 
#include <string>
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
using namespace std;
 
struct  MyProgress : BundleLoaderProgress
{
string GridName ;
 
        bool    CreateGrid(const RefPtr<GridID>&gname, Grid&G, double t) override
        {
                GridName  = gname->Name();
                return true;
        }
 
        bool    CreateField(const RefPtr<GridID>&gname, Grid&G, double t,
                                    const string&fieldname) override
        {
                return true;
        }
};
 
// ----------- FRAG ------------
struct FragIt : Field::Iterator
{
RefPtr<Field>&OutputField;
 
        FragIt(RefPtr<Field>&OutputFieldP)
        : OutputField(OutputFieldP)
        {}
 
        bool apply(const RefPtr<FragmentID>&fid,
                   const RefPtr<CreativeArrayBase>&CAB)
        {
 
        RefPtr<MemArray<1,point> > MemIn = CAB->create();
        MultiArray<1,point>&MulIn = *MemIn;
 
        RefPtr<MemArray<1,point> > MemOut = new MemArray<1,point>( MemIn->nElements() );
        MultiArray<1,point>&MulOut = *MemOut;
 
                //implementing spatial sorting......
                for (auto I : MulIn.Size() )
                        MulOut[I] = MulIn[I];
 
        RefPtr<FragmentID> NewFragID =  OutputField->makeFragmentID( fid->Name() );
 
                Console() << "Save Fragment: " << fid->Name() << " with " <<  MemIn->nElements() ;
 
                OutputField->setPersistentData(MemOut,NewFragID);
 
                return true;
        }
};
 
// ----------- SLICE ------------
class SliceIterator : public EvolutionIterator<Slice>
{
public:
string&GridName;
BundlePtr&BPNew;
 
        SliceIterator(string&GridNameP,BundlePtr&BPNewP)
        : GridName(GridNameP)
        , BPNew(BPNewP)
        {}
 
        bool apply(ParameterSet&P, Slice&S)
        {
        RefPtr<Grid> InGrid  = S(GridName);
 
                if (!InGrid)
                        return true;
 
        RefPtr<Field> myPositions = InGrid->getCartesianPositions();
 
                if (!myPositions)
                        return false;
 
        Representation&myCartesianRepresentation = BPNew[0.0]["myGrid"].makeCartesianRepresentation(3);
 
        RefPtr<Field>&OutputField = myCartesianRepresentation[ FIBER_POSITIONS ];
                OutputField = new Field();
 
                if (!OutputField)
                        return false;
 
        FragIt myfragit(OutputField);
                if ( !myPositions->iterate(myfragit) )
                        return false;
 
                return true;
        }
};
 
// ----------- MAIN ------------
int     main(int argc, char** argv)
{
        // initialize
        Finit();
 
string FileName = argv[1];
 
        Console() << "Input File: " << FileName;
 
// load bundle
bool    success;
BundlePtr BP;
RefPtr<MyProgress> Ptr = new   MyProgress();
        BP = Bundle::load( success,  FileName , BP, Ptr);
 
        if (!success)
        {
                Console() << "Could not read file: " ;
                return true;
        }
 
// new Bundle
BundlePtr BPNew = new Bundle();
        BPNew->bindToNew("200_SpacialSorting.f5");
 
SliceIterator mySliceIterator(Ptr->GridName,BPNew);
        if ( !BP->iterate(ParameterList(), mySliceIterator) )
        {
                Console() << "Error";
                return 1;
        }
 
        return 0;
}