132-RepresentSortedAsUnsortedCartesianChart.cpp File Reference

[← Previous Example] [Next Example → 141-LambdaBinding.cpp ]. More...

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <fiber/field/ArrayRef.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <fiber/grid/types/RegularlyFragmentedGrid.hpp>

Functions
int	main ()

Detailed Description

[← Previous Example] [Next Example → 141-LambdaBinding.cpp ].

In FiberLib Tutorial

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
 
#include <fiber/field/ArrayRef.hpp>
#include <eagle/PhysicalSpace.hpp>
 
#include <fiber/grid/types/RegularlyFragmentedGrid.hpp>
 
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
 
 
int     main()
{
        // Initialize I/O layers
        Finit(); 
 
        // 
        // Create a bundle object with a grid at T=1.0, named "myGrid", in 
        // a three-dimensional cartesian representation, using the default 
        // coordinate system.
        //
BundlePtr BP = new Bundle();
 
Slice&mySlice = BP[0];
 
Grid&GridOfUnsortedPoints = mySlice["UnsortedPoints"]; 
 
Representation&CartesianRepresentationOfUnsortedPoints =
        GridOfUnsortedPoints.makeCartesianRepresentation(3);
 
Ref< MemArray<1,point> > Coordinates(80); 
        for(auto P : *Coordinates )
        {
        index_t i = P.getIndex();
                P->x() = 0.001 * i;
                P->y() = 0.002 * i;
                P->z() = 0.003 * i;
        }
        CartesianRepresentationOfUnsortedPoints.setPositions( new Field( Coordinates ));
 
RefPtr<Skeleton> VertexSkeletonOfUnsortedPoints = GridOfUnsortedPoints.findVertices(); 
                Assert(VertexSkeletonOfUnsortedPoints);
 
/**
        ######### Index List #######
*/
Grid&GridOfSortedPoints = mySlice["SortedPoints"]; 
 
Skeleton&VertexSkeletonOfSortedPoints  = GridOfSortedPoints[ SkeletonID(3,0) ]; // 3d neighbourhood expected, 0 index depth ->point 
 
/**
   Representation of Skeleton Sorted to Skeleton Unsorted
 */ 
 
Representation&RepresentSortedAsUnsorted = VertexSkeletonOfSortedPoints[ VertexSkeletonOfUnsortedPoints ];
 
bool    Unfragmented = true; 
 
        if (Unfragmented)
        {
        Ref< MemArray<1,index_t> > Indices(80); 
                for(auto I : *Indices)
                {
                        I = I.getIndex();
                }
 
                RepresentSortedAsUnsorted.setPositions(new Field(Indices ));
        } 
        else
        {
        RefPtr<RegularlyFragmentedField<3> > FieldPositionsOfSortedAsUnsorted= new RegularlyFragmentedField<3>({2,2,2});
 
                for(auto&F :FieldPositionsOfSortedAsUnsorted->getNumberOfFragments() )
                {
                RefPtr< MemArray<1,index_t> > MB = new MemArray<1,index_t>(10);
                        (*FieldPositionsOfSortedAsUnsorted)[F] = new CreativeArray(MB, MemCore::Cache::MemCache() );
                }
 
                RepresentSortedAsUnsorted.setPositions(FieldPositionsOfSortedAsUnsorted);
        }
 
        BP.save("132_RepresentSortedAsUnsortedCartesianChart.f5");
 
        Verbose(0) << BP->xml(); 
 
        return 0;
}

Function Documentation

main()

int main

(

)

######### Index List #######

Representation of Skeleton Sorted to Skeleton Unsorted

References Fiber::HyperslabParameters::getIndex(), MemCore::Cache::MemCache(), and Fiber::BundlePtr::save().