TopologicalFace.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Core/CADEntity.h"
#include "Core/HaveStates.h"
#include "Core/Types.h"
#include "Geo/GeoEnum.h"
#include "Geo/GeoPoint.h"
#include "Geo/Sampling/PolylineTools.h"
#include "Geo/Surfaces/Surface.h"
#include "Math/Boundary.h"
#include "Math/Curvature.h"
#include "Math/Point.h"
#include "Topo/TopologicalEdge.h"
#include "Topo/TopologicalEntity.h"
#include "Topo/TopologicalLoop.h"
#include "Topo/TopologicalShapeEntity.h"
 
#include "Mesh/Structure/EdgeSegment.h"
#include "Mesh/Structure/ThinZone2D.h"
 
#ifdef CADKERNEL_DEV
#include "UI/DefineForDebug.h"
#endif
 
namespace UE::CADKernel
{
 
class FCADKernelArchive;
class FCriteriaGrid;
class FCriterion;
class FCurve;
class FDatabase;
class FModelMesh;
class FTopologicalVertex;
struct FSurfacicSampling;
 
enum class EStatut : uint8
{
    Interior = 0,
    Exterior,
    Border
};
 
enum class EQuadType : uint8
{
    Unset = 0,
    Quadrangular,
    Triangular,
    Other
};
 
struct FBBoxWithNormal;
 
class CADKERNEL_API FTopologicalFace : public FTopologicalShapeEntity
{
    friend class FEntity;
 
protected:
 
    TSharedPtr<FSurface> CarrierSurface;
    TArray<TSharedPtr<FTopologicalLoop>> Loops;
 
    mutable TCache<FSurfacicBoundary> Boundary;
 
    TSharedPtr<FFaceMesh> Mesh;
 
    FCoordinateGrid MeshCuttingCoordinates;
 
    FCoordinateGrid CrossingCoordinates;
 
    FCoordinateGrid CrossingPointDeltaMins;
 
    FCoordinateGrid CrossingPointDeltaMaxs;
 
    double EstimatedMinimalElementLength = DOUBLE_BIG_NUMBER;
 
    FTopologicalFace(const TSharedPtr<FSurface>& InCarrierSurface)
        : FTopologicalShapeEntity()
        , CarrierSurface(InCarrierSurface)
        , Mesh(TSharedPtr<FFaceMesh>())
    {
        ResetElementStatus();
    }
 
    FTopologicalFace() = default;
 
    void ComputeBoundary() const;
 
public:
 
    virtual ~FTopologicalFace() override
    {
        FTopologicalFace::Empty();
    }
 
    virtual void Serialize(FCADKernelArchive& Ar) override
    {
        FTopologicalShapeEntity::Serialize(Ar);
        SerializeIdent(Ar, CarrierSurface);
        SerializeIdents(Ar, (TArray<TSharedPtr<FEntity>>&) Loops);
    }
 
    virtual void SpawnIdent(FDatabase& Database) override;
 
    virtual void ResetMarkersRecursively() const override
    {
        ResetMarkers();
        ResetMarkersRecursivelyOnEntities(Loops);
        CarrierSurface->ResetMarkersRecursively();
    }
 
#ifdef CADKERNEL_DEV
    virtual FInfoEntity& GetInfo(FInfoEntity&) const override;
#endif
 
    virtual EEntity GetEntityType() const override
    {
        return EEntity::TopologicalFace;
    }
 
    const FSurfacicTolerance& GetIsoTolerances() const
    {
        return CarrierSurface->GetIsoTolerances();
    }
 
    double GetIsoTolerance(EIso Iso) const
    {
        return CarrierSurface->GetIsoTolerance(Iso);
    }
 
    const FSurfacicBoundary& GetBoundary() const
    {
        if (!Boundary.IsValid())
        {
            ComputeBoundary();
        }
        return Boundary;
    };
 
    virtual int32 FaceCount() const override
    {
        return 1;
    }
 
    virtual void GetFaces(TArray<FTopologicalFace*>& OutFaces) override
    {
        if (!HasMarker1())
        {
            OutFaces.Emplace(this);
            SetMarker1();
        }
    }
 
    virtual void CompleteMetaData() override
    {
        CompleteMetaDataWithHostMetaData();
    }
 
    virtual void PropagateBodyOrientation() override
    {
    }
 
    // ======   Loop Functions   ======
 
    void RemoveLoop(const TSharedPtr<FTopologicalLoop>& Loop);
    void AddLoop(const TSharedPtr<FTopologicalLoop>& Loop)
    {
        if (Loop.IsValid())
        {
            Loop->SetSurface(this);
            Loops.Add(Loop);
        }
    }
 
    void AddLoops(const TArray<TSharedPtr<FTopologicalLoop>>& Loops, int32& DoubtfulLoopOrientationCount);
 
    void AddLoops(const TArray<TSharedPtr<FCurve>>& Restrictions);
 
    void ApplyNaturalLoops();
 
    void ApplyNaturalLoops(const FSurfacicBoundary& Boundaries);
 
    int32 LoopCount() const
    {
        return Loops.Num();
    }
 
    const TArray<TSharedPtr<FTopologicalLoop>>& GetLoops() const
    {
        return Loops;
    }
 
    const TSharedPtr<FTopologicalLoop> GetExternalLoop() const;
 
    const void Get2DLoopSampling(TArray<TArray<FVector2d>>& OutLoopSamplings) const;
 
    // ======   Loop edge Functions   ======
 
    const FTopologicalEdge* GetLinkedEdge(const FTopologicalEdge& LinkedEdge) const;
 
    void GetEdgeIndex(const FTopologicalEdge& Edge, int32& OutBoundaryIndex, int32& OutEdgeIndex) const;
 
    void EdgeCount(int32& EdgeCount) const
    {
        for (const TSharedPtr<FTopologicalLoop>& Loop : Loops)
        {
            EdgeCount += Loop->GetEdges().Num();
        }
    }
 
    void GetActiveEdges(TArray<TSharedPtr<FTopologicalEdge>>& OutEdges) const
    {
        for (const TSharedPtr<FTopologicalLoop>& Loop : Loops)
        {
            Loop->GetActiveEdges(OutEdges);
        }
    }
 
    int32 EdgeCount() const
    {
        int32 EdgeNum = 0;
        for (const TSharedPtr<FTopologicalLoop>& Loop : Loops)
        {
            EdgeNum += Loop->EdgeCount();
        }
        return EdgeNum;
    }
 
    // ======   Carrier Surface Functions   ======
 
    TSharedRef<FSurface> GetCarrierSurface() const
    {
        return CarrierSurface.ToSharedRef();
    }
 
    // ======   Point evaluation Functions   ======
 
    void EvaluatePointGrid(const FCoordinateGrid& Coordinates, FSurfacicSampling& OutPoints, bool bComputeNormals = false) const
    {
        CarrierSurface->EvaluatePointGrid(Coordinates, OutPoints, bComputeNormals);
    }
 
    void EvaluateGrid(FGrid& Grid) const;
 
    void UpdateBBox(int32 IsoCount, const double ApproximationFactor, FBBoxWithNormal& BBox);
 
    // ======   Topo Functions   ======
 
    void Remove(TArray<FTopologicalEdge*>* NewBorderEdges = nullptr)
    {
        Disjoin(NewBorderEdges);
        Delete();
    }
 
    virtual void Empty() override
    {
#ifndef DONT_DELETE_FACE_FOR_DEBUG
        CarrierSurface.Reset();
        for (TSharedPtr<FTopologicalLoop>& Loop : Loops)
        {
            for (FOrientedEdge& Edge : Loop->GetEdges())
            {
                Edge.Entity->Delete();
            }
 
            Loop->Empty();
        }
        Loops.Empty();
#endif
 
        Mesh.Reset();
        MeshCuttingCoordinates.Empty();
        CrossingCoordinates.Empty();
        CrossingPointDeltaMins.Empty();
        CrossingPointDeltaMaxs.Empty();
 
        SurfaceCorners.Empty();
        StartSideIndices.Empty();
        SideProperties.Empty();
 
        FTopologicalShapeEntity::Empty();
    }
 
    bool IsANonManifoldFace() const;
 
    bool IsABorderFace() const;
 
    bool IsAFullyNonManifoldFace() const;
 
    bool IsADuplicatedFace() const;
 
    bool HasSameBoundariesAs(const FTopologicalFace* OtherFace) const;
 
    void Disjoin(TArray<FTopologicalEdge*>* NewBorderEdges = nullptr);
 
    void DeleteNonmanifoldLink();
 
 
#ifdef CADKERNEL_DEV
    virtual void FillTopologyReport(FTopologyReport& Report) const override;
#endif
 
    // ======   Meshing Function   ======
 
    FFaceMesh& GetOrCreateMesh(FModelMesh& ModelMesh);
 
    const bool HasTesselation() const
    {
        return Mesh.IsValid();
    }
 
    FFaceMesh* GetMesh() const
    {
        if (Mesh.IsValid())
        {
            return Mesh.Get();
        }
        return nullptr;
    }
 
    void InitDeltaUs();
 
    const TArray<double>& GetCuttingCoordinatesAlongIso(EIso Iso) const
    {
        return MeshCuttingCoordinates[Iso];
    }
 
    TArray<double>& GetCuttingCoordinatesAlongIso(EIso Iso)
    {
        return MeshCuttingCoordinates[Iso];
    }
 
    const FCoordinateGrid& GetCuttingPointCoordinates() const
    {
        return MeshCuttingCoordinates;
    }
 
    FCoordinateGrid& GetCuttingPointCoordinates()
    {
        return MeshCuttingCoordinates;
    }
 
    const FCoordinateGrid& GetCrossingPointCoordinates() const
    {
        return CrossingCoordinates;
    }
 
    const TArray<double>& GetCrossingPointCoordinates(EIso Iso) const
    {
        return CrossingCoordinates[Iso];
    }
 
    TArray<double>& GetCrossingPointCoordinates(EIso Iso)
    {
        return CrossingCoordinates[Iso];
    }
 
    bool ComputeCriteriaGridSampling();
        
    void ApplyCriteria(const TArray<TSharedPtr<FCriterion>>& Criteria, const FCriteriaGrid& Grid);
 
    const TArray<double>& GetCrossingPointDeltaMins(EIso Iso) const
    {
        return CrossingPointDeltaMins[Iso];
    }
 
    const TArray<double>& GetCrossingPointDeltaMaxs(EIso Iso) const
    {
        return CrossingPointDeltaMaxs[Iso];
    }
 
    // ======   State, Type Functions   ======
 
    const EQuadType GetQuadType() const
    {
        return QuadType;
    }
 
    const bool HasThinZone() const
    {
        return ((States & EHaveStates::ThinZone) == EHaveStates::ThinZone);
    }
 
    void SetHasThinZoneMarker()
    {
        States |= EHaveStates::ThinZone;
    }
 
    void ResetHasThinSurface()
    {
        States &= ~EHaveStates::ThinZone;
    }
 
    bool IsBackOriented() const
    {
        return ((States & EHaveStates::IsBackOriented) == EHaveStates::IsBackOriented);
    }
 
    void SwapOrientation() const
    {
        if (IsBackOriented())
        {
            ResetBackOriented();
        }
        else
        {
            SetBackOriented();
        }
    }
 
    void SetBackOriented() const
    {
        States |= EHaveStates::IsBackOriented;
    }
 
    void ResetBackOriented() const
    {
        States &= ~EHaveStates::IsBackOriented;
    }
 
    virtual void Remove(const FTopologicalShapeEntity*) override
    {
    }
 
    // ======================================================================================================================================================================================================================
    // Thin zone properties ===============================================================================================================================================================================
    // ======================================================================================================================================================================================================================
private:
    TArray<FThinZone2D> ThinZones;
 
public:
    void MoveThinZones(TArray<FThinZone2D>& InThinZones)
    {
        ThinZones = MoveTemp(InThinZones);
    }
 
    const TArray<FThinZone2D>& GetThinZones() const
    {
        return ThinZones;
    }
 
    TArray<FThinZone2D>& GetThinZones()
    {
        return ThinZones;
    }
 
    // ======================================================================================================================================================================================================================
    // Quad properties for meshing scheduling ===============================================================================================================================================================================
    // ======================================================================================================================================================================================================================
private:
    TArray<TSharedPtr<FTopologicalVertex>> SurfaceCorners;
    TArray<int32> StartSideIndices;
    TArray<FEdge2DProperties> SideProperties;
    int32 NumOfMeshedSide = 0;
    double LoopLength = -1.;
    double LengthOfMeshedSide = 0;
    double QuadCriteria = 0;
    FSurfaceCurvature Curvatures;
    EQuadType QuadType = EQuadType::Unset;
 
public:
    void ComputeQuadCriteria();
    double GetQuadCriteria();
 
    const FSurfaceCurvature& GetCurvatures() const
    {
        return Curvatures;
    }
 
    FSurfaceCurvature& GetCurvatures()
    {
        return Curvatures;
    }
 
    const FIsoCurvature& GetCurvature(EIso Iso) const
    {
        return Curvatures[Iso];
    }
 
    void ComputeSurfaceSideProperties();
 
    void DefineSurfaceType();
 
    const TArray<FEdge2DProperties>& GetSideProperties() const
    {
        return SideProperties;
    }
 
    FEdge2DProperties& GetSideProperty(int32 Index)
    {
        return SideProperties[Index];
    }
 
    const FEdge2DProperties& GetSideProperty(int32 Index) const
    {
        return SideProperties[Index];
    }
 
    int32& MeshedSideNum()
    {
        return NumOfMeshedSide;
    }
 
    const int32& MeshedSideNum() const
    {
        return NumOfMeshedSide;
    }
 
    void AddMeshedLength(double Length)
    {
        LengthOfMeshedSide += Length;
    }
 
    double MeshedSideRatio() const
    {
        return LengthOfMeshedSide / LoopLength;
    }
 
    int32 GetStartEdgeIndexOfSide(int32 Index) const
    {
        return StartSideIndices[Index];
    }
 
    const TArray<int32>& GetStartSideIndices() const
    {
        return StartSideIndices;
    }
 
    int32 GetSideIndex(FTopologicalEdge& Edge) const
    {
        int32 EdgeIndex = Loops[0]->GetEdgeIndex(Edge);
        if (EdgeIndex < 0)
        {
            return -1;
        }
        return GetSideIndex(EdgeIndex);
    }
 
    int32 GetSideIndex(int32 EdgeIndex) const
    {
        if (StartSideIndices.Num() == 0)
        {
            return -1;
        }
 
        if (StartSideIndices[0] > EdgeIndex)
        {
            return (int32)StartSideIndices.Num() - 1;
        }
        else
        {
            for (int32 SideIndex = 0; SideIndex < StartSideIndices.Num() - 1; ++SideIndex)
            {
                if (StartSideIndices[SideIndex] <= EdgeIndex && EdgeIndex < StartSideIndices[SideIndex + 1])
                {
                    return SideIndex;
                }
            }
            return (int32)StartSideIndices.Num() - 1;
        }
    }
 
    void SetEstimatedMinimalElementLength(double Value)
    {
        if(Value < EstimatedMinimalElementLength)
        {
            EstimatedMinimalElementLength = Value;
        }
    }
 
    double GetEstimatedMinimalElementLength() const
    {
        return EstimatedMinimalElementLength;
    }
 
};
 
struct FFaceSubset
{
    TArray<FTopologicalFace*> Faces;
    int32 BorderEdgeCount = 0;
    int32 NonManifoldEdgeCount = 0;
    FTopologicalShapeEntity* MainShell;
    FTopologicalShapeEntity* MainBody;
    FString MainName;
    uint32 MainColor;
    uint32 MainMaterial;
 
    void SetMainShell(TMap<FTopologicalShapeEntity*, int32>& ShellToFaceCount);
    void SetMainBody(TMap<FTopologicalShapeEntity*, int32>& BodyToFaceCount);
    void SetMainName(TMap<FString, int32>& NameToFaceCount);
    void SetMainColor(TMap<uint32, int32>& ColorToFaceCount);
    void SetMainMaterial(TMap<uint32, int32>& MaterialToFaceCount);
};
 
struct FBBoxWithNormal
{
    FVector Max;
    FVector Min;
    FVector MaxPoints[3];
    FVector MinPoints[3];
    FVector2d MaxCoordinates[3];
    FVector2d MinCoordinates[3];
    FVector MaxPointNormals[3];
    FVector MinPointNormals[3];
    bool MaxNormalNeedUpdate[3] = {true, true, true};
    bool MinNormalNeedUpdate[3] = {true, true, true};
 
    FBBoxWithNormal()
        : Max(-HUGE_VALUE, -HUGE_VALUE, -HUGE_VALUE)
        , Min(HUGE_VALUE, HUGE_VALUE, HUGE_VALUE)
    {
    }
 
    double Length()
    {
        double XLength = Max.X - Min.X;
        double YLength = Max.Y - Min.Y;
        double ZLength = Max.Z - Min.Z;
        return XLength + YLength + ZLength;
    }
 
    bool CheckOrientation(bool bHasWrongOrientation)
    {
        int32 GoodOrientation = 0;
        int32 WrongOrientation = 0;
 
        const FVector BBoxNormals[] = { FVector(1., 0., 0.) , FVector(0., 1., 0.) , FVector(0., 0., 1.) };
 
        for (int32 Index = 0; Index < 3; ++Index)
        {
            double DotProduct = MaxPointNormals[Index] | BBoxNormals[Index];
            if (DotProduct > DOUBLE_KINDA_SMALL_NUMBER)
            {
                GoodOrientation++;
            }
            else if(DotProduct < DOUBLE_KINDA_SMALL_NUMBER)
            {
                WrongOrientation++;
            }
 
            DotProduct = MinPointNormals[Index] | BBoxNormals[Index];
            if (DotProduct < DOUBLE_KINDA_SMALL_NUMBER)
            {
                GoodOrientation++;
            }
            else if (DotProduct > DOUBLE_KINDA_SMALL_NUMBER)
            {
                WrongOrientation++;
            }
        }
 
        bHasWrongOrientation = (GoodOrientation < WrongOrientation);
        return ((GoodOrientation >= 3) || (WrongOrientation >= 3)) && (GoodOrientation != WrongOrientation);
    }
 
    void Update(const FPolylineBBox& PolylineBBox, const EIso IsoType, double IsoCoordinate)
    {
        for (int32 Index = 0; Index < 3; ++Index)
        {
            if (PolylineBBox.Max[Index] > Max[Index])
            {
                Max[Index] = PolylineBBox.Max[Index];
                MaxPoints[Index] = PolylineBBox.MaxPoints[Index];
                MaxCoordinates[Index] = (IsoType == IsoU) ? FVector2d(IsoCoordinate, PolylineBBox.CoordinateOfMaxPoint[Index]) : FVector2d(PolylineBBox.CoordinateOfMaxPoint[Index], IsoCoordinate);
                MaxNormalNeedUpdate[Index] = true;
            }
 
            if (PolylineBBox.Min[Index] < Min[Index])
            {
                Min[Index] = PolylineBBox.Min[Index];
                MinPoints[Index] = PolylineBBox.MinPoints[Index];
                MinCoordinates[Index] = (IsoType == IsoU) ? FVector2d(IsoCoordinate, PolylineBBox.CoordinateOfMinPoint[Index]) : FVector2d(PolylineBBox.CoordinateOfMinPoint[Index], IsoCoordinate);
                MinNormalNeedUpdate[Index] = true;
            }
        }
    }
 
    void Update(const FVector& Point, const FVector2d InPoint2D)
    {
        for (int32 Index = 0; Index < 3; ++Index)
        {
            if (Point[Index] > Max[Index])
            {
                Max[Index] = Point[Index];
                MaxPoints[Index] = Point;
                MaxCoordinates[Index] = InPoint2D;
                MaxNormalNeedUpdate[Index] = true;
            }
 
            if (Point[Index] < Min[Index])
            {
                Min[Index] = Point[Index];
                MinPoints[Index] = Point;
                MinCoordinates[Index] = InPoint2D;
                MinNormalNeedUpdate[Index] = true;
            }
        }
    }
 
    void UpdateNormal(const FTopologicalFace& Face)
    {
        const FSurface& Surface = *Face.GetCarrierSurface();
        bool bSwapOrientation = Face.IsBackOriented();
 
        for (int32 Index = 0; Index < 3; ++Index)
        {
            if (MaxNormalNeedUpdate[Index])
            {
                MaxPointNormals[Index] = Surface.EvaluateNormal(MaxCoordinates[Index]);
                if (bSwapOrientation)
                {
                    MaxPointNormals[Index] *= -1.;
                }
                MaxNormalNeedUpdate[Index] = false;
            }
 
            if (MinNormalNeedUpdate[Index])
            {
                MinPointNormals[Index] = Surface.EvaluateNormal(MinCoordinates[Index]);
                if (bSwapOrientation)
                {
                    MinPointNormals[Index] *= -1.;
                }
                MinNormalNeedUpdate[Index] = false;
            }
        }
    }
};
 
 
} // namespace UE::CADKernel