SlopeUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Core/Types.h"
#include "Math/Point.h"
#include "Algo/AllOf.h"
 
namespace UE::CADKernel
{
 
namespace Slope
{
 
constexpr double NullSlope = 0.;
 
constexpr double RightSlope = 2.;
constexpr double HalfPiSlope = 2.;
constexpr double NinetySlope = 2.;
 
constexpr double ThreeRightSlope = 6.;
 
constexpr double MinusRightSlope = -2.;
 
constexpr double PiSlope = 4.;
 
constexpr double TwoPiSlope = 8.;
 
constexpr double ThirdPiSlope = 1.422649730810374235490851219498;
constexpr double SixtySlope   = 1.422649730810374235490851219498;
 
constexpr double QuaterPiSlope  = 1;
constexpr double FortyFiveSlope = 0.57735026918962576450914878050196;
 
constexpr double SixthPiSlope = 0.57735026918962576450914878050196;
constexpr double ThirtySlope  = 0.57735026918962576450914878050196;
 
constexpr double ThreeQuaterPiSlope = 3;
                              
constexpr double OneDegree        = 0.01745506492821758576512889521973;
constexpr double TwoDegree        = 0.03492076949174773050040262577373;
constexpr double FiveDegree       = 0.08748866352592400522201866943496;
constexpr double TenDegree        = 0.17632698070846497347109038686862;
constexpr double FifteenDegree    = 0.26794919243112270647255365849413;
constexpr double TwentyDegree     = 0.36397023426620236135104788277683;
constexpr double TwentyFiveDegree = 0.46630765815499859283000619479956;
 
constexpr double Epsilon = 0.001;
 
}
 
typedef TFunction<double(const FVector2d&, const FVector2d&, double)> SlopeMethod;
 
inline double TransformIntoOrientedSlope(double Slope)
{
    return WrapTo(Slope, -Slope::PiSlope, Slope::PiSlope, Slope::TwoPiSlope);
}
 
inline double TransformIntoClockwiseSlope(double Slope)
{
    return Slope::TwoPiSlope - Slope;
}
 
inline double TransformIntoUnorientedSlope(double Slope)
{
    return FMath::Abs(WrapTo(Slope, -Slope::PiSlope, Slope::PiSlope, Slope::TwoPiSlope));
}
 
inline double TransformIntoPositiveSlope(double Slope)
{
    return WrapTo(Slope, Slope::NullSlope, Slope::TwoPiSlope, Slope::TwoPiSlope);
}
 
inline double TransformIntoSlopeRelativeToReferenceAxis(double Slope)
{
    Slope = TransformIntoUnorientedSlope(Slope);
 
    if (Slope > Slope::RightSlope)
    {
        Slope = Slope::PiSlope - Slope;
    }
 
    return Slope;
}
 
 
inline double SwapSlopeOrientation(double Slope)
{
    const double SwapedSlope = Slope < Slope::PiSlope ? Slope + Slope::PiSlope : Slope - Slope::PiSlope;
    return TransformIntoPositiveSlope(SwapedSlope);
}
 
inline double ComputeSlope(const FVector2d& StartPoint, const FVector2d& EndPoint)
{
    double DeltaU = EndPoint.X - StartPoint.X;
    double DeltaV = EndPoint.Y - StartPoint.Y;
    double Delta;
 
    if (FMath::Abs(DeltaU) < DOUBLE_SMALL_NUMBER && FMath::Abs(DeltaV) < DOUBLE_SMALL_NUMBER)
    {
        return 0;
    }
 
    if (DeltaU > DOUBLE_SMALL_NUMBER)
    {
        if (DeltaV > DOUBLE_SMALL_NUMBER)
        {
            if (DeltaU > DeltaV)
            {
                Delta = DeltaV / DeltaU;
            }
            else
            {
                Delta = 2. - DeltaU / DeltaV;
            }
        }
        else
        {
            if (DeltaU > -DeltaV)
            {
                Delta = 8. + DeltaV / DeltaU;
            }
            else if (fabs(DeltaV) > DOUBLE_SMALL_NUMBER)
            {
                Delta = 6. - DeltaU / DeltaV; // deltaU/deltaV <0
            }
            else
            {
                Delta = 8.;
            }
        }
    }
    else if (-DeltaU > DOUBLE_SMALL_NUMBER)
    {
        if (DeltaV > DOUBLE_SMALL_NUMBER)
        {
            if (-DeltaU > DeltaV)
            {
                Delta = 4. + DeltaV / DeltaU;
            }
            else
            {
                Delta = 2. - DeltaU / DeltaV;
            }
        }
        else
        {
            if (-DeltaU > -DeltaV)
            {
                Delta = 4. + DeltaV / DeltaU;
            }
            else if (fabs(DeltaV) > DOUBLE_SMALL_NUMBER)
            {
                Delta = 6. - DeltaU / DeltaV;
            }
            else
            {
                Delta = 4.;
            }
        }
    }
    else
    {
        if (DeltaV > 0)
        {
            Delta = 2.;
        }
        else
        {
            Delta = 6.;
        }
    }
 
    return Delta;
}
 
inline double ComputeSlope(const FVector2d& StartPoint, const FVector2d& EndPoint, double ReferenceSlope)
{
    const double Slope = ComputeSlope(StartPoint, EndPoint);
    return Slope - ReferenceSlope;
}
 
inline double ComputeSlope(const FVector2d& StartPoint, const FVector2d& EndPoint1, const FVector2d& EndPoint2)
{
    const double ReferenceSlope = ComputeSlope(StartPoint, EndPoint1);
    const double Slope = ComputeSlope(StartPoint, EndPoint2);
    return Slope - ReferenceSlope;
}
 
inline double ComputePositiveSlope(const FVector2d& StartPoint, const FVector2d& EndPoint, double ReferenceSlope)
{
    double Slope = ComputeSlope(StartPoint, EndPoint, ReferenceSlope);
    return TransformIntoPositiveSlope(Slope);
}
 
inline double ComputePositiveSlope(const FVector2d& StartPoint, const FVector2d& EndPoint1, const FVector2d& EndPoint2)
{
    double Slope = ComputeSlope(StartPoint, EndPoint1, EndPoint2);
    return TransformIntoPositiveSlope(Slope);
}
 
inline double ClockwiseSlope(const FVector2d& StartPoint, const FVector2d& EndPoint, double ReferenceSlope)
{
    return TransformIntoClockwiseSlope(ComputePositiveSlope(StartPoint, EndPoint, ReferenceSlope));
}
 
inline double CounterClockwiseSlope(const FVector2d& StartPoint, const FVector2d& EndPoint, double ReferenceSlope)
{
    return ComputePositiveSlope(StartPoint, EndPoint, ReferenceSlope);
}
 
inline double ComputeOrientedSlope(const FVector2d& StartPoint, const FVector2d& EndPoint, double ReferenceSlope)
{
    return TransformIntoOrientedSlope(ComputeSlope(StartPoint, EndPoint, ReferenceSlope));
}
 
inline double ComputeOrientedSlope(const FVector2d& StartPoint, const FVector2d& EndPoint1, const FVector2d& EndPoint2)
{
    return TransformIntoOrientedSlope(ComputeSlope(StartPoint, EndPoint1, EndPoint2));
}
 
inline double ComputeUnorientedSlope(const FVector2d& StartPoint, const FVector2d& EndPoint, double ReferenceSlope)
{
    const double Slope = ComputeSlope(StartPoint, EndPoint, ReferenceSlope);
    return TransformIntoUnorientedSlope(Slope);
}
 
inline double ComputeSlopeRelativeToNearestAxis(const FVector2d& StartPoint, const FVector2d& EndPoint)
{
    double Slope = TransformIntoUnorientedSlope(ComputeSlope(StartPoint, EndPoint));
    if (Slope > Slope::RightSlope)
    {
        Slope = Slope::PiSlope - Slope;
    }
 
    // if slope close to 2 means segment close to IsoU, otherwise segment close to IsoV
    // Wants a slope between 0 and 1 to manage either IsoU and IsoV
    // Close to 0 means close to IsoU or IsoV
    if (Slope > Slope::QuaterPiSlope)
    {
        Slope = Slope::RightSlope - Slope;
    }
 
    return Slope;
}
 
inline double ComputeSlopeRelativeToReferenceAxis(const FVector2d& StartPoint, const FVector2d& EndPoint, double ReferenceAxisSlope)
{
    const double Slope = ComputeSlope(StartPoint, EndPoint, ReferenceAxisSlope);
    return TransformIntoSlopeRelativeToReferenceAxis(Slope);
}
 
inline double ComputeUnorientedSlope(const FVector2d& StartPoint, const FVector2d& EndPoint1, const FVector2d& EndPoint2)
{
    return TransformIntoUnorientedSlope(ComputeSlope(StartPoint, EndPoint1, EndPoint2));
}
 
inline bool IsPointPInsideSectorABC(const FVector2d& PointA, const FVector2d& PointB, const FVector2d& PointC, const FVector2d& PointP, const double FlatAngle)
{
    double SlopWithNextBoundary = ComputeSlope(PointB, PointC);
    double BoundaryDeltaSlope = ComputePositiveSlope(PointB, PointA, SlopWithNextBoundary);
    double SegmentSlope = ComputePositiveSlope(PointB, PointP, SlopWithNextBoundary);
    if (SegmentSlope < FlatAngle || SegmentSlope + FlatAngle > BoundaryDeltaSlope)
    {
        return false;
    }
    return true;
}
 
inline bool ArePointsInsideSectorABC(const FVector2d& PointA, const FVector2d& PointB, const FVector2d& PointC, const TArray<const FVector2d*>& Points, const double FlatAngle = -DOUBLE_SMALL_NUMBER)
{
    double SlopWithNextBoundary = ComputeSlope(PointB, PointC);
    double BoundaryDeltaSlope = ComputePositiveSlope(PointB, PointA, SlopWithNextBoundary);
 
    return Algo::AllOf(Points, [&](const FVector2d* PointP) 
    {
        double DeltaU = PointB.X - PointP->X;
        double DeltaV = PointB.Y - PointP->Y;
 
        if (FMath::Abs(DeltaU) < DOUBLE_SMALL_NUMBER && FMath::Abs(DeltaV) < DOUBLE_SMALL_NUMBER)
        {
            return true;
        }
 
        double SegmentSlope = ComputePositiveSlope(PointB, *PointP, SlopWithNextBoundary);
        if (SegmentSlope < FlatAngle || SegmentSlope + FlatAngle > BoundaryDeltaSlope)
        {
            return false;
        }
        return true;
    });
}
 
inline FVector2d SlopeToVector(const double Slope)
{
    int32 SlopeStep = (int32)(Slope);
    FVector2d Vector = FVector2d::ZeroVector;
    switch (SlopeStep)
    {
    case 0:
        // Delta = DeltaV / DeltaU;
        Vector[0] = 1.;
        Vector[1] = Slope;
        break;
    case 1:
        // 2 - DeltaU / DeltaV;
        Vector[0] = 2. - Slope;
        Vector[1] = 1.;
        break;
    case 2:
        // 2 - DeltaU / DeltaV;
        Vector[0] = 2. - Slope;
        Vector[1] = 1.;
        break;
    case 3:
        // 4 + DeltaV / DeltaU;
        Vector[0] = -1.;
        Vector[1] = 4. - Slope;
        break;
    case 4:
        // 4 + DeltaV / DeltaU;
        Vector[0] = -1.;
        Vector[1] = 4. - Slope;
        break;
    case 5:
        // 6 - DeltaU / DeltaV;
        Vector[0] = Slope - 6.;
        Vector[1] = -1.;
        break;
    case 6:
        // 6 - DeltaU / DeltaV // deltaU/deltaV <0
        Vector[0] = Slope - 6.;
        Vector[1] = -1.;
        break;
    case 7:
        // 8 + DeltaV / DeltaU; // deltaU/deltaV <0
        Vector[0] = 1.;
        Vector[1] = Slope - 8.;
        break;
    default:
        break;
    }
 
    return Vector;
}
 
} // namespace UE::CADKernel