RecursiveSeaBed.hpp

#ifndef __FISH_POND_ANEMONEFISH_RecursiveSeabed_HPP
#define __FISH_POND_ANEMONEFISH_RecursiveSeabed_HPP
 
#include <functional>
#include <fiber/grid/Skeleton.hpp>
#include <fiber/grid/RepresentationReference.hpp>
#include <aerie/BoundingBox.hpp>
 
#include <grid/types/RefinedFragmentSkeleton.hpp>
 
#include "GridAnemone.hpp"
#include "SeaBed.hpp"
 
namespace Wizt
{
 
 
struct  RecursiveSeaBed
{
        SeaBed&mySeaBed;
 
//      const GridAnemone::FragmentSorter&      myFragmentSorter;
        pRegionOfInterest                       myRegionOfInterest;
 
#ifdef  SUPPORT_MULTIROOT_LEVELS
        const std::vector<RefinedFragment>&     RootLevel;
#endif
        RefPtr<CellTensorFunctor>               myCellTensorFunctor;
        double                                  CellsizeThreshold;
 
#ifdef  SUPPORT_MULTIROOT_LEVELS
        std::multimap<double, int> SortedFragmentMap;
 
        void    SortRootLevel()
        {
                SortedFragmentMap.clear();
                for(size_t i = 0; i<RootLevel.size(); i++)
                {
                const RefPtr<FragmentID>&fID = RootLevel[i].myFragmentID();
                const Fiber::SkeletonID &SID = RootLevel[i].LevelID;
                double  SortValue = myFragmentSorter.getSortCriteria(SID, fID);
 
                        SortedFragmentMap.emplace( SortValue, i );
                }
        }
#endif
 
        const VCamera   &CurrentCameraSettings() const
        {
                return mySeaBed.myCamera;
        }
 
        double  ApparentCellSize2_Threshold() const;
 
        bool    checkIfFragmentIsTooDetailedOrInvisible(const Fiber::SkeletonID&LevelID ,
                                                        const Fiber::CoordinateRepresentationReference&,
                                                        const RefPtr<Field>&Coordinates,
                                                        const RefPtr<CreativeArrayBase>&theVertexFragmentData,
                                                        const RefPtr<FragmentID>&theFragmentID,
                                                        RefPtr<BoundingBox>&BBox,
                                                        bool&isInside,
                                                        bool&isInvisible) const;
 
        /*
          @param theFragmentID A fragment ID for the given Representation.
         */
        bool    checkIfVertexFragmentIsTooDetailedOrInvisible(const Fiber::SkeletonID&LevelID ,
                                                              const Fiber::CoordinateRepresentationReference&,
                                                              const RefPtr<FragmentID>&theFragmentID,
                                                              RefPtr<BoundingBox>&BBox,
                                                              bool&isInside,
                                                              bool&isInvisible) const;
 
        bool    checkIfVertexCompatibleFragmentIsTooDetailedOrInvisible(const Fiber::SkeletonID&LevelID ,
                                                                        const Fiber::CoordinateRepresentationReference&,
                                                                        const RefPtr<FragmentID>&theFragmentID,
                                                                        RefPtr<BoundingBox>&BBox,
                                                                        bool&isInside,
                                                                        bool&isInvisible) const;
 
        bool    checkIfFragmentIsTooDetailedOrInvisible(const GridAnemone::SkeletonSet::const_iterator&S,
                                                        const RefPtr<FragmentID>&theFragmentID,
                                                        RefPtr<BoundingBox>&BBox,
                                                        bool&isInside,
                                                        bool&isInvisible) const;
 
        mutable map<index_t, int> Statistics;
        mutable index_t HighestUsedLevel = 0;
 
        int     MaxCollectedFragsPerLevel() const
        {
        int     i = 0;
                for(const auto&L : Statistics)
                {
                        if (L.second>i) i = L.second;
                }
                return i;
        }
 
        void    includeInStatistics(const SkeletonID&ID) const
        {
                Statistics[ ID.getHomogeneousLevel() ]++;
                if (ID.getHomogeneousLevel()>HighestUsedLevel)
                        HighestUsedLevel = ID.getHomogeneousLevel();
        }
 
 
static  constexpr bool SortFragments = false;
 
        void    prepareFragment(const GridAnemone::SkeletonSet::const_iterator&S,
                                const RefPtr<FragmentID>&ParentFragmentID,
                                bool    TerminalFragment) const;
        // TODO: check how to optimize the get inside information, since it already has been computed by the caller
        int     isInside(const Skeleton&VertexSkeleton, const RefPtr<FragmentID>&theFragmentID) const;
 
        void    recurseLevelFragment(const GridAnemone::SkeletonSet::const_iterator&S,
                                     const RefPtr<FragmentID>&ParentFragmentID) const;
 
        void    recurseLevel(const GridAnemone::SkeletonSet::const_iterator&S);
 
                /*
          Recursion over a connectivity fragment
         */
        void    renderRefinedConnectivityFragment(const RefinedFragmentSkeleton&Refinement,
                                                  const SkeletonID&CurrentConnectivityID, const SkeletonID&NextConnectivityID,
                                                  Field&ConnectivityField,
                                                  const RefPtr<FragmentID>&theConnectivityFragmentID,
                                                  const RefPtr<CreativeArrayBase>&theConnectivityFragmentCreator,
                                                  const RefPtr<BoundingBox>&theConnectivityFragmentBBox,
 
                                                  const SkeletonID&CurrentVertexSkeletonID, const SkeletonID&NextVertexID
                                                );
 
        void    renderRecursiveConnectivityFragment(const SkeletonID&CurrentConnectivityID,
                                                    Field&ConnectivityField,
                                                    const RefPtr<FragmentID>&theConnectivityFragmentID,
                                                    const RefPtr<BoundingBox>&theConnectivityFragmentBBox,
                                                    const SkeletonID&CurrentVertexSkeletonID);
 
        void    renderConnectivity(const SkeletonID&CurrentConnectivityID,
                                   Field&ConnectivityField,
                                   const SkeletonID&CurrentVertexSkeletonID);
 
        void    ShowStatistics() const;
 
//      RecursiveSeaBed(SeaBed&theSeaBed, const GridAnemone::FragmentSorter&FS, const VCamera&TheCameraSettings,
 
        RecursiveSeaBed(SeaBed&theSeaBed, const VCamera&TheCameraSettings,
                        bool   CurrentAsyncLoading, pRegionOfInterest theRegionOfInterest);
 
};
 
 
 
} // namespace
 
#endif  // __FISH_POND_ANEMONEFISH_RecursiveSeabed_HPP