EmbedSurfacePath.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3Sharp MeshPlaneCut
 
#pragma once
#include "CoreMinimal.h"
 
#include "MathUtil.h"
#include "VectorTypes.h"
#include "FrameTypes.h"
#include "GeometryTypes.h"
#include "Curve/GeneralPolygon2.h"
#include "Selections/MeshFaceSelection.h"
 
 
namespace UE
{
namespace Geometry
{
 
class FDynamicMesh3;
 
enum class ESurfacePointType
{
    Vertex = 0,
    Edge = 1,
    Triangle = 2
};
 
struct FMeshSurfacePoint
{
    int ElementID;
    FVector3d BaryCoord;
    ESurfacePointType PointType;
 
    FMeshSurfacePoint() : ElementID(-1)
    {
    }
    FMeshSurfacePoint(int TriangleID, const FVector3d& BaryCoord) : ElementID(TriangleID), BaryCoord(BaryCoord), PointType(ESurfacePointType::Triangle)
    {
    }
    FMeshSurfacePoint(int EdgeID, double FirstCoordWt) : ElementID(EdgeID), BaryCoord(FirstCoordWt, 1-FirstCoordWt, 0), PointType(ESurfacePointType::Edge)
    {
    }
    FMeshSurfacePoint(int VertexID) : ElementID(VertexID), BaryCoord(1,0,0), PointType(ESurfacePointType::Vertex)
    {
    }
 
    GEOMETRYCORE_API FVector3d Pos(const FDynamicMesh3 *Mesh) const;
};
 
//bool GEOMETRYCORE_API WalkMeshPlanar(
//  const FDynamicMesh3* Mesh, int StartTri, int EndVertID, FVector3d StartPt, int EndTri, FVector3d EndPt, FVector3d WalkPlaneNormal, 
//  TFunction<FVector3d(const FDynamicMesh3*, int)> VertexToPosnFn, bool bAllowBackwardsSearch, double AcceptEndPtOutsideDist,
//  double PtOnPlaneThreshold, TArray<TPair<FMeshSurfacePoint, int>>& WalkedPath, double BackwardsTolerance = FMathd::ZeroTolerance * 10);
 
 
class FMeshSurfacePath
{
public:
    FDynamicMesh3 *Mesh;
    TArray<TPair<FMeshSurfacePoint, int>> Path; // Surface points paired with triangle to walk to get to next surface point
    bool bIsClosed;
 
public:
 
    FMeshSurfacePath(FDynamicMesh3* Mesh) : Mesh(Mesh), bIsClosed(false)
    {
    }
    virtual ~FMeshSurfacePath() {}
 
    // TODO: not clear if we need this -- helper to find the shared triangle (if it exists) that we could traverse to connect two surface points.  this gets a bit hairy and it's easier to keep track of the traversed triangles during the mesh walk that creates any path in the first place
    //static int FindSharedTriangle(const FDynamicMesh3* Mesh, const FMeshSurfacePoint& A, const FMeshSurfacePoint& B);
    
    GEOMETRYCORE_API bool IsConnected() const;
 
    bool IsClosed() const
    {
        return bIsClosed;
    }
 
    void Reset()
    {
        Path.Reset();
        bIsClosed = false;
    }
 
    GEOMETRYCORE_API bool AddViaPlanarWalk(int StartTri, int StartVID, FVector3d StartPt, int EndTri, int EndVertID, FVector3d EndPt,
        FVector3d WalkPlaneNormal, TFunction<FVector3d(const FDynamicMesh3*, int)> VertexToPosnFn = nullptr,
        bool bAllowBackwardsSearch = true, double AcceptEndPtOutsideDist = FMathd::ZeroTolerance, 
        double PtOnPlaneThresholdSq = FMathf::ZeroTolerance*100, double BackwardsTolerance = FMathd::ZeroTolerance*10);
    // TODO: Also support geodesic walks, other alternatives?
 
    GEOMETRYCORE_API bool ClosePath();
 
    virtual EOperationValidationResult Validate()
    {
        if (!IsConnected())
        {
            return EOperationValidationResult::Failed_UnknownReason;
        }
 
        return EOperationValidationResult::Ok;
    }
 
    // TODO: support for embedding arbitrary paths in mesh using a graph remesher
    // * Embed surface path in mesh, such that each point in path is a mesh vertex with a connecting edge.  Note that IsConnected must be true for this to succeed.
    // *
    // * @param bUpdatePath Updating the Path array with the new vertices (if false, the path will no longer be valid after running this function)
    // * @param PathVertices Indices of the vertices on the path after embedding succeeds; NOTE these will not be 1:1 with the input Path
    // * @param MeshGraphFn Function to create a mesh from an input 2D graph of labeled edges.
    // * @return true if embedding succeeded.
    // */
    //bool EmbedPath(bool bUpdatePath, TArray<int>& PathVertices, TFunction<bool(const TArray<FVector2d>& Vertices, const TArray<FIndex3i>& LabelledEdges, TArray<FVector2d>& OutVertices, TArray<int32>& OutVertexMap, TArray<FIndex3i>& OutTriangles)> MeshGraphFn);
 
    GEOMETRYCORE_API bool EmbedSimplePath(bool bUpdatePath, TArray<int>& PathVertices, bool bDoNotDuplicateFirstVertexID = true, double SnapElementThresholdSq = FMathf::ZeroTolerance*100);
 
    // TODO: add functionality to delete 'inside' of path -- but how do we determine what is inside?  ref MeshFacesFromLoop.cs in geometry3sharp
};
 
bool GEOMETRYCORE_API EmbedProjectedPath(FDynamicMesh3* Mesh, int StartTriID, FFrame3d Frame, const TArray<FVector2d>& Path2D, TArray<int>& OutPathVertices, TArray<int>& OutVertexCorrespondence, bool bClosePath, FMeshFaceSelection *EnclosedFaces = nullptr, double PtSnapVertexOrEdgeThresholdSq = FMathf::ZeroTolerance*100);
 
bool GEOMETRYCORE_API EmbedProjectedPaths(FDynamicMesh3* Mesh, const TArrayView<const int> StartTriIDs, FFrame3d Frame, const TArrayView<const TArray<FVector2d>> AllPaths, TArray<TArray<int>>& OutAllPathVertices, TArray<TArray<int>>& OutAllVertexCorrespondence, bool bClosePaths, FMeshFaceSelection* EnclosedFaces, double PtSnapVertexOrEdgeThresholdSq = FMathf::ZeroTolerance*100);
 
 
} // end namespace UE::Geometry
} // end namespace UE