Boundary.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Core/Types.h"
#include "Geo/GeoEnum.h"
#include "Math/MathConst.h"
#include "Math/Point.h"
 
namespace UE::CADKernel
{
#define MINIMAL_UNIT_LINEAR_TOLERANCE 1e-5
 
struct CADKERNEL_API FLinearBoundary
{
 
    static const FLinearBoundary DefaultBoundary;
 
    double Min;
    double Max;
 
    FLinearBoundary()
    {
        Min = 0.;
        Max = 1.;
    }
 
    FLinearBoundary(const FLinearBoundary& Boundary)
        : Min(Boundary.Min)
        , Max(Boundary.Max)
    {
    }
 
    FLinearBoundary(const double UMin, const double UMax)
    {
        Set(UMin, UMax);
    }
 
    FLinearBoundary(const FLinearBoundary& Boundary, const double OffsetTolerance)
        : Min(Boundary.Min - OffsetTolerance)
        , Max(Boundary.Max + OffsetTolerance)
    {
    }
 
    FLinearBoundary(const double UMin, const double UMax, const double OffsetTolerance)
    {
        Set(UMin, UMax);
        Offset(OffsetTolerance);
    }
 
    friend FArchive& operator<<(FArchive& Ar, FLinearBoundary& Boundary)
    {
        Ar.Serialize(&Boundary, sizeof(FLinearBoundary));
        return Ar;
    }
 
    constexpr double GetMin() const
    {
        return Min;
    }
 
    constexpr double GetMax() const
    {
        return Max;
    }
 
    constexpr double GetAt(const double Coordinate) const
    {
        return Min + (Max - Min) * Coordinate;
    }
 
    constexpr double GetMiddle() const
    {
        return (Min + Max) * 0.5;
    }
 
    double Size() const { return Max - Min; }
 
    void SetMin(const double Coordinates)
    {
        FMath::GetMinMax(Coordinates, Max, Min, Max);
    }
 
    void SetMax(const double Coordinates)
    {
        FMath::GetMinMax(Min, Coordinates, Min, Max);
    }
 
    void Set(const double InUMin = 0., const double InUMax = 1.)
    {
        FMath::GetMinMax(InUMin, InUMax, Min, Max);
    }
 
    void Set(const TArray<double>& Coordinates)
    {
        Init();
        for (const double& Coordinate : Coordinates)
        {
            ExtendTo(Coordinate);
        }
    }
 
 
    bool IsValid() const
    {
        return Min <= Max;
    }
 
    bool Contains(const double Coordinate) const
    {
        return RealCompare(Coordinate, Min) >= 0 && RealCompare(Coordinate, Max) <= 0;
    }
 
    double Length() const
    {
        return GetMax() - GetMin();
    }
 
    bool IsDegenerated() const
    {
        double DeltaU = (Max - Min);
        return (DeltaU < DOUBLE_SMALL_NUMBER);
    }
 
    double ComputeMinimalTolerance() const
    {
        return Length() * MINIMAL_UNIT_LINEAR_TOLERANCE;
    }
 
    void MoveInsideIfNot(double& Coordinate, const double Tolerance = DOUBLE_SMALL_NUMBER) const
    {
        if (Coordinate <= Min)
        {
            Coordinate = Min + Tolerance;
        }
        else if (Coordinate >= Max)
        {
            Coordinate = Max - Tolerance;
        }
    }
 
    void Offset(const double Tolerance = DOUBLE_SMALL_NUMBER)
    {
        Min -= Tolerance;
        Max += Tolerance;
    }
 
    void Init()
    {
        Min = HUGE_VALUE;
        Max = -HUGE_VALUE;
    }
 
    void ExtendTo(double MinCoordinate, double MaxCoordinate)
    {
        FMath::GetMinMax(MinCoordinate, MaxCoordinate);
        Min = FMath::Min(Min, MinCoordinate);
        Max = FMath::Max(Max, MaxCoordinate);
    }
 
    void TrimAt(const FLinearBoundary& MaxBound)
    {
        if (Max < MaxBound.Min || Min > MaxBound.Max)
        {
            *this = MaxBound;
            return;
        }
 
        Min = FMath::Max(Min, MaxBound.Min);
        Max = FMath::Min(Max, MaxBound.Max);
    }
 
    void ExtendTo(const FLinearBoundary& MaxBound)
    {
        Min = FMath::Min(Min, MaxBound.Min);
        Max = FMath::Max(Max, MaxBound.Max);
    }
 
    void ExtendTo(const double Coordinate)
    {
        if (Coordinate < Min)
        {
            Min = Coordinate;
        }
 
        if (Coordinate > Max)
        {
            Max = Coordinate;
        }
    }
 
    void RestrictTo(const FLinearBoundary& MaxBound)
    {
        if (MaxBound.Min > Min)
        {
            Min = MaxBound.Min;
        }
        if (MaxBound.Max < Max)
        {
            Max = MaxBound.Max;
        }
    }
 
    void WidenIfDegenerated()
    {
        if (FMath::IsNearlyEqual(Min, Max))
        {
            Min -= DOUBLE_SMALL_NUMBER;
            Max += DOUBLE_SMALL_NUMBER;
        }
    }
 
    FLinearBoundary& operator=(const FLinearBoundary& InBounds)
    {
        Min = InBounds.Min;
        Max = InBounds.Max;
        return *this;
    }
 
};
 
class CADKERNEL_API FSurfacicBoundary
{
private:
    FLinearBoundary UVBoundaries[2];
 
public:
    static const FSurfacicBoundary DefaultBoundary;
 
    FSurfacicBoundary() = default;
 
    FSurfacicBoundary(const double InUMin, const double InUMax, const double InVMin, const double InVMax)
    {
        UVBoundaries[EIso::IsoU].Set(InUMin, InUMax);
        UVBoundaries[EIso::IsoV].Set(InVMin, InVMax);
    }
 
    FSurfacicBoundary(const double InUMin, const double InUMax, const double InVMin, const double InVMax, const double OffsetTolerance)
    {
        UVBoundaries[EIso::IsoU].Set(InUMin, InUMax);
        UVBoundaries[EIso::IsoV].Set(InVMin, InVMax);
        Offset(OffsetTolerance);
    }
 
    FSurfacicBoundary(const FVector2d& Point1, const FVector2d& Point2)
    {
        Set(Point1, Point2);
    }
 
    FSurfacicBoundary(const FVector2d& Point1, const FVector2d& Point2, const double OffsetTolerance)
    {
        Set(Point1, Point2);
        Offset(OffsetTolerance);
    }
 
    void Set(const FVector2d& Point1, const FVector2d& Point2)
    {
        UVBoundaries[EIso::IsoU].Set(Point1.X, Point2.X);
        UVBoundaries[EIso::IsoV].Set(Point1.Y, Point2.Y);
    }
 
    friend FArchive& operator<<(FArchive& Ar, FSurfacicBoundary& Boundary)
    {
        Ar << Boundary[EIso::IsoU];
        Ar << Boundary[EIso::IsoV];
        return Ar;
    }
 
    void Set(const FLinearBoundary& BoundU, const FLinearBoundary& BoundV)
    {
        UVBoundaries[EIso::IsoU] = BoundU;
        UVBoundaries[EIso::IsoV] = BoundV;
    }
 
    void Set(const double InUMin, const double InUMax, const double InVMin, const double InVMax)
    {
        UVBoundaries[EIso::IsoU].Set(InUMin, InUMax);
        UVBoundaries[EIso::IsoV].Set(InVMin, InVMax);
    }
 
    void Set()
    {
        UVBoundaries[EIso::IsoU].Set();
        UVBoundaries[EIso::IsoV].Set();
    }
 
    void Set(const TArray<FVector2d>& Points)
    {
        Init();
        for (const FVector2d& Point : Points)
        {
            ExtendTo(Point);
        }
    }
 
    const FLinearBoundary& Get(EIso Type) const
    {
        return UVBoundaries[Type];
    }
 
    bool IsValid() const
    {
        return UVBoundaries[EIso::IsoU].IsValid() && UVBoundaries[EIso::IsoV].IsValid();
    }
 
    bool IsDegenerated() const
    {
        return UVBoundaries[EIso::IsoU].IsDegenerated() || UVBoundaries[EIso::IsoV].IsDegenerated();
    }
 
    ESituation IsInside(const FSurfacicBoundary& OtherBoundary, const FSurfacicTolerance& Tolerance2D)
    {
        int32 Inside = 0;
        int32 Outside = 0;
        TFunction<void(double, double, double)> CheckInside = [&](double LeftSide, double RigthSide, double Tolerance)
        {
            if (LeftSide + Tolerance < RigthSide)
            {
                Inside++;
            }
            else if (RigthSide + Tolerance < LeftSide)
            {
                Outside++;
            }
        };
 
        CheckInside(OtherBoundary[EIso::IsoU].GetMin(), UVBoundaries[EIso::IsoU].GetMin(), Tolerance2D[EIso::IsoU]);
        CheckInside(OtherBoundary[EIso::IsoV].GetMin(), UVBoundaries[EIso::IsoV].GetMin(), Tolerance2D[EIso::IsoV]);
        CheckInside(UVBoundaries[EIso::IsoU].GetMax(), OtherBoundary[EIso::IsoU].GetMax(), Tolerance2D[EIso::IsoU]);
        CheckInside(UVBoundaries[EIso::IsoV].GetMax(), OtherBoundary[EIso::IsoV].GetMax(), Tolerance2D[EIso::IsoV]);
 
        if (Inside > 2)
        {
            return ESituation::Inside;
        }
        if (Outside > 2)
        {
            return ESituation::Outside;
        }
        return ESituation::Undefined;
    }
 
    void Init()
    {
        UVBoundaries[EIso::IsoU].Init();
        UVBoundaries[EIso::IsoV].Init();
    }
 
    void TrimAt(const FSurfacicBoundary& MaxLimit)
    {
        UVBoundaries[EIso::IsoU].TrimAt(MaxLimit[EIso::IsoU]);
        UVBoundaries[EIso::IsoV].TrimAt(MaxLimit[EIso::IsoV]);
    }
 
    void ExtendTo(const FSurfacicBoundary& MaxLimit)
    {
        UVBoundaries[EIso::IsoU].ExtendTo(MaxLimit[EIso::IsoU]);
        UVBoundaries[EIso::IsoV].ExtendTo(MaxLimit[EIso::IsoV]);
    }
 
    void ExtendTo(const FVector2d& Point)
    {
        UVBoundaries[EIso::IsoU].ExtendTo(Point.X);
        UVBoundaries[EIso::IsoV].ExtendTo(Point.Y);
    }
 
    void ExtendTo(const FVector& Point)
    {
        UVBoundaries[EIso::IsoU].ExtendTo(Point.X);
        UVBoundaries[EIso::IsoV].ExtendTo(Point.Y);
    }
 
    void RestrictTo(const FSurfacicBoundary& MaxBound)
    {
        UVBoundaries[EIso::IsoU].RestrictTo(MaxBound.UVBoundaries[EIso::IsoU]);
        UVBoundaries[EIso::IsoV].RestrictTo(MaxBound.UVBoundaries[EIso::IsoV]);
    }
 
    void WidenIfDegenerated()
    {
        UVBoundaries[EIso::IsoU].WidenIfDegenerated();
        UVBoundaries[EIso::IsoV].WidenIfDegenerated();
    }
 
    void MoveInsideIfNot(FVector& Point, const double Tolerance = DOUBLE_SMALL_NUMBER) const
    {
        UVBoundaries[EIso::IsoU].MoveInsideIfNot(Point.X, Tolerance);
        UVBoundaries[EIso::IsoV].MoveInsideIfNot(Point.Y, Tolerance);
    }
 
    void MoveInsideIfNot(FVector2d& Point, const double Tolerance = DOUBLE_SMALL_NUMBER) const
    {
        UVBoundaries[EIso::IsoU].MoveInsideIfNot(Point.X, Tolerance);
        UVBoundaries[EIso::IsoV].MoveInsideIfNot(Point.Y, Tolerance);
    }
 
    double Length(const EIso& Iso) const
    {
        return UVBoundaries[Iso].Length();
    }
 
    constexpr const FLinearBoundary& operator[](const EIso& Iso) const
    {
        return UVBoundaries[Iso];
    }
 
    constexpr FLinearBoundary& operator[](const EIso& Iso)
    {
        return UVBoundaries[Iso];
    }
 
    void Offset(const double Tolerance = DOUBLE_SMALL_NUMBER)
    {
        UVBoundaries[EIso::IsoU].Offset(Tolerance);
        UVBoundaries[EIso::IsoV].Offset(Tolerance);
    }
 
};
}