RestrictionCurve.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Core/CADKernelArchive.h"
#include "Core/Types.h"
#include "Geo/Curves/SurfacicCurve.h"
#include "Geo/GeoEnum.h"
#include "Geo/GeoPoint.h"
#include "Geo/Sampling/SurfacicPolyline.h"
#include "Geo/Surfaces/Surface.h"
#include "Math/Boundary.h"
#include "Math/MatrixH.h"
#include "Math/Point.h"
 
namespace UE::CADKernel
{
class FCurve;
class FEntityGeom;
 
class CADKERNEL_API FRestrictionCurve : public FSurfacicCurve
{
    friend class FEntity;
    friend class FTopologicalEdge;
 
protected:
 
    FSurfacicPolyline Polyline;
    double MinLinearTolerance;
 
    FRestrictionCurve(TSharedRef<FSurface> InCarrierSurface, TSharedRef<FCurve> InCurve2D)
        : FSurfacicCurve(InCurve2D, InCarrierSurface)
        , Polyline(InCarrierSurface, InCurve2D)
    {
        MinLinearTolerance = Boundary.ComputeMinimalTolerance();
    }
 
    FRestrictionCurve() = default;
 
public:
 
    virtual void Serialize(FCADKernelArchive& Ar) override
    {
        FSurfacicCurve::Serialize(Ar);
        Polyline.Serialize(Ar);
        if (Ar.IsLoading())
        {
            MinLinearTolerance = Boundary.ComputeMinimalTolerance();
        }
    }
 
#ifdef CADKERNEL_DEV
    virtual FInfoEntity& GetInfo(FInfoEntity&) const override;
#endif
 
    virtual ECurve GetCurveType() const override
    {
        return ECurve::Restriction;
    }
 
    const FSurfacicPolyline& GetPolyline() const
    {
        return Polyline;
    }
 
    const TSharedRef<FCurve> Get2DCurve() const
    {
        return Curve2D.ToSharedRef();
    }
 
    double GetMinLinearTolerance() const
    {
        return MinLinearTolerance;
    }
 
    TSharedPtr<FEntityGeom> ApplyMatrix(const FMatrixH& InMatrix) const override
    {
        ensureCADKernel(false);
        return TSharedPtr<FEntityGeom>();
    }
 
    FVector2d Approximate2DPoint(double InCoordinate) const
    {
        return Polyline.Approximate2DPoint(InCoordinate);
    }
 
    FVector Approximate3DPoint(double InCoordinate) const
    {
        return Polyline.Approximate3DPoint(InCoordinate);
    }
 
    FVector GetTangentAt(double InCoordinate) const
    {
        return Polyline.GetTangentAt(InCoordinate);
    }
 
    FVector2d GetTangent2DAt(double InCoordinate) const
    {
        return Polyline.GetTangent2DAt(InCoordinate);
    }
 
    void Approximate2DPoints(const TArray<double>& InCoordinates, TArray<FVector2d>& OutPoints) const
    {
        return Polyline.Approximate2DPoints(InCoordinates, OutPoints);
    }
 
    void Approximate3DPoints(const TArray<double>& InCoordinates, TArray<FVector>& OutPoints) const
    {
        return Polyline.Approximate3DPoints(InCoordinates, OutPoints);
    }
 
    void ApproximatePolyline(FSurfacicPolyline& OutPolyline) const
    {
        Polyline.ApproximatePolyline(OutPolyline);
    }
 
    template<class PointType>
    double GetCoordinateOfProjectedPoint(const FLinearBoundary& InBoundary, const PointType& PointOnEdge, PointType& ProjectedPoint) const
    {
        return Polyline.GetCoordinateOfProjectedPoint(InBoundary, PointOnEdge, ProjectedPoint);
    }
 
    template<class PointType>
    void ProjectPoints(const FLinearBoundary& InBoundary, const TArray<PointType>& InPointsToProject, TArray<double>& ProjectedPointCoordinates, TArray<PointType>& ProjectedPoints) const
    {
        Polyline.ProjectPoints(InBoundary, InPointsToProject, ProjectedPointCoordinates, ProjectedPoints);
    }
 
    void ProjectTwinCurvePoints(const FLinearBoundary& InBoundary, const TArray<FVector>& InPointsToProject, bool bSameOrientation, TArray<double>& OutProjectedPointCoords, double ToleranceOfProjection) const
    {
        Polyline.ProjectCoincidentalPolyline(InBoundary, InPointsToProject, bSameOrientation, OutProjectedPointCoords, ToleranceOfProjection);
    }
 
    void ComputeIntersectionsWithIsos(const FLinearBoundary& InBoundary, const TArray<double>& InIsoCoordinates, const EIso InTypeIso, const FSurfacicTolerance& ToleranceIso, TArray<double>& OutIntersection) const
    {
        Polyline.ComputeIntersectionsWithIsos(InBoundary, InIsoCoordinates, InTypeIso, ToleranceIso, OutIntersection);
    }
 
    void CheckIfDegenerated(const FLinearBoundary& InBoundary, bool& bDegeneration2D, bool& bDegeneration3D, double& Length3D) const
    {
        if (Polyline.Coordinates.Num() <  2)
        {
            bDegeneration2D = true;
            bDegeneration3D = true;
            Length3D = 0.;
            return;
        }
        double Tolerance = GetCarrierSurface()->Get3DTolerance();
        const FSurfacicTolerance& Tolerances2D = GetCarrierSurface()->GetIsoTolerances();
        Polyline.CheckIfDegenerated(Tolerance, Tolerances2D, InBoundary, bDegeneration2D, bDegeneration3D, Length3D);
    }
 
    void GetExtremities(const FLinearBoundary& InBoundary, FSurfacicCurveExtremities& Extremities) const
    {
        double Tolerance = GetCarrierSurface()->Get3DTolerance();
        const FSurfacicTolerance& Tolerances2D = GetCarrierSurface()->GetIsoTolerances();
        Polyline.GetExtremities(InBoundary, Tolerance, Tolerances2D, Extremities);
    }
 
    double GetToleranceAt(const double InCoordinate)
    {
        FDichotomyFinder Finder(Polyline.GetCoordinates());
        const int32 Index = Finder.Find(InCoordinate);
        const double Tolerance = GetCarrierSurface()->Get3DTolerance();
 
        return Polyline.ComputeLinearToleranceAt(Tolerance, MinLinearTolerance, Index);
    }
 
    FVector2d GetExtremityTolerances(const FLinearBoundary& InBoundary)
    {
        FDichotomyFinder Finder(Polyline.GetCoordinates());
        const int32 StartIndex = Finder.Find(InBoundary.Min);
        const int32 EndIndex = Finder.Find(InBoundary.Max);
 
        const double Tolerance = GetCarrierSurface()->Get3DTolerance();
 
        FVector2d ExtremityTolerance;
        ExtremityTolerance[0] = Polyline.ComputeLinearToleranceAt(Tolerance, MinLinearTolerance, StartIndex);
        ExtremityTolerance[1] = Polyline.ComputeLinearToleranceAt(Tolerance, MinLinearTolerance, EndIndex);
        return ExtremityTolerance;
    }
 
    int32 GetPolylineSize()
    {
        return Polyline.Size();
    }
 
    template<class PointType>
    void GetDiscretizationPoints(const FLinearBoundary& InBoundary, EOrientation Orientation, TArray<PointType>& OutPoints) const
    {
        Polyline.GetSubPolyline(InBoundary, Orientation, OutPoints);
    }
 
    template<class PointType>
    void GetDiscretizationPoints(const FLinearBoundary& InBoundary, TArray<double>& OutCoordinates, TArray<PointType>& OutPoints) const
    {
        Polyline.GetSubPolyline(InBoundary, OutCoordinates, OutPoints);
    }
 
    void Sample(const FLinearBoundary& InBoundary, const double DesiredSegmentLength, TArray<double>& OutCoordinates) const
    {
        Polyline.Sample(InBoundary, DesiredSegmentLength, OutCoordinates);
    }
 
    double ApproximateLength(const FLinearBoundary& InBoundary) const
    {
        return Polyline.GetLength(InBoundary);
    }
 
    void ExtendTo(const FVector2d& Point) override;
 
    bool IsIso(EIso Iso, double ErrorTolerance = DOUBLE_SMALL_NUMBER) const
    {
        return Polyline.IsIso(Iso, ErrorTolerance);
    }
 
    void Offset2D(const FVector2d& OffsetDirection);
 
    virtual void Offset(const FVector& OffsetDirection) override
    {
        ensureCADKernel(false);
    }
 
};
 
} // namespace UE::CADKernel