XF_LineSetHierarchicalRegularized.cpp

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
 
#include <fiber/grid/types/LineSet.hpp>
#include <fiber/grid/types/RefinedFragmentSkeleton.hpp>
#include <fiber/grid/types/RegularlyFragmentedGrid.hpp>
 
#include <memcore/Console.hpp>
 
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
 
int     main()
{
        Finit();
 
BundlePtr BP;
Grid&GridOfFragmentedLines = BP[0.0]["HierarchicalLineSetRegular"];
RefPtr<Chart> myChart = GridOfFragmentedLines.makeCartesianChart();
 
const unsigned MaxLevel = 4;
        for(unsigned Level = 1; Level< MaxLevel;  Level++)
        {
        unsigned NFragsPerDim = 1<<(Level-1);
        MultiIndex<3> NFrags = { NFragsPerDim,NFragsPerDim,NFragsPerDim };
 
        string  FragmentNamePrefix = "LineFragmentL" + std::to_string(Level) + "#";
 
        RefPtr<RegularlyFragmentedField<3>>
                Coordinates  = new RegularlyFragmentedField<3>( NFrags, FragmentNamePrefix ),
                Connectivity = new RegularlyFragmentedField<3>( NFrags, FragmentNamePrefix );
 
        double  CellSize = 0.25/NFragsPerDim; // the more fragments the smaller the cellsize
 
        string  FragmentPrefix = "LineFragmentL" + std::to_string(Level) + "#";
 
                for(unsigned Z = 0; Z<NFragsPerDim; Z++)
                for(unsigned Y = 0; Y<NFragsPerDim; Y++)
                for(unsigned X = 0; X<NFragsPerDim; X++)
                {
                MultiIndex<3> FragID = { X,Y,Z };
 
                        //
                        // Coordinates
                        //
                        {
                        Ref<LineSet::CoordsMemArray_t> CoordsArray( 1024 );
                        std::vector<point>&Crds = CoordsArray->myChunk()->get_vector();
                        
                        int     some_int = 0;
                                for(auto&P : Crds)
                                {
                                        P.x() =       double( some_int%32      + X* 37.0)/NFragsPerDim; 
                                        P.y() =       double( (some_int/ 8)%32 + Y* 43.0)/NFragsPerDim;
                                        P.z() =   0.6*double( (some_int/64)%32 + Z* 39.0)/NFragsPerDim;
 
                                        some_int++;
                                }
                        auto&VertexFrag =
                                (*Coordinates)[ FragID ] = new CreativeArray( CoordsArray ); 
                                Coordinates->own( VertexFrag );
 
                                *VertexFrag << "CellSize" << CellSize;
                        }
 
                        //
                        // Connectivity 
                        //
                        {
                        Ref<LineSet::LinesetArray_t>     LinesetArray(32);
                        MultiArray<1, std::vector<LineSet::LineIndex_t> >&LineIndices = *LinesetArray;
 
                        // 
                        // Put vertex indices into LineIndices array.
                        // The following code will define 32 lines,
                        // each constructed by 32 vertices, so 32*32=1024 points.
                        //
                                for(index_t j=0; j<32; j++)
                                {
                                std::vector<LineSet::LineIndex_t>&E = LineIndices[ j ];
                                        E.resize(32);
                                        for(index_t i=0; i<32; i++)
                                        {
                                                E[i] = i + j*32;
                                        }
                                } 
                        auto&C=Connectivity[ FragID ] = new CreativeArray( LinesetArray ); 
                                Connectivity->own(C);
                        }
                } 
 
        SkeletonID VertexSkeletonID = SkeletonID::refinedSkeleton(         SkeletonID(1)      , Level),
             ConnectivitySkeletonID = SkeletonID::refinedSkeleton(LineSet::PerLineSkeletonID(), Level);
                Verbose(0) << " Vertices: " << VertexSkeletonID << " Connectivity: " << ConnectivitySkeletonID;
 
        Skeleton&TheVertices = GridOfFragmentedLines[       VertexSkeletonID ];
        Representation&TheCartesianVertices = TheVertices[myChart];
                TheCartesianVertices.setPositions( Coordinates ); 
 
        Skeleton&TheLineset  = GridOfFragmentedLines[ ConnectivitySkeletonID ];
        Representation&LinesAsVertices = TheLineset[ TheVertices ];
                LinesAsVertices.setPositions( Connectivity ); 
 
                createRegularlyFragmentedSkeleton( GridOfFragmentedLines, TheLineset);
        }
 
        Verbose(0) << " ----------- Setting up hierarchy ------------- "; 
 
        for(unsigned Level = 1; Level< MaxLevel-1;  Level++)
        {
        SkeletonID
                ParentVertexSkeletonID       = SkeletonID::refinedSkeleton(         SkeletonID(1)      , Level  ),
                ParentConnectivitySkeletonID = SkeletonID::refinedSkeleton(LineSet::PerLineSkeletonID(), Level  ),
                ChildVertexSkeletonID        = SkeletonID::refinedSkeleton(         SkeletonID(1)      , Level+1),
                ChildConnectivitySkeletonID  = SkeletonID::refinedSkeleton(LineSet::PerLineSkeletonID(), Level+1); 
 
        RelativeRepresentation
                ParentConnectivity(GridOfFragmentedLines, ParentConnectivitySkeletonID, ParentVertexSkeletonID),
                ChildConnectivity (GridOfFragmentedLines, ChildConnectivitySkeletonID , ChildVertexSkeletonID ); 
 
                Assert( ParentConnectivity );
                Assert( ChildConnectivity  ); 
 
        RefPtr<RegularlyFragmentedField<3>>
                ParentConnectivityField = ParentConnectivity.getParentChildMapping(),
                ChildConnectivityField  = ChildConnectivity.getParentChildMapping(); 
 
                Assert( ParentConnectivityField );
                Assert( ChildConnectivityField  );      
        
                Verbose(0) << " Setting up parental relationship for " << ParentConnectivitySkeletonID << " --> " << ChildConnectivitySkeletonID; 
                
                // 
                // Three-dimensional layout of fragment relationships 
                //
        unsigned        NFragsPerDim = 1<<(Level-1);
        DynamicSize     theFragmentRefinementLayout(3, NFragsPerDim);
 
        RefinedFragmentSkeleton&&
                Refinement = RefinedFragmentSkeleton::create(GridOfFragmentedLines,
                                                             ParentConnectivitySkeletonID,
                                                             ChildConnectivitySkeletonID,
                                                             theFragmentRefinementLayout); 
                for(unsigned Z = 0; Z<NFragsPerDim; Z++)
                for(unsigned Y = 0; Y<NFragsPerDim; Y++)
                for(unsigned X = 0; X<NFragsPerDim; X++)
                {
                MultiIndex<3> ParentFragmentIndex = { X,Y,Z };
                RefPtr<FragmentID> ParentFragmentID = ParentConnectivityField->getFragmentID( ParentFragmentIndex );
                        Assert(ParentFragmentID); 
 
                RefinedFragmentSkeleton::FragmentMapping_t ChildFragments; 
                        for(unsigned ZZ = 2*Z; ZZ<2*Z+2; ZZ++)
                        for(unsigned YY = 2*Y; YY<2*Y+2; YY++)
                        for(unsigned XX = 2*X; XX<2*X+2; XX++)
                        {
                        MultiIndex<3> ChildFragmentIndex = {XX,YY,ZZ}; 
                        RefPtr<FragmentID> ChildFragmentID = ChildConnectivityField->getFragmentID( ChildFragmentIndex );
                                Assert( ChildFragmentID );
                                ChildFragments.push_back( ChildFragmentID );
                        }
 
                        Refinement.setFragmentMappingArray(ParentFragmentID, ChildFragments,
                                                           -42 ); // RefinementFragmentDims argument is unusued in "new" layout.
                }
        } 
 
        if (!BP.save("LineSetHierarchicalRegularized.f5"))
                Console() << " Could not create file LineSetHierarchicalRegularized.f5 , is it already opened by another program?";
        return 0;
}