GeometrySet3.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/ParallelFor.h"
#include "BoxTypes.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Math/Ray.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Polyline3.h"
#include "Templates/Function.h"
#include "Templates/Invoke.h"
 
namespace UE
{
namespace Geometry
{
 
class FGeometrySet3
{
public:
    GEOMETRYCORE_API void Reset(bool bPoints = true, bool bCurves = true);
 
    GEOMETRYCORE_API void AddPoint(int PointID, const FVector3d& Position);
    GEOMETRYCORE_API void AddCurve(int CurveID, const FPolyline3d& Polyline);
 
    GEOMETRYCORE_API void RemovePoint(int PointID);
    GEOMETRYCORE_API void RemoveCurve(int CurveID);
 
    GEOMETRYCORE_API void UpdatePoint(int PointID, const FVector3d& Position);
    GEOMETRYCORE_API void UpdateCurve(int CurveID, const FPolyline3d& Polyline);
 
    struct FNearest
    {
        int ID;
        bool bIsPoint;
 
        FVector3d NearestRayPoint;
        FVector3d NearestGeoPoint;
 
        double RayParam;
 
        int PolySegmentIdx;
        double PolySegmentParam;
    };
 
 
    GEOMETRYCORE_API bool FindNearestPointToRay(const FRay3d& Ray, FNearest& ResultOut,
        TFunction<bool(const FVector3d&, const FVector3d&)> PointWithinToleranceTest) const;
 
    GEOMETRYCORE_API bool CollectPointsNearRay(const FRay3d& Ray, TArray<FNearest>& ResultsOut,
        TFunction<bool(const FVector3d&, const FVector3d&)> PointWithinToleranceTest) const;
 
    GEOMETRYCORE_API bool FindNearestCurveToRay(const FRay3d& Ray, FNearest& ResultOut,
        TFunction<bool(const FVector3d&, const FVector3d&)> PointWithinToleranceTest) const;
 
    GEOMETRYCORE_API bool CollectCurvesNearRay(const FRay3d& Ray, TArray<FNearest>& ResultsOut,
        TFunction<bool(const FVector3d&, const FVector3d&)> PointWithinToleranceTest) const;
 
    template <typename PredicateType, typename IntContainerType>
    bool FindAllPointsSatisfying(PredicateType Predicate, IntContainerType& PointIDsOut) const
    {
        PointIDsOut.Reset();
        for (const FPoint& Point : Points)
        {
            if (Invoke(Predicate, Point.Position))
            {
                PointIDsOut.Add(Point.ID);
            }
        }
        return !PointIDsOut.IsEmpty();
    }
 
    template <typename PredicateType, typename IntContainerType>
    bool ParallelFindAllPointsSatisfying(PredicateType Predicate, IntContainerType& PointIDsOut) const
    {
        TArray<bool> Flags;
        Flags.SetNumZeroed(Points.Num());
        ParallelFor(Points.Num(), [this, &Predicate, &Flags](int32 i)
            {
                if (Invoke(Predicate, Points[i].Position))
                {
                    Flags[i] = true;
                }
            });
 
        for (int32 i = 0; i < Points.Num(); ++i)
        {
            if (Flags[i])
            {
                PointIDsOut.Add(Points[i].ID);
            }
        }
        return !PointIDsOut.IsEmpty();
    }
 
    template <typename PredicateType, typename IntContainerType>
    bool FindAllCurvesSatisfying(PredicateType Predicate, IntContainerType& CurveIDsOut) const
    {
        CurveIDsOut.Reset();
        for (const FCurve& Curve : Curves)
        {
            if (Invoke(Predicate, Curve.Geometry))
            {
                CurveIDsOut.Add(Curve.ID);
            }
        }
        return !CurveIDsOut.IsEmpty();
    }
 
    template <typename PredicateType, typename IntContainerType>
    bool ParallelFindAllCurvesSatisfying(PredicateType Predicate, IntContainerType& CurveIDsOut) const
    {
        TArray<bool> Flags;
        Flags.SetNumZeroed(Curves.Num());
        ParallelFor(Curves.Num(), [this, &Predicate, &Flags](int32 i)
        {
            if (Invoke(Predicate, Curves[i].Geometry))
            {
                Flags[i] = true;
            }
        });
 
        for (int32 i = 0; i < Curves.Num(); ++i)
        {
            if (Flags[i])
            {
                CurveIDsOut.Add(Curves[i].ID);
            }
        }
        return !CurveIDsOut.IsEmpty();
    }
 
protected:
 
    struct FPoint
    {
        int ID;
        FVector3d Position;
    };
    TArray<FPoint> Points;
    TMap<int, int> PointIDToIndex;
 
    struct FCurve
    {
        int ID;
        FPolyline3d Geometry;
 
        FAxisAlignedBox3d Bounds;
    };
    TArray<FCurve> Curves;
    TMap<int, int> CurveIDToIndex;
 
};
 
 
} // end namespace UE::Geometry
} // end namespace UE