TopologicalLoop.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Core/CADKernelArchive.h"
#include "Core/CADEntity.h"
#include "Core/OrientedEntity.h"
#include "Geo/GeoEnum.h"
#include "Math/Boundary.h"
#include "Topo/TopologicalEdge.h"
#include "Topo/TopologicalEntity.h"
#include "Topo/TopologicalVertex.h"
 
namespace UE::CADKernel
{
 
class FDatabase;
class FTopologicalFace;
class FTopologicalVertex;
 
class CADKERNEL_API FOrientedEdge : public TOrientedEntity<FTopologicalEdge>
{
public:
    FOrientedEdge(TSharedPtr<FTopologicalEdge>& InEntity, EOrientation InDirection)
        : TOrientedEntity(InEntity, InDirection)
    {
    }
 
    FOrientedEdge()
        : TOrientedEntity()
    {
    }
 
    bool operator==(const FOrientedEdge& Edge) const
    {
        return Entity == Edge.Entity;
    }
 
    TSharedRef<FTopologicalVertex> GetStartVertex()
    {
        return Direction == EOrientation::Front ? Entity->GetStartVertex() : Entity->GetEndVertex();
    }
 
    TSharedRef<FTopologicalVertex> GetEndVertex()
    {
        return Direction == EOrientation::Front ? Entity->GetEndVertex() : Entity->GetStartVertex();
    }
 
    double GetStartCoordinate()
    {
        return Direction == EOrientation::Front ? Entity->GetBoundary().GetMin() : Entity->GetBoundary().GetMax();
    }
 
    double GetEndCoordinate()
    {
        return Direction == EOrientation::Front ? Entity->GetBoundary().GetMax() : Entity->GetBoundary().GetMin();
    }
};
 
class CADKERNEL_API FTopologicalLoop : public FTopologicalEntity
{
    friend class FEntity;
    friend class FTopologicalFace;
    friend class FTopologicalFace;
    friend class FTopologicalEdge;
 
public:
    FSurfacicBoundary Boundary;
 
protected:
    TArray<FOrientedEdge> Edges;
 
    FTopologicalFace* Face;
    bool bIsExternal;
 
    FTopologicalLoop(const TArray<TSharedPtr<FTopologicalEdge>>& Edges, const TArray<EOrientation>& EdgeDirections, const bool bIsEternalLoop);
 
    FTopologicalLoop() = default;
 
private:
 
    void SetSurface(FTopologicalFace* HostedFace)
    {
        Face = HostedFace;
    }
 
    void ResetSurface()
    {
        Face = nullptr;
    }
 
public:
 
    virtual ~FTopologicalLoop() override
    {
        FTopologicalLoop::Empty();
    }
 
    virtual void Empty() override
    {
        for (FOrientedEdge& Edge : Edges)
        {
            Edge.Entity->Empty();
        }
        Edges.Empty();
        FTopologicalEntity::Empty();
    }
 
    static TSharedPtr<FTopologicalLoop> Make(const TArray<TSharedPtr<FTopologicalEdge>>& EdgeList, const TArray<EOrientation>& EdgeDirections, const bool bIsExternalLoop, const double GeometricTolerance);
 
    void DeleteLoopEdges();
 
    virtual void Serialize(FCADKernelArchive& Ar) override
    {
        FTopologicalEntity::Serialize(Ar);
        SerializeIdents(Ar, (TArray<TOrientedEntity<FEntity>>&) Edges);
        SerializeIdent(Ar, &Face);
        Ar << bIsExternal;
    }
 
    virtual void SpawnIdent(FDatabase& Database) override
    {
        if (!FEntity::SetId(Database))
        {
            return;
        }
 
        SpawnIdentOnEntities((TArray<TOrientedEntity<FEntity>>&) Edges, Database);
    }
 
    virtual void ResetMarkersRecursively() const override
    {
        ResetMarkers();
        ResetMarkersRecursivelyOnEntities((TArray<TOrientedEntity<FEntity>>&) Edges);
    }
 
#ifdef CADKERNEL_DEV
    virtual FInfoEntity& GetInfo(FInfoEntity&) const override;
#endif
 
    virtual EEntity GetEntityType() const override
    {
        return EEntity::TopologicalLoop;
    }
 
    double Length() const;
    
    const int32 EdgeCount() const
    {
        return Edges.Num();
    }
 
    const TArray<FOrientedEdge>& GetEdges() const
    {
        return Edges;
    }
 
    TArray<FOrientedEdge>& GetEdges()
    {
        return Edges;
    }
 
    const FOrientedEdge* GetOrientedEdge(const FTopologicalEdge* InEdge) const 
    {
        for (const FOrientedEdge& Edge : Edges)
        {
            if (Edge.Entity.Get() == InEdge)
            {
                return &Edge;
            }
        }
        return nullptr;
    }
 
    void GetActiveEdges(TArray<TSharedPtr<FTopologicalEdge>>& OutEdges) const
    {
        for (const FOrientedEdge& Edge : Edges)
        {
            TSharedPtr<FTopologicalEdge> ActiveEdge = Edge.Entity->GetLinkActiveEdge();
            if (!ActiveEdge->HasMarker1())
            {
                ActiveEdge->SetMarker1();
                OutEdges.Emplace(ActiveEdge);
            }
        }
    }
 
    FTopologicalFace* GetFace() const
    {
        return Face;
    }
 
    bool IsExternal() const 
    {
        return bIsExternal;
    }
 
    void SetExternal()
    {
        bIsExternal = true;
    }
 
    void SetInternal()
    {
        bIsExternal = false;
    }
 
    /*
     * @return false if the orientation is doubtful
     */
    bool Orient();
    void SwapOrientation();
 
    void ReplaceEdge(TSharedPtr<FTopologicalEdge>& OldEdge, TSharedPtr<FTopologicalEdge>& NewEdge);
    void ReplaceEdge(TSharedPtr<FTopologicalEdge>& Edge, TArray<TSharedPtr<FTopologicalEdge>>& NewEdges);
    void ReplaceEdges(TArray<FOrientedEdge>& Candidates, TSharedPtr<FTopologicalEdge>& NewEdge);
 
    void SplitEdge(FTopologicalEdge& Edge, TSharedPtr<FTopologicalEdge> NewEdge, bool bNewEdgeIsFirst);
 
    void RemoveEdge(TSharedPtr<FTopologicalEdge>& Edge);
    //void ReplaceEdgesWithMergedEdge(TArray<TSharedPtr<FTopologicalEdge>>& OldEdges, TSharedPtr<FTopologicalVertex>& MiddleVertex, TSharedPtr<FTopologicalEdge>& NewEdge);
 
    EOrientation GetDirection(TSharedPtr<FTopologicalEdge>& Edge, bool bAllowLinkedEdge = false) const;
 
    EOrientation GetDirection(int32 Index) const
    {
        return Edges[Index].Direction;
    }
 
    const TSharedPtr<FTopologicalEdge>& GetEdge(int32 Index) const
    {
        return Edges[Index].Entity;
    }
 
    int32 GetEdgeIndex(const FTopologicalEdge& Edge) const
    {
        for (int32 Index = 0; Index < Edges.Num(); ++Index)
        {
            if (&Edge == Edges[Index].Entity.Get())
            {
                return Index;
            }
        }
        return -1;
    }
 
    void Get2DSampling(TArray<FVector2d>& LoopSampling) const;
 
    bool Get2DSamplingWithoutDegeneratedEdges(TArray<FVector2d>& LoopSampling) const;
 
    void FindSurfaceCorners(TArray<TSharedPtr<FTopologicalVertex>>& OutCorners, TArray<int32>& OutStartSideIndex) const;
    void FindBreaks(TArray<TSharedPtr<FTopologicalVertex>>& Ruptures, TArray<int32>& OutStartSideIndex, TArray<double>& RuptureValues) const;
 
    void ComputeBoundaryProperties(const TArray<int32>& StartSideIndex, TArray<FEdge2DProperties>& OutSideProperties) const;
 
    void EnsureLogicalClosing(const double GeometricTolerance);
 
    void CheckEdgesOrientation();
    void CheckLoopWithTwoEdgesOrientation();
    void RemoveDegeneratedEdges();
 
    bool IsInside(const FTopologicalLoop& Other) const;
 
};
 
}