XF_LineSetHierarchical.cpp

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
 
#include <fiber/grid/types/LineSet.hpp>
#include <fiber/grid/types/RefinedFragmentSkeleton.hpp>
 
 
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
 
string  FragmentName(unsigned Level, unsigned X, unsigned Y, unsigned Z)
{
        return  "LineFragmentL" + std::to_string(Level) + "#" + std::to_string(X)
                + "x" + std::to_string(Y) + "x" + std::to_string(Z);
}
 
int     main()
{
        Finit();
 
BundlePtr BP;
Grid&GridOfFragmentedLines = BP[0.0]["HierarchicalLineSet"]; 
RefPtr<Chart> myChart = GridOfFragmentedLines.makeCartesianChart(); 
 
const unsigned MaxLevel = 4;
        for(unsigned Level = 1; Level< MaxLevel;  Level++)
        {
        RefPtr<Field> Coordinates = new Field(),
                     Connectivity = new Field(); 
 
        unsigned NFragsPerDim = 1<<(Level-1); 
 
        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++)
                {
                string  FragmentName = "LineFragmentL" + std::to_string(Level) + "#" + std::to_string(X)
                                       + "x" + std::to_string(Y) + "x" + std::to_string(Z);
 
                        Verbose(0) << "Level " << Level << " creating fragment " << FragmentName;
 
                        //
                        // 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->setPersistentDataByName( CoordsArray, FragmentName );
 
                                *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;
                                        }
                                }
                                Connectivity->setPersistentDataByName( LinesetArray, FragmentName );
                        }
                }
 
        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 );
        } 
 
        Verbose(0) << " ----------- Setting up hierarchy ------------- ";
 
        for(unsigned Level = 1; Level< MaxLevel-1;  Level++)
        {
        SkeletonID
                ParentConnectivitySkeletonID = SkeletonID::refinedSkeleton(LineSet::PerLineSkeletonID(), Level  ),
                ChildConnectivitySkeletonID  = SkeletonID::refinedSkeleton(LineSet::PerLineSkeletonID(), Level+1);
 
                Verbose(0) << " Setting up parental relationship for " << ParentConnectivitySkeletonID << " --> " << ChildConnectivitySkeletonID;
 
                //
                // Three-dimensional layout of fragment relationships
                //
        int     NFragsPerDim = 1<<(Level-1);
        DynamicSize     theFragmentRefinementLayout(3, NFragsPerDim);
 
        RefinedFragmentSkeleton&&
                Refinement = RefinedFragmentSkeleton::create(GridOfFragmentedLines,
                                                             ParentConnectivitySkeletonID,
                                                             ChildConnectivitySkeletonID,
                                                             theFragmentRefinementLayout); 
                for(int Z = 0; Z<NFragsPerDim; Z++)
                for(int Y = 0; Y<NFragsPerDim; Y++)
                for(int X = 0; X<NFragsPerDim; X++)
                {
                string  FragmentName = "LineFragmentL" + std::to_string(Level) + "#" + std::to_string(X)
                                       + "x" + std::to_string(Y) + "x" + std::to_string(Z);
 
                        Assert( Refinement.FragmentRefinement.ParentSkeleton );
                        Assert( Refinement.FragmentRefinement.ParentSkeleton->getFragmentIDCollection() ); 
 
                RefPtr<FragmentID> ParentFragmentID = Refinement.getParentSkeleton()->findFragmentIDByName(FragmentName); 
                        Assert(ParentFragmentID);
/*
                        if (!ParentFragmentID)
                        {
                                Verbose(0) << " Could not find " << FragmentName << " in level " << Level
                                           << " in " << Refinement.getParentSkeleton()->ID()
                                           << " with " << Refinement.getParentSkeleton()->getFragmentIDCollection();
                                continue;
                        }
*/ 
 
                RefinedFragmentSkeleton::FragmentMapping_t ChildFragments; 
                        for(int ZZ = 2*Z; ZZ<2*Z+2; ZZ++)
                        for(int YY = 2*Y; YY<2*Y+2; YY++)
                        for(int XX = 2*X; XX<2*X+2; XX++)
                        {
                        string  FragmentNameNextLevel = "LineFragmentL" + std::to_string(Level+1) + "#" + std::to_string(XX)
                                                        + "x" + std::to_string(YY) + "x" + std::to_string(ZZ);
 
                        RefPtr<FragmentID> ChildFragmentID = Refinement.getChildSkeleton()->getFragmentIDCollection()->findFragmentIDByName(FragmentNameNextLevel); 
                                Assert( ChildFragmentID );
                                ChildFragments.push_back( ChildFragmentID );
                        }
 
                        Refinement.setFragmentMappingArray(ParentFragmentID, ChildFragments,
                                                           -42 ); // RefinementFragmentDims argument is unusued in "new" layout.
                }
        } 
 
        BP.save("LineSetHierarchical.f5");
        return 0;
}