MRPointCloudTriangulationHelpers.h

Go to the documentation of this file.

#pragma once
 
#include "MRPch/MRBindingMacros.h"
#include "MRVector.h"
#include "MRId.h"
#include "MRConstants.h"
#include "MRBuffer.h"
#include "MRPointsProject.h"
#include "MRFewSmallest.h"
#include <climits>
#include <optional>
#include <queue>
 
namespace MR
{
namespace TriangulationHelpers
{
 
MRMESH_API float updateNeighborsRadius( const VertCoords& points, VertId v, VertId boundaryV,
    const std::vector<VertId>& fan, float baseRadius );
 
MRMESH_API void findNeighborsInBall( const PointCloud& pointCloud, VertId v, float radius, std::vector<VertId>& neighbors );
 
MRMESH_API float findNumNeighbors( const PointCloud& pointCloud, VertId v, int numNeis, std::vector<VertId>& neighbors,
    FewSmallest<PointsProjectionResult> & tmp, float upDistLimitSq = FLT_MAX );
 
MRMESH_API void filterNeighbors( const VertNormals& orientedNormals, const VertBitSet* untrustedNormals, VertId v, std::vector<VertId>& neighbors );
 
struct FanOptimizerQueueElement
{
    float weight{ 0.0f }; // profit of flipping this edge
    int id{ -1 }; // index
 
    // needed to remove outdated queue elements
    int prevId{ -1 }; // id of prev neighbor
    int nextId{ -1 }; // id of next neighbor
 
    bool stable{ false }; // if this flag is true, edge cannot be flipped
    bool operator < ( const FanOptimizerQueueElement& other ) const
    {
        if ( stable == other.stable )
            return weight < other.weight;
        return stable;
    }
    bool operator==( const FanOptimizerQueueElement& other ) const = default;
 
    bool isOutdated( const std::vector<VertId>& neighbors ) const
    {
        return !neighbors[nextId].valid() || !neighbors[prevId].valid();
    }
};
 
struct TriangulatedFanData
{
    std::vector<VertId> neighbors;
 
    std::vector<std::pair<double, int>> cacheAngleOrder;
 
    VertId border;
 
    FewSmallest<PointsProjectionResult> nearesetPoints;
 
    MR_BIND_IGNORE std::priority_queue<FanOptimizerQueueElement> queue;
};
 
struct Settings
{
    float radius = 0;
 
    int numNeis = 0;
 
    float critAngle = PI2_F;
 
    float boundaryAngle = 0.9f * PI_F;
 
    const VertNormals* orientedNormals = nullptr;
    const VertBitSet* untrustedNormals = nullptr;
 
    bool automaticRadiusIncrease = true;
 
    int maxRemoves = INT_MAX;
 
    std::vector<VertId> * allNeighbors = nullptr;
 
    float * actualRadius = nullptr;
 
    const PointCloud * searchNeighbors = nullptr;
};
 
MRMESH_API void buildLocalTriangulation( const PointCloud& cloud, VertId v, const Settings & settings,
    TriangulatedFanData & fanData );
 
[[nodiscard]] MRMESH_API std::optional<std::vector<SomeLocalTriangulations>> buildLocalTriangulations(
    const PointCloud& cloud, const Settings & settings, const ProgressCallback & progress = {} );
 
[[nodiscard]] MRMESH_API std::optional<AllLocalTriangulations> buildUnitedLocalTriangulations(
    const PointCloud& cloud, const Settings & settings, const ProgressCallback & progress = {} );
 
[[nodiscard]] MRMESH_API bool isBoundaryPoint( const PointCloud& cloud, VertId v, const Settings & settings,
    TriangulatedFanData & fanData );
 
[[nodiscard]] MRMESH_API std::optional<VertBitSet> findBoundaryPoints( const PointCloud& pointCloud, const Settings & settings,
    ProgressCallback cb = {} );
 
 
} //namespace TriangulationHelpers
 
} //namespace MR