XF_LineSetFragmented.cpp

Demonstrates creation of a set of lines that is fragmented into four regions.

Demonstrates creation of a set of lines that is fragmented into four regions.The fragmentation is identical for the coordinates and connectivity, using identical nomenclatura for the fragments in each separate Skeleton. This particular choice of fragmentation allows a 1:1 mapping between connectivity fragments and coordinate fragments and is easy to handle since fragments from both skeletons can be paired and considered independently from other fragments.

Other fragmentations are possible but involve higher complexity, so not all functions operating on a set of lines may support such yet or with same efficiency.

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
 
#include <fiber/grid/types/LineSet.hpp>
 
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
 
int     main()
{
        Finit();
 
RefPtr<Field> Coordinates = new Field(),
             Connectivity = new Field(); 
 
        for(int X = 0; X<4; X++)
        {
        string  FragmentName = "LineFragment#" + std::to_string(X); 
 
                // 
                // 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*35.0;
                                P.y() =       double( (some_int/ 8)%32 ); 
                                P.z() =   0.6*double( (some_int/64)%32 ); 
 
                                some_int++;
                        } 
                        Coordinates->setPersistentDataByName( CoordsArray, FragmentName ); 
                } 
 
                // 
                // 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 ); 
                }
        } 
 
 
 
BundlePtr BP; 
 
        {
        Grid&GridOfFragmentedLines = BP[0.0]["FragmentedLineSet"]; 
 
        Skeleton&TheLineset  = GridOfFragmentedLines[ LineSet::PerLineSkeletonID() ]; 
        Skeleton&TheVertices = GridOfFragmentedLines.makeVertices( 1 ); 
 
        Representation&TheCartesianVertices = GridOfFragmentedLines.makeCartesianRepresentation( 1 ); 
                TheCartesianVertices.setPositions( Coordinates ); 
 
        Representation&LinesAsVertices = TheLineset[ TheVertices ]; 
                LinesAsVertices.setPositions( Connectivity );
        } 
        
        BP.save("LineSetFragmented.f5");
        return 0;
}