TopologicalEdge.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Geo/Curves/Curve.h"
#include "Geo/Curves/RestrictionCurve.h"
#include "Geo/Sampling/SurfacicPolyline.h"
#include "Geo/GeoEnum.h"
#include "Math/Boundary.h"
#include "Mesh/MeshEnum.h"
#include "Topo/Linkable.h"
#include "Topo/TopologicalVertex.h"
#include "Utils/Cache.h"
 
namespace UE::CADKernel
{
 
typedef TTopologicalLink<FTopologicalEdge> FEdgeLink;
 
class FOrientedEdge;
class FThinZone2D;
class FThinZoneSide;
 
struct CADKERNEL_API FImposedCuttingPoint
{
    const double Coordinate = 0;
    const int32 OppositNodeIndex = -1;
    double DeltaU = 0;
 
    FImposedCuttingPoint()
    {
    }
 
    FImposedCuttingPoint(const double InCoordinate, const int32 NodeIndex1, const double InDeltaU = 0.)
        : Coordinate(InCoordinate)
        , OppositNodeIndex(NodeIndex1)
        , DeltaU(InDeltaU)
    {
    };
};
 
template<typename FCuttingPointType>
void GetCuttingPointCoordinates(const TArray<FCuttingPointType>& CuttingPoints, TArray<double>& CuttingPointCoordinates);
 
using FAddCuttingPointFunc = TFunction<void(const double, const ECoordinateType, const FPairOfIndex, const double)>;
 
struct FEdge2DProperties;
struct FCuttingPoint;
 
class FModelMesh;
class FEdgeMesh;
class FSurface;
class FThinZone;
class FTopologicalLoop;
class FTopologicalVertex;
 
class CADKERNEL_API FTopologicalEdge : public TLinkable<FTopologicalEdge, FEdgeLink>
{
    friend class FEntity;
    friend class FTopologicalLoop;
    friend class FTopologicalFace;
 
private:
    const double FactorToComputeMaxTol = 0.1;
 
protected:
 
    TSharedPtr<FTopologicalVertex> StartVertex;
    TSharedPtr<FTopologicalVertex> EndVertex;
 
    FLinearBoundary Boundary;
 
    TSharedPtr<FRestrictionCurve> Curve;
    mutable double Length3D = -1.;
 
    // To avoid huge tolerance in case of degenerated edge, the max tol is defined as Length3D / 10.
    mutable double Max2DTolerance = -1;
 
    FTopologicalLoop* Loop = nullptr;
 
    TSharedPtr<FEdgeMesh> Mesh;
 
    TArray<FCuttingPoint> CuttingPointUs;
 
    TArray<FImposedCuttingPoint> ImposedCuttingPointUs;
 
    TArray<FThinZoneSide*> ThinZoneSides;
    TArray<FLinearBoundary> ThinZoneBounds;
 
    TArray<double> CrossingPointUs;
 
    TArray<double> CrossingPointDeltaUMins;
 
    TArray<double> CrossingPointDeltaUMaxs;
 
private:
 
    FTopologicalEdge(const TSharedRef<FRestrictionCurve>& InCurve, const TSharedRef<FTopologicalVertex>& InVertex1, const TSharedRef<FTopologicalVertex>& InVertex2, const FLinearBoundary& InBoundary);
    FTopologicalEdge(const TSharedRef<FRestrictionCurve>& InCurve, const TSharedRef<FTopologicalVertex>& InVertex1, const TSharedRef<FTopologicalVertex>& InVertex2);
    FTopologicalEdge(const TSharedRef<FRestrictionCurve>& InCurve, const FLinearBoundary& InBoundary);
    FTopologicalEdge(const TSharedRef<FSurface>& InSurface, const FVector2d& InCoordinateVertex1, const TSharedRef<FTopologicalVertex>& InVertex1, const FVector2d& InCoordinateVertex2, const TSharedRef<FTopologicalVertex>& InVertex2);
 
    FTopologicalEdge() = default;
 
    void SetLoop(FTopologicalLoop& NewBoundary)
    {
        Loop = &NewBoundary;
    }
 
    void RemoveLoop()
    {
        Loop = nullptr;
    }
 
    bool CheckVertices();
 
public:
 
    static TSharedPtr<FTopologicalEdge> Make(const TSharedRef<FRestrictionCurve>& InCurve, const TSharedRef<FTopologicalVertex>& InVertex1, const TSharedRef<FTopologicalVertex>& InVertex2, const FLinearBoundary& InBoundary);
    static TSharedPtr<FTopologicalEdge> Make(const TSharedRef<FRestrictionCurve>& InCurve, const TSharedRef<FTopologicalVertex>& InVertex1, const TSharedRef<FTopologicalVertex>& InVertex2);
    static TSharedPtr<FTopologicalEdge> Make(const TSharedRef<FRestrictionCurve>& InCurve, const FLinearBoundary& InBoundary);
    static TSharedPtr<FTopologicalEdge> Make(const TSharedRef<FRestrictionCurve>& InCurve);
 
    static TSharedPtr<FTopologicalEdge> Make(const TSharedRef<FSurface>& InSurface, const FVector2d& InCoordinateVertex1, const TSharedRef<FTopologicalVertex>& InVertex1, const FVector2d& InCoordinateVertex2, const TSharedRef<FTopologicalVertex>& InVertex2);
 
    static TSharedPtr<FTopologicalEdge> ReturnIfValid(TSharedRef<FTopologicalEdge>& InEdge, bool bCheckVertices);
 
    virtual ~FTopologicalEdge() override
    {
        FTopologicalEdge::Empty();
    }
 
    virtual void Empty() override;
 
    virtual void Serialize(FCADKernelArchive& Ar) override
    {
        TLinkable<FTopologicalEdge, FEdgeLink>::Serialize(Ar);
        SerializeIdent(Ar, StartVertex);
        SerializeIdent(Ar, EndVertex);
        SerializeIdent(Ar, Curve);
        Ar << Boundary;
        SerializeIdent(Ar, &Loop);
        Ar << Length3D;
        Max2DTolerance = Length3D * FactorToComputeMaxTol;
    }
 
    virtual void SpawnIdent(FDatabase& Database) override;
 
    virtual void ResetMarkersRecursively() const override
    {
        TLinkable<FTopologicalEdge, FEdgeLink>::ResetMarkersRecursively();
        StartVertex->ResetMarkersRecursively();
        EndVertex->ResetMarkersRecursively();
 
        Curve->ResetMarkersRecursively();;
    }
 
#ifdef CADKERNEL_DEV
    virtual FInfoEntity& GetInfo(FInfoEntity&) const override;
#endif
 
    double GetTolerance3D() const
    {
        return GetCurve()->GetCarrierSurface()->Get3DTolerance();
    }
 
    double GetTolerance2DAt(double Coordinate) const
    {
        return FMath::Min(Max2DTolerance, GetCurve()->GetToleranceAt(Coordinate));
    }
 
    virtual EEntity GetEntityType() const override
    {
        return EEntity::TopologicalEdge;
    }
 
    // ======   Topological Function   ======
 
    void LinkVertex();
 
    bool CheckIfDegenerated() const;
 
    bool IsLinkableTo(const FTopologicalEdge& Edge, double EdgeLengthTolerance) const;
 
    void LinkIfCoincident(FTopologicalEdge& OtherEdge, double EdgeLengthTolerance, double SquareJoiningTolerance);
 
    void Link(FTopologicalEdge& OtherEdge);
 
    void Disjoin();
 
    void Unlink()
    {
        Disjoin();
    }
 
 
    TSharedRef<const FTopologicalEdge> GetLinkActiveEdge() const
    {
        return StaticCastSharedRef<const FTopologicalEdge>(GetLinkActiveEntity());
    }
 
    TSharedRef<FTopologicalEdge> GetLinkActiveEdge()
    {
        return StaticCastSharedRef<FTopologicalEdge>(GetLinkActiveEntity());
    }
 
    FTopologicalEdge* GetFirstTwinEdge() const
    {
        if (!TopologicalLink)
        {
            return nullptr;
        }
 
        if (TopologicalLink->GetTwinEntities().Num() < 2)
        {
            return nullptr;
        }
 
        FTopologicalEdge* FirstTwinEdge = (TopologicalLink->GetTwinEntities()[0] == this) ? TopologicalLink->GetTwinEntities()[1] : TopologicalLink->GetTwinEntities()[0];
        return FirstTwinEdge;
    }
 
    FTopologicalEdge* GetTwinEdge() const
    {
        const TArray<FTopologicalEdge*>& TwinEdges = GetTwinEntities();
        if (TwinEdges.Num() > 1)
        {
            return TwinEdges[0] == this ? TwinEdges[1] : TwinEdges[0];
        }
        return nullptr;
    }
 
    bool IsSameDirection(const FTopologicalEdge& Edge) const;
 
    bool IsTangentAtExtremitiesWith(const FTopologicalEdge & Edge) const;
 
    bool IsClosed() const
    {
        return StartVertex->GetLinkActiveEntity() == EndVertex->GetLinkActiveEntity();
    }
 
    void ReplaceEdgeVertex(bool bIsStartVertex, TSharedRef<FTopologicalVertex>& NewVertex);
 
    const FTopologicalLoop* GetLoop() const
    {
        return Loop;
    }
 
    FTopologicalLoop* GetLoop()
    {
        return Loop;
    }
 
    FTopologicalFace* GetFace() const;
 
    // ======   Vertex Functions (Get, Set, ...)   ======
 
    const TSharedRef<FTopologicalVertex> GetStartVertex(EOrientation Forward) const
    {
        return (Forward == EOrientation::Front ? StartVertex.ToSharedRef() : EndVertex.ToSharedRef());
    }
 
    const TSharedRef<FTopologicalVertex> GetEndVertex(EOrientation Forward) const
    {
        return (Forward == EOrientation::Front ? EndVertex.ToSharedRef() : StartVertex.ToSharedRef());
    }
 
    const TSharedRef<FTopologicalVertex> GetStartVertex(bool Forward) const
    {
        return (Forward ? StartVertex.ToSharedRef() : EndVertex.ToSharedRef());
    }
 
    const TSharedRef<FTopologicalVertex> GetEndVertex(bool Forward) const
    {
        return (Forward ? EndVertex.ToSharedRef() : StartVertex.ToSharedRef());
    }
 
    const TSharedRef<FTopologicalVertex> GetStartVertex() const
    {
        return StartVertex.ToSharedRef();
    }
 
    const TSharedRef< FTopologicalVertex> GetEndVertex() const
    {
        return EndVertex.ToSharedRef();
    }
 
    TSharedRef<FTopologicalVertex> GetStartVertex()
    {
        return StartVertex.ToSharedRef();
    }
 
    TSharedRef<FTopologicalVertex> GetEndVertex()
    {
        return EndVertex.ToSharedRef();
    }
 
    TSharedPtr<FTopologicalVertex> GetOtherVertex(const TSharedRef<FTopologicalVertex>& Vertex)
    {
        return (Vertex->GetLink() == StartVertex->GetLink() ? EndVertex : (Vertex->GetLink() == EndVertex->GetLink() ? StartVertex : TSharedPtr<FTopologicalVertex>()));
    }
 
    FTopologicalVertex* GetOtherVertex(FTopologicalVertex& Vertex)
    {
        return (Vertex.GetLink() == StartVertex->GetLink() ? EndVertex.Get() : (Vertex.GetLink() == EndVertex->GetLink() ? StartVertex.Get() : nullptr));
    }
 
    const FTopologicalVertex* GetOtherVertex(const FTopologicalVertex& Vertex) const
    {
        return (Vertex.GetLink() == StartVertex->GetLink() ? EndVertex.Get() : (Vertex.GetLink() == EndVertex->GetLink() ? StartVertex.Get() : nullptr));
    }
 
    const TSharedPtr<FTopologicalVertex> GetOtherVertex(const TSharedRef<FTopologicalVertex>& Vertex) const
    {
        return (Vertex->GetLink() == StartVertex->GetLink() ? EndVertex : (Vertex->GetLink() == EndVertex->GetLink() ? StartVertex : TSharedPtr<FTopologicalVertex>()));
    }
 
    void SetStartVertex(const double NewCoordinate);
    void SetEndVertex(const double NewCoordinate);
 
    void SetStartVertex(const double NewCoordinate, const FVector& NewPoint3D);
    void SetEndVertex(const double NewCoordinate, const FVector& NewPoint3D);
 
    // ======   Boundary Function   ======
 
    const FLinearBoundary& GetBoundary() const
    {
        return Boundary;
    }
 
    double GetStartCurvilinearCoordinates() const
    {
        return Boundary.GetMin();
    }
 
    double GetEndCurvilinearCoordinates() const
    {
        return Boundary.GetMax();
    }
 
    FVector GetStartBarycenter()
    {
        return StartVertex->GetBarycenter();
    }
 
    FVector GetEndBarycenter()
    {
        return EndVertex->GetBarycenter();
    }
 
    FVector GetStartCoordinate()
    {
        return StartVertex->GetCoordinates();
    }
 
    FVector GetEndCoordinate()
    {
        return EndVertex->GetCoordinates();
    }
 
    void GetTangentsAtExtremities(FVector& StartTangent, FVector& EndTangent, bool bForward) const;
    void GetTangentsAtExtremities(FVector& StartTangent, FVector& EndTangent, EOrientation Orientation) const
    {
        GetTangentsAtExtremities(StartTangent, EndTangent, Orientation == EOrientation::Front);
    }
 
    // ======   Meshing Function   ======
 
    const FEdgeMesh* GetMesh() const
    {
        if (GetLinkActiveEntity() != AsShared())
        {
            return GetLinkActiveEdge()->GetMesh();
        }
        if (Mesh.IsValid())
        {
            return Mesh.Get();
        }
        return nullptr;
    }
 
    FEdgeMesh& GetOrCreateMesh(FModelMesh& MeshModel);
 
    void RemovePreMesh();
 
    const FTopologicalEdge* GetPreMeshedTwin() const;
    FTopologicalEdge* GetPreMeshedTwin()
    {
        return const_cast<FTopologicalEdge*> (static_cast<const FTopologicalEdge*>(this)->GetPreMeshedTwin());
    }
 
    void ComputeCrossingPointCoordinates();
 
    int32 EvaluateCuttingPointNum();
 
    void InitDeltaUs()
    {
        int32 Size = CrossingPointUs.Num();
        ensureCADKernel(Size >= 2);
        CrossingPointUs.SetNum(Size);
        CrossingPointDeltaUMins.Init(DOUBLE_SMALL_NUMBER, Size - 1);
        CrossingPointDeltaUMaxs.Init(2.0 * (GetEndCurvilinearCoordinates() - GetStartCurvilinearCoordinates()), Size - 1);
    }
 
    const TArray<double>& GetCrossingPointUs() const
    {
        return CrossingPointUs;
    }
 
    TArray<double>& GetCrossingPointUs()
    {
        return CrossingPointUs;
    }
 
    TArray<double>& GetDeltaUMins()
    {
        return CrossingPointDeltaUMins;
    }
 
    TArray<double>& GetDeltaUMaxs()
    {
        return CrossingPointDeltaUMaxs;
    }
 
    const TArray<double>& GetDeltaUMaxs() const
    {
        return CrossingPointDeltaUMaxs;
    }
 
    double GetDeltaUFor(double Coordinate, int32& Index) const 
    {
        for (; Index < CrossingPointUs.Num() - 1; ++Index)
        {
            if (Coordinate < CrossingPointUs[Index + 1])
            {
                if (Coordinate > CrossingPointUs[Index] - DOUBLE_SMALL_NUMBER)
                {
                    break;
                }
                Index = 0;
                if(Coordinate < CrossingPointUs[1])
                {
                    break;
                }
            }
        }
        return CrossingPointDeltaUMaxs[Index];
    }
 
    TArray<FCuttingPoint>& GetCuttingPoints()
    {
        return CuttingPointUs;
    };
 
    const TArray<FCuttingPoint>& GetCuttingPoints() const
    {
        return CuttingPointUs;
    }
 
    TArray<double> GetCuttingPointCoordinates() const;
 
    void TransferCuttingPointFromMeshedEdge(bool bOnlyWithOppositeNode, FAddCuttingPointFunc AddCuttingPoint);
 
    TArray<double> GetPreElementLengths() const;
 
    // For thin zone purpose
    void SortImposedCuttingPoints();
 
    const TArray<FImposedCuttingPoint>& GetImposedCuttingPoints() const
    {
        return ImposedCuttingPointUs;
    }
 
    void AddThinZone(FThinZoneSide* InThinZoneSide, const FLinearBoundary& InThinZoneBounds)
    {
        if(InThinZoneSide)
        {
            ThinZoneSides.AddUnique(InThinZoneSide);
            ThinZoneBounds.Add(InThinZoneBounds);
        }
    }
 
    int32 GetThinZoneCount() const
    {
        return ThinZoneSides.Num();
    }
 
    const TArray<FThinZoneSide*>& GetThinZoneSides() const
    {
        return ThinZoneSides;
    }
 
    const TArray<FLinearBoundary>& GetThinZoneBounds() const
    {
        return ThinZoneBounds;
    }
 
    void AddImposedCuttingPointU(const double ImposedCuttingPointU, const int32 OppositeNodeIndex, const double DeltaU);
    void AddTwinsCuttingPoint(const double Coord, const double DeltaU);
 
    void GenerateMeshElements(FModelMesh& MeshModel);
 
    // ======   Curve Functions   ======
 
    TSharedRef<FRestrictionCurve> GetCurve() const
    {
        return Curve.ToSharedRef();
    }
 
    TSharedRef<FRestrictionCurve> GetCurve()
    {
        return Curve.ToSharedRef();
    }
 
    void ComputeLength();
    double Length() const;
 
    void Sample(const double DesiredSegmentLength, TArray<double>& OutCoordinates) const;
 
    void EvaluatePoint(double InCoordinate, int32 Derivative, FCurvePoint& Point) const
    {
        Curve->EvaluatePoint(InCoordinate, Point, Derivative);
    }
 
    void EvaluatePoints(const TArray<double>& InCoordinates, int32 DerivativeOrder, TArray<FCurvePoint>& OutPoints) const
    {
        Curve->EvaluatePoints(InCoordinates, OutPoints, DerivativeOrder);
    }
 
    void ApproximatePoints(const TArray<double>& InCoordinates, TArray<FVector>& OutPoints) const
    {
        Curve->Approximate3DPoints(InCoordinates, OutPoints);
    }
 
    FVector2d Approximate2DPoint(const double InCoordinate) const
    {
        return Curve->Approximate2DPoint(InCoordinate);
    }
 
    void Approximate2DPoints(const TArray<double>& InCoordinates, TArray<FVector2d>& OutPoints) const
    {
        Curve->Approximate2DPoints(InCoordinates, OutPoints);
    }
 
    void ApproximatePolyline(FSurfacicPolyline& Polyline) const
    {
        Curve->ApproximatePolyline(Polyline);
    }
 
    FVector GetTangentAt(const double InCoordinate) const
    {
        return Curve->GetTangentAt(InCoordinate);
    }
 
    FVector2d GetTangent2DAt(const double InCoordinate) const
    {
        return Curve->GetTangent2DAt(InCoordinate);
    }
 
    FVector GetTangentAt(const FTopologicalVertex& InVertex);
    FVector2d GetTangent2DAt(const FTopologicalVertex& InVertex);
 
    template<class PointType>
    double ProjectPoint(const PointType& InPointToProject, PointType& OutProjectedPoint) const
    {
        return Curve->GetCoordinateOfProjectedPoint(Boundary, InPointToProject, OutProjectedPoint);
    }
 
    void ProjectPoints(const TArray<FVector>& InPointsToProject, TArray<double>& OutProjectedPointCoords, TArray<FVector>& OutProjectedPoints) const
    {
        Curve->ProjectPoints(Boundary, InPointsToProject, OutProjectedPointCoords, OutProjectedPoints);
    }
 
    void ProjectTwinEdgePoints(const TArray<FVector>& InPointsToProject, bool bSameOrientation, TArray<double>& OutProjectedPointCoords) const
    {
        const double ToleranceOfProjection = Length3D * 0.1;
        Curve->ProjectTwinCurvePoints(Boundary, InPointsToProject, bSameOrientation, OutProjectedPointCoords, ToleranceOfProjection);
    }
 
    void ProjectTwinEdgePointsOn2DCurve(const TSharedRef<FTopologicalEdge>& InTwinEdge, const TArray<double>& InTwinEdgePointCoords, TArray<FVector2d>& OutPoints2D);
 
    void ComputeIntersectionsWithIsos(const TArray<double>& InIsoCoordinates, const EIso InTypeIso, const FSurfacicTolerance& ToleranceIso, TArray<double>& OutIntersection) const
    {
        Curve->ComputeIntersectionsWithIsos(Boundary, InIsoCoordinates, InTypeIso, ToleranceIso, OutIntersection);
    }
 
    template<class PointType>
    void GetDiscretization2DPoints(EOrientation Orientation, TArray<PointType>& OutPoints) const
    {
        Curve->GetDiscretizationPoints(Boundary, Orientation, OutPoints);
    }
 
    double TransformLocalCoordinateToActiveEdgeCoordinate(const double LocalCoordinate) const;
    double TransformActiveEdgeCoordinateToLocalCoordinate(const double ActiveEdgeCoordinate) const;
    double TransformTwinEdgeCoordinateToLocalCoordinate(const FTopologicalEdge& TwinEdge, const double InTwinCoordinate) const;
 
    void TransformTwinEdgeCoordinatesToLocalCoordinates(const FTopologicalEdge& TwinEdge, const TArray<double>& InActiveEdgeCoordinate, TArray<double>& OutLocalCoordinate) const;
    void TransformActiveEdgeCoordinatesToLocalCoordinates(const TArray<double>& InActiveEdgeCoordinate, TArray<double>& OutLocalCoordinate) const;
    void TransformLocalCoordinatesToActiveEdgeCoordinates(const TArray<double>& InLocalCoordinate, TArray<double>& OutActiveEdgeCoordinate) const;
 
    void ComputeEdge2DProperties(FEdge2DProperties& SlopeCharacteristics);
 
    void GetExtremities(FSurfacicCurveExtremities& Extremities) const
    {
        Curve->GetExtremities(Boundary, Extremities);
    }
 
    void Offset2D(const FVector2d& OffsetDirection);
 
    // ======   Geometrical Functions   ======
 
    FTopologicalVertex* SplitAt(double SplittingCoordinate, const FVector& NewVertexCoordinate, bool bKeepStartVertexConnectivity, TSharedPtr<FTopologicalEdge>& OutNewEdge);
 
    bool ExtendTo(bool bStartExtremity, const FVector2d& NewExtremityCoordinate, TSharedRef<FTopologicalVertex>& NewVertex);
 
    bool IsSharpEdge() const;
 
    bool HasSameLengthAs(const FTopologicalEdge& Edge, double EdgeLengthTolerance) const;
 
    // ======   State Functions   ======
 
    virtual bool IsDegenerated() const override
    {
        return FHaveStates::IsDegenerated();
    }
 
    bool IsThinPeak() const
    {
        return ((States & EHaveStates::ThinPeak) == EHaveStates::ThinPeak);
    }
 
    virtual void SetThinPeakMarker() const
    {
        States |= EHaveStates::ThinPeak;
    }
 
    virtual void ResetThinPeakMarker() const
    {
        States &= ~EHaveStates::ThinPeak;
    }
 
    bool IsVirtuallyMeshed() const
    {
        return ((States & EHaveStates::IsVirtuallyMeshed) == EHaveStates::IsVirtuallyMeshed);
    }
 
    virtual void SetVirtuallyMeshedMarker() const
    {
        States |= EHaveStates::IsVirtuallyMeshed;
    }
 
    virtual void ResetVirtuallyMeshedMarker() const
    {
        States &= ~EHaveStates::IsVirtuallyMeshed;
    }
 
    bool IsBorder() const
    {
        return GetTwinEntityCount() == 1;
    }
 
    bool IsSurfacic() const
    {
        return GetTwinEntityCount() == 2;
    }
 
    bool IsConnectedTo(const FTopologicalFace* Face) const;
 
    TArray<FTopologicalFace*> GetLinkedFaces() const;
 
    static TSharedPtr<FTopologicalEdge> CreateEdgeByMergingEdges(const double SmallEdgeTolerance, TArray<FOrientedEdge>& Edges, const TSharedRef<FTopologicalVertex>& StartVertex, const TSharedRef<FTopologicalVertex>& EndVertex);
};
 
struct CADKERNEL_API FEdge2DProperties
{
    double StandardDeviation = 0;
    double MediumSlope = 0;
    double Length3D = 0;
    EIso IsoType = EIso::UndefinedIso;
    bool bIsMesh = false;
    double MeshedLength = 0;
 
    void Add(double InSlope, double InLength)
    {
        double Temp = InSlope * InLength;
        MediumSlope += Temp;
        Temp *= InSlope;
        StandardDeviation += Temp;
        Length3D += InLength;
    }
 
    // Finalize has been done on each Property
    void Add2(FEdge2DProperties& Property)
    {
        StandardDeviation = (FMath::Square(StandardDeviation) + FMath::Square(MediumSlope)) * Length3D + (FMath::Square(Property.StandardDeviation) + FMath::Square(Property.MediumSlope)) * Property.Length3D;
        MediumSlope = MediumSlope * Length3D + Property.MediumSlope * Property.Length3D;
        Length3D += Property.Length3D;
 
        MediumSlope /= Length3D;
        StandardDeviation /= Length3D;
        StandardDeviation -= FMath::Square(MediumSlope);
        StandardDeviation = sqrt(StandardDeviation);
    }
 
    // Finalize has not been done on each Property
    void Add(FEdge2DProperties& Property)
    {
        StandardDeviation += Property.StandardDeviation;
        MediumSlope += Property.MediumSlope;
        Length3D += Property.Length3D;
    }
 
    void Finalize()
    {
        MediumSlope /= Length3D;
        StandardDeviation /= Length3D;
        StandardDeviation -= FMath::Square(MediumSlope);
        if (StandardDeviation < 0)
        {
            StandardDeviation = 0;
        }
        else
        {
            StandardDeviation = sqrt(StandardDeviation);
        }
        IsoType = EIso::UndefinedIso;
 
        if (MediumSlope < 0.2)
        {
            if (StandardDeviation < 0.1)
            {
                IsoType = EIso::IsoU;
            }
        }
        else if (MediumSlope > 1.8)
        {
            if (StandardDeviation < 0.1)
            {
                IsoType = EIso::IsoV;
            }
        }
    }
 
};
 
struct CADKERNEL_API FCuttingPoint
{
    double Coordinate;
    ECoordinateType Type;
    FPairOfIndex OppositNodeIndices;
    double IsoDeltaU = 0;
 
    FCuttingPoint()
        : Coordinate(0)
        , Type(ECoordinateType::OtherCoordinate)
        , OppositNodeIndices(FPairOfIndex::Undefined)
        , IsoDeltaU(HUGE_VAL)
    {
    }
 
    FCuttingPoint(double InCoordinate, ECoordinateType InType)
        : Coordinate(InCoordinate)
        , Type(InType)
        , OppositNodeIndices(FPairOfIndex::Undefined)
        , IsoDeltaU(HUGE_VAL)
    {
    }
 
    FCuttingPoint(double InCoordinate, ECoordinateType InType, FPairOfIndex InOppositNodeIndices, double DeltaU)
        : Coordinate(InCoordinate)
        , Type(InType)
        , OppositNodeIndices(InOppositNodeIndices)
        , IsoDeltaU(DeltaU)
    {
    }
 
    FCuttingPoint(double InCoordinate, ECoordinateType InType, int32 InOppositeNodeId, double DeltaU)
        : Coordinate(InCoordinate)
        , Type(InType)
        , OppositNodeIndices(InOppositeNodeId)
        , IsoDeltaU(DeltaU)
    {
    }
};
 
struct CADKERNEL_API FCuttingGrid
{
    TArray<FCuttingPoint> Coordinates[2];
 
    constexpr TArray<FCuttingPoint>& operator[](EIso Iso)
    {
        ensureCADKernel(Iso == 0 || Iso == 1);
        return Coordinates[Iso];
    }
 
    constexpr const TArray<FCuttingPoint>& operator[](EIso Iso) const
    {
        ensureCADKernel(Iso == 0 || Iso == 1);
        return Coordinates[Iso];
    }
};
 
 
template<typename FCuttingPointType>
void GetCuttingPointCoordinates(const TArray<FCuttingPointType>& CuttingPoints, TArray<double>& CuttingPointCoordinates)
{
    CuttingPointCoordinates.Empty(CuttingPoints.Num());
    for (const FCuttingPointType& CuttingPoint : CuttingPoints)
    {
        CuttingPointCoordinates.Add(CuttingPoint.Coordinate);
    }
};
 
 
} // namespace UE::CADKernel