RefinementRecursion.hpp

#ifndef __FIBER_BASEOP_REFINEMENTRECURSION_HPP
#define __FIBER_BASEOP_REFINEMENTRECURSION_HPP
 
#include <grid/types/RefinedFragmentSkeleton.hpp>
 
#include <forward_list>
#include <functional>
#include <tuple>
 
namespace       Fiber
{
 
template <class FragmentContext>
using   RefinementAllowanceFunction = std::function< std::tuple<bool, FragmentContext   >(const RefPtr<Skeleton>&, const RefPtr<FragmentID>&)>;
 
template <class FragmentContext, class RecursionCriterium>
using   RefinementContinuationFunction = std::function< std::tuple<bool, RecursionCriterium>(const FragmentContext&,const RefPtr<FragmentID>&)>;
 
template <class RecursionCriterium>
using   RefinementFragmentEmitFunction = std::function<bool(const RecursionCriterium&TerminalCriteria,const RefPtr<FragmentID>&)>;
 
 
/*
  Application example see RefinementRecursion.cpp
 
 */
template <class FragmentContext, class RecursionCriterium>
bool    ConditionalRecursion(const RefPtr<Grid>&G, const SkeletonID&ParentSid, const RefPtr<FragmentID>&ParentID,
                             const RefinementAllowanceFunction<FragmentContext>&isAllowedFragment,
                             const RefinementContinuationFunction<FragmentContext,RecursionCriterium>&wantFurtherRefinement,
                             const RefinementFragmentEmitFunction<RecursionCriterium>&emitKid,
                             const RecursionCriterium&ParentFragmentCriteria
        )
{
int     FragmentRefinementLayoutDimension = 3;
 
        if (!G) return false;
 
SkeletonID ChildrenSid = SkeletonID::nextRefinement(ParentSid, 1);
RefinedFragmentSkeleton Refinement(G, ParentSid, ChildrenSid, FragmentRefinementLayoutDimension); 
 
RefPtr<Skeleton> ParentSkeleton = Refinement.getParentSkeleton();
        if (Refinement && ParentSkeleton && Refinement.getChildSkeleton() )
        {
        const std::tuple<bool, FragmentContext>&FragmentRefinementAllowance = isAllowedFragment(ParentSkeleton, ParentID);
                if (std::get<0>(FragmentRefinementAllowance))
                {
                std::forward_list< std::tuple<RefPtr<FragmentID>, RecursionCriterium> >
                        KidsThatNeedFurtherRecursion,
                        KidsThatNeedNoRecursion; 
                        
                        Refinement.iterateChildren(ParentID,
                                           [
                                                   &KidsThatNeedFurtherRecursion,
                                                   &KidsThatNeedNoRecursion     ,
                                                   &FragmentRefinementAllowance         ,
                                                   wantFurtherRefinement
                                           ](const RefPtr<FragmentID>&KidID)
                        {
                        const    std::tuple<bool, RecursionCriterium>&
                                NeedMoreRefinement = wantFurtherRefinement( std::get<1>(FragmentRefinementAllowance), KidID);
                                if (std::get<0>(NeedMoreRefinement))
                                {
                                        KidsThatNeedFurtherRecursion.emplace_front( KidID, std::get<1>(NeedMoreRefinement) );
                                }
                                else
                                {
                                        KidsThatNeedNoRecursion.emplace_front( KidID, std::get<1>(NeedMoreRefinement) );
                                }
                                return true;
                        }
                        );
 
                        if (!KidsThatNeedFurtherRecursion.empty())
                        {
                                // todo: possibly reorder kids here
                                for(const auto&Kid : KidsThatNeedFurtherRecursion)
                                {
                                const RefPtr<FragmentID>&KidID = std::get<0>(Kid); 
                                        if (!ConditionalRecursion(G, ChildrenSid, KidID, isAllowedFragment, wantFurtherRefinement, emitKid,  std::get<1>(Kid) ))
                                                return false;
                                } 
                                for(const auto&Kid : KidsThatNeedNoRecursion)
                                {
                                const RefPtr<FragmentID>&KidID = std::get<0>(Kid); 
                                        if (!emitKid( std::get<1>(Kid), KidID ))
                                                return false;
                                }
 
                                return true;
                        }
                }
        }
 
        return  emitKid( ParentFragmentCriteria, ParentID );
}
 
template <class FragmentContext, class RecursionCriterium>
void    RefinementRecursion(const RefPtr<Grid>&G, const SkeletonID&ConnectivitySid, const RefPtr<Field>&ConnectivityField,
                            const RefinementAllowanceFunction<FragmentContext>&isAllowedFragment,
                            const RefinementContinuationFunction<FragmentContext,RecursionCriterium>&wantFurtherRefinement,
                            const RefinementFragmentEmitFunction<RecursionCriterium>&emitKid,
                            const RecursionCriterium&ParentFragmentCriteria)
{
        ConnectivityField->Iterate( [G, ConnectivitySid,
                                     isAllowedFragment, wantFurtherRefinement, emitKid, ParentFragmentCriteria ]
                                    (const RefPtr<FragmentID>&myFragmentID, const RefPtr<CreativeArrayBase>&)
        {
                ConditionalRecursion<FragmentContext,RecursionCriterium>
                        (G, ConnectivitySid, myFragmentID, isAllowedFragment, wantFurtherRefinement, emitKid, ParentFragmentCriteria );
                return true;
        }
        );
}
 
template <class FragmentContext, class RecursionCriterium>
void    RefinementRecursion(const RefPtr<Grid>&G, const SkeletonID&ConnectivitySid, const RefPtr<Skeleton>&Vertices,
                            const RefinementAllowanceFunction<FragmentContext>&isAllowedFragment,
                            const RefinementContinuationFunction<FragmentContext,RecursionCriterium>&wantFurtherRefinement,
                            const RefinementFragmentEmitFunction<RecursionCriterium>&emitKid,
                            const RecursionCriterium&ParentFragmentCriteria) 
{
        if (!G) return;
 
RefPtr<Skeleton> ConnectivitySkeleton = (*G)(ConnectivitySid);
 
        if (!ConnectivitySkeleton) return;
 
RefPtr<Representation> Connectivity = (*ConnectivitySkeleton)(Vertices);
        if (!Connectivity) return;
RefPtr<Field> ConnectivityField = Connectivity->getPositions();
 
        RefinementRecursion<FragmentContext,RecursionCriterium>
                (G, ConnectivitySid, ConnectivityField, isAllowedFragment, wantFurtherRefinement, emitKid, ParentFragmentCriteria );
}
 
template <class FragmentContext, class RecursionCriterium>
void    RefinementRecursion(const RefPtr<Grid>&G, const SkeletonID&ConnectivitySid,
                            const RefinementAllowanceFunction<FragmentContext>&isAllowedFragment,
                            const RefinementContinuationFunction<FragmentContext,RecursionCriterium>&wantFurtherRefinement,
                            const RefinementFragmentEmitFunction<RecursionCriterium>&emitKid,
                            const RecursionCriterium&ParentFragmentCriteria)
{
        if (!G) return;
        
        RefinementRecursion<FragmentContext,RecursionCriterium>
                (G, ConnectivitySid, G->findVertices(),
                 isAllowedFragment, wantFurtherRefinement, emitKid, ParentFragmentCriteria );
}
 
} // namespace Fiber
 
 
#endif  // __FIBER_BASEOP_REFINEMENTRECURSION_HPP