LoadGrid.hpp

#ifndef __FIBER_FIBERIO_HDF5_GRID_LOADER_HPP
#define __FIBER_FIBERIO_HDF5_GRID_LOADER_HPP
 
#include <fiber/grid/Grid.hpp>
#include <fiber/bundle/StorageTransformations.hpp>
#include <memcore/Loader.hpp>
#include <hdf5.h>
#include <F5/F5Path.h>
#include <fiber/grid/types/FragmentTopology.hpp>
#include <F5/F5iterate.h>
 
#include "H++/H5Property.hpp"
 
namespace Fiber
{
 
class   GridLoader
{
public:
        Fiber::Grid&MyGrid;
 
        MemCore::RefPtr<MemCore::LoaderProgress> LP;
        MemCore::WeakPtr<Fiber::StorageTransformations::IOPerformance> LoadPerformance;
        std::string path_info;
 
        std::unordered_set<std::string> IgnoreAttributesOnLoad;
 
private:
        using NamedSkeleton_t = Fiber::FragmentTopology::NamedSkeleton_t;
        NamedSkeleton_t AvailableGridSkeletons;
 
        typedef std::map<MemCore::WeakPtr<Fiber::Representation>, bool>  GotRepresentations_t;
        GotRepresentations_t GotRepresentations;
 
public:
        using SkeletonFragmentIDCollections_t
                = std::map<Fiber::SkeletonID, MemCore::RefPtr<Fiber::FragmentIDCollection>>;
 
        SkeletonFragmentIDCollections_t
                SkeletonFragmentIDCollections;
 
        MemCore::RefPtr<H5GroupAccess>  GroupAccess;
 
        GridLoader(Fiber::Grid&g,
                   const MemCore::RefPtr<MemCore::LoaderProgress>&lp,
                   const MemCore::WeakPtr<Fiber::StorageTransformations::IOPerformance>&theLoadPerformance,
                   const std::string&info);
 
        ~GridLoader();
 
        bool    gotRepresentation(const MemCore::WeakPtr<Fiber::Representation>&R) const;
 
        MemCore::WeakPtr<Fiber::Skeleton> findAvailableSkeleton(const std::string&NameInFile) const;
 
        void    createSkeleton(const Fiber::SkeletonID&, const std::string&SkeletonNameInFile);
 
        void    loadGrid(F5Path*grid);
 
        herr_t  LoadSkeletonTopology(F5Path*skeleton, const char*skeletonname, int index_depth, int skel_dims);
        herr_t  LoadSkeletonCoordinateRepresentations(F5Path*skeleton, const char*skeletonname, int index_depth, int skel_dims);
        herr_t  LoadSkeletonRelativeRepresentations(F5Path*skeleton, const char*skeletonname, int index_depth, int skel_dims);
        herr_t  LoadSkeletonOtherRepresentations(F5Path*skeleton, const char*skeletonname, int index_depth, int skel_dims);
 
private:
        void    loadAtlas(F5Path*grid);
        void    identify_all_SkeletonIDs_and_create_empty_Skeletons(F5Path*grid);
 
};
 
template <class IteratorContainer>
inline void F5IterateTopologies(IteratorContainer&I, F5Path*grid,
                                herr_t (IteratorContainer::*Iterator)(F5Path*skeleton, const char*skeletonname, int index_depth, int skel_dims))
 
{
        struct  F5Iterate
        {
                IteratorContainer*IC;
                herr_t (IteratorContainer::*Iterator)(F5Path*skeleton, const char*skeletonname, int index_depth, int);
 
// F5 callback to iterate over skeletons and load them
static herr_t skeleton_iterator(F5Path*skeleton, const char*skeletonname,
                                int index_depth, int skel_dims,
                                void *operator_data)
        {
        F5Iterate&FI = *reinterpret_cast<F5Iterate*>(operator_data);
                return (FI.IC->*FI.Iterator)(skeleton, skeletonname, index_depth, skel_dims);
        }
 
        } FIT;
        FIT.IC = &I;
        FIT.Iterator = Iterator;
 
        F5iterate_topologies(grid, NULL, F5Iterate::skeleton_iterator, &FIT);
}
 
 
} // namespace Fiber
 
#endif // __FIBER_FIBERIO_HDF5_GRID_LOADER_HPP