MeshBoundaryLoops.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3cpp MeshBoundaryLoops
 
#pragma once
 
#include "DynamicMesh/DynamicMesh3.h"
#include "EdgeLoop.h"
#include "EdgeSpan.h"
#include "VectorUtil.h"
#include "Util/BufferUtil.h"
 
namespace UE
{
namespace Geometry
{
 
class FMeshBoundaryLoops
{
public:
    const FDynamicMesh3* Mesh = nullptr;
 
    TArray<FEdgeLoop> Loops;
 
    TArray<FEdgeSpan> Spans;
 
    bool bAborted = false;
    bool bSawOpenSpans = false;
    bool bFellBackToSpansOnFailure = false;
    
    enum class ESpanBehaviors
    {
        Ignore, Abort, Compute
    };
    ESpanBehaviors SpanBehavior = ESpanBehaviors::Compute;
 
 
    enum class EFailureBehaviors
    {
        Abort,       // die, and you clean up
        ConvertToOpenSpan     // keep un-closed loop as a span
    };
    EFailureBehaviors FailureBehavior = EFailureBehaviors::ConvertToOpenSpan;
 
    TFunction<bool(int)> EdgeFilterFunc = nullptr;
 
    TArray<int> FailureBowties;
 
    bool bOnlyComputeSpans = false;
 
public:
    FMeshBoundaryLoops() {}
 
    FMeshBoundaryLoops(const FDynamicMesh3* MeshIn, bool bAutoCompute = true)
    {
        Mesh = MeshIn;
        if (bAutoCompute)
        {
            Compute();
        }
    }
 
    void SetMesh(const FDynamicMesh3* MeshIn) { Mesh = MeshIn; }
 
    GEOMETRYCORE_API bool Compute();
 
 
 
    int GetLoopCount() const
    {
        return Loops.Num();
    }
 
    int GetSpanCount() const
    {
        return Spans.Num();
    }
 
    const FEdgeLoop& operator[](int Index) const
    {
        return Loops[Index];
    }
 
 
    GEOMETRYCORE_API int GetMaxVerticesLoopIndex() const;
 
    GEOMETRYCORE_API int GetLongestLoopIndex() const;
 
    GEOMETRYCORE_API FIndex2i FindVertexInLoop(int VertexID) const;
 
    GEOMETRYCORE_API int FindLoopContainingVertex(int VertexID) const;
 
    GEOMETRYCORE_API int FindLoopContainingEdge(int EdgeID) const;
 
    GEOMETRYCORE_API int FindLoopTrianglesHint(const TArray<int>& BorderHintTris) const;
 
    GEOMETRYCORE_API int FindLoopEdgesHint(const TSet<int>& BorderHintEdges) const;
 
    GEOMETRYCORE_API int FindSpanContainingEdge(int EdgeID) const;
 
 
protected:
 
    TArray<int> VerticesTemp;
 
    // [TODO] cache this : a dictionary? we will not need very many, but we will
    //   need each multiple times!
    GEOMETRYCORE_API FVector3d GetVertexNormal(int vid);
 
    // ok, bdry_edges[0...bdry_edges_count] contains the boundary edges coming out of bowtie_v.
    // We want to pick the best one to continue the loop that came in to bowtie_v on incoming_e.
    // If the loops are all sane, then we will get the smallest loops by "turning left" at bowtie_v.
    GEOMETRYCORE_API int FindLeftTurnEdge(int incoming_e, int bowtie_v, TArray<int>& bdry_edges, int bdry_edges_count, TArray<bool>& used_edges);
    
    struct Subloops
    {
        TArray<FEdgeLoop> Loops;
        TArray<FEdgeSpan> Spans;
    };
 
 
    // This is called when loopV contains one or more "bowtie" vertices.
    // These vertices *might* be duplicated in loopV (but not necessarily)
    // If they are, we have to break loopV into subloops that don't contain duplicates.
    GEOMETRYCORE_API bool ExtractSubloops(TArray<int>& loopV, TArray<int>& loopE, TArray<int>& bowties, Subloops& SubloopsOut);
 
 
 
protected:
 
    friend class FMeshRegionBoundaryLoops;
 
    /*
     * static Utility functions that can be re-used in MeshRegionBoundaryLoops
     * In all the functions below, the list loopV is assumed to possibly
     * contain "removed" vertices indicated by -1. These are ignored.
     */
 
    // Check if the loop from bowtieV to bowtieV inside loopV contains any other bowtie verts.
    // Also returns start and end indices in loopV of "clean" loop
    // Note that start may be < end, if the "clean" loop wraps around the end
    static GEOMETRYCORE_API bool IsSimpleBowtieLoop(const TArray<int>& LoopVerts, const TArray<int>& BowtieVerts, int BowtieVertex, int& start_i, int& end_i);
 
    // check if forward path from loopV[i1] to loopV[i2] contains any bowtie verts other than bowtieV
    static GEOMETRYCORE_API bool IsSimplePath(const TArray<int>& LoopVerts, const TArray<int>& BowtieVerts, int BowtieVertex, int i1, int i2);
 
 
    // Read out the span from loop[i0] to loop [i1-1] into an array.
    // If bMarkInvalid, then these values are set to -1 in loop
    static GEOMETRYCORE_API void ExtractSpan(TArray<int>& Loop, int i0, int i1, bool bMarkInvalid, TArray<int>& OutSpan);
 
    // count number of valid vertices in l between loop[i0] and loop[i1-1]
    static GEOMETRYCORE_API int CountSpan(const TArray<int>& Loop, int i0, int i1);
 
    // find the index of item in loop, starting at start index
    static GEOMETRYCORE_API int FindIndex(const TArray<int>& Loop, int Start, int Item);
 
    // count number of times item appears in loop
    static GEOMETRYCORE_API int CountInList(const TArray<int>& Loop, int Item);
 
 
};
 
 
} // end namespace UE::Geometry
} // end namespace UE