EdgeLoop.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3cpp EdgeLoop
 
#pragma once
 
#include "DynamicMesh/DynamicMesh3.h"
#include "Util/IndexUtil.h"
 
namespace UE
{
namespace Geometry
{
 
class FEdgeLoop
{
public:
    const FDynamicMesh3* Mesh;
 
    TArray<int> Vertices;
    TArray<int> Edges;
 
    TArray<int> BowtieVertices;
 
    bool bBowtiesCalculated = false;
 
    FEdgeLoop()
    {
        Mesh = nullptr;
    }
 
    FEdgeLoop(const FDynamicMesh3* mesh)
    {
        Mesh = mesh;
    }
 
    FEdgeLoop(const FDynamicMesh3* mesh, const TArray<int>& vertices, const TArray<int> & edges)
    {
        Mesh = mesh;
        Vertices = vertices;
        Edges = edges;
    }
 
 
    GEOMETRYCORE_API void Initialize(const FDynamicMesh3* mesh, const TArray<int>& vertices, const TArray<int> & edges, const TArray<int>* BowtieVerticesIn = nullptr);
 
    GEOMETRYCORE_API void InitializeFromEdges(const TArray<int>& EdgesIn);
 
    void InitializeFromEdges(const FDynamicMesh3* MeshIn, const TArray<int>& EdgesIn)
    {
        Mesh = MeshIn;
        InitializeFromEdges(EdgesIn);
    }
 
 
 
    GEOMETRYCORE_API bool InitializeFromVertices(const TArray<int>& VerticesIn, bool bAutoOrient = true);
 
    bool InitializeFromVertices(const FDynamicMesh3* MeshIn, const TArray<int>& VerticesIn, bool bAutoOrient = true)
    {
        Mesh = MeshIn;
        return InitializeFromVertices(VerticesIn, bAutoOrient);
    }
 
 
 
 
    void SetBowtieVertices(const TArray<int>& Bowties)
    {
        BowtieVertices = Bowties;
        bBowtiesCalculated = true;
    }
 
 
    GEOMETRYCORE_API void CalculateBowtieVertices();
 
    int GetVertexCount() const
    {
        return Vertices.Num();
    }
 
    int GetEdgeCount() const
    {
        return Edges.Num();
    }
 
    inline FVector3d GetVertex(int LoopIndex) const
    {
        return Mesh->GetVertex(Vertices[LoopIndex]);
    }
 
    inline FVector3d GetPrevVertex(int32 LoopIndex) const
    {
        return Mesh->GetVertex(Vertices[ (LoopIndex == 0) ? (Vertices.Num()-1) : (LoopIndex-1) ]);
    }
 
    inline FVector3d GetNextVertex(int32 LoopIndex) const
    {
        return Mesh->GetVertex(Vertices[ (LoopIndex + 1) % Vertices.Num() ]);
    }
 
 
 
    GEOMETRYCORE_API FAxisAlignedBox3d GetBounds() const;
 
    template<typename VecType>
    void GetVertices(TArray<VecType>& VerticesOut) const
    {
        int NumV = Vertices.Num();
        for (int i = 0; i < NumV; ++i)
        {
            VecType Pos = Mesh->GetVertex(Vertices[i]);
            VerticesOut.Add(Pos);
        }
    }
 
 
    GEOMETRYCORE_API bool SetCorrectOrientation();
 
 
    void Reverse()
    {
        Algo::Reverse(Vertices);
        Algo::Reverse(Edges);
    }
 
 
    GEOMETRYCORE_API bool IsInternalLoop() const;
 
 
    GEOMETRYCORE_API bool IsBoundaryLoop(const FDynamicMesh3* TestMesh = nullptr) const;
 
 
    GEOMETRYCORE_API int FindVertexIndex(int VertexID) const;
 
 
    GEOMETRYCORE_API int FindNearestVertexIndex(const FVector3d& QueryPoint) const;
 
 
 
    GEOMETRYCORE_API bool CheckValidity(EValidityCheckFailMode FailMode = EValidityCheckFailMode::Check) const;
 
 
 
 
    static GEOMETRYCORE_API void VertexLoopToEdgeLoop(const FDynamicMesh3* Mesh, const TArray<int>& VertexLoop, TArray<int>& OutEdgeLoop);
 
};
 
 
//
// Utility functions for converting/processing edge loops
//
 
GEOMETRYCORE_API bool ConvertLoopToTriOrderedEdgeLoop(const FDynamicMesh3& Mesh,
    const TArray<int32>& VertexLoop, const TArray<int32>& EdgeLoop,
    TFunctionRef<int(int EdgeID, int TriangleA, int TriangleB)> SelectEdgeTriangleFunc,
    TArray<FMeshTriOrderedEdgeID>& TriOrderedEdgesLoopOut );
 
GEOMETRYCORE_API bool ConvertLoopToTriOrderedEdgeLoop(const FDynamicMesh3& Mesh,
    const TArray<int32>& VertexLoop, const TArray<int32>& EdgeLoop,
    TArray<FMeshTriOrderedEdgeID>& TriOrderedEdgesLoopOut );
 
GEOMETRYCORE_API bool ConvertTriOrderedEdgeLoopToLoop(const FDynamicMesh3& Mesh,
    const TArray<FMeshTriOrderedEdgeID>& TriOrderedEdgesLoopOut,
    TArray<int32>& VertexLoop, TArray<int32>* EdgeLoop = nullptr);
 
 
 
} // end namespace UE::Geometry
} // end namespace UE