MRMeshOrPoints.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshPart.h"
#include "MRPointCloudPart.h"
#include "MRAffineXf3.h"
#include "MRId.h"
#include <cfloat>
#include <functional>
#include <optional>
#include <variant>
 
namespace MR
{
 
class MeshOrPoints
{
public:
    MeshOrPoints( const MeshPart & mp ) : var_( mp ) { }
    MeshOrPoints( const PointCloudPart & pcp ) : var_( pcp ) { }
 
    // these constructors are redundant for C++, but important for python bindings
    MeshOrPoints( const Mesh & mesh ) : var_( MeshPart( mesh ) ) { }
    MeshOrPoints( const PointCloud & pc ) : var_( PointCloudPart( pc ) ) { }
 
    [[nodiscard]] const MeshPart* asMeshPart() const;
 
    [[nodiscard]] const PointCloudPart* asPointCloudPart() const;
 
    [[nodiscard]] MRMESH_API Box3f getObjBoundingBox() const;
 
    MRMESH_API void cacheAABBTree() const;
 
    [[nodiscard]] MRMESH_API Box3f computeBoundingBox( const AffineXf3f * toWorld = nullptr ) const;
 
    MRMESH_API void accumulate( PointAccumulator& accum, const AffineXf3f* xf = nullptr ) const;
 
    [[nodiscard]] MRMESH_API std::optional<VertBitSet> pointsGridSampling( float voxelSize, size_t maxVoxels = 500000,
        const ProgressCallback & cb = {} ) const;
 
    [[nodiscard]] MRMESH_API const VertCoords & points() const;
 
    [[nodiscard]] MRMESH_API const VertBitSet& validPoints() const;
 
    [[nodiscard]] MRMESH_API std::function<Vector3f(VertId)> normals() const;
 
    [[nodiscard]] MRMESH_API std::function<float(VertId)> weights() const;
 
    struct ProjectionResult
    {
        Vector3f point;
 
        std::optional<Vector3f> normal;
 
        bool isBd = false;
 
        float distSq = FLT_MAX;
 
        VertId closestVert;
 
        [[nodiscard]] explicit operator bool() const { return valid(); }
        [[nodiscard]] bool valid() const { return distSq < FLT_MAX; }
    };
 
    [[nodiscard]] MRMESH_API std::function<ProjectionResult( const Vector3f & )> projector() const;
 
    using LimitedProjectorFunc = std::function<bool( const Vector3f& p, ProjectionResult& res )>;
    [[nodiscard]] MRMESH_API LimitedProjectorFunc limitedProjector() const;
 
private:
    std::variant<MeshPart, PointCloudPart> var_;
};
 
struct MeshOrPointsXf
{
    MeshOrPoints obj;
    AffineXf3f xf;
 
    [[nodiscard]] MRMESH_API std::function<MeshOrPoints::ProjectionResult( const Vector3f& )> projector() const;
 
    [[nodiscard]] MRMESH_API MeshOrPoints::LimitedProjectorFunc limitedProjector() const;
};
 
[[nodiscard]] MRMESH_API std::optional<MeshOrPoints> getMeshOrPoints( const Object * obj );
[[nodiscard]] MRMESH_API std::optional<MeshOrPointsXf> getMeshOrPointsXf( const Object * obj );
 
using ProjectOnAllCallback = std::function<void( ObjId, MeshOrPoints::ProjectionResult )>;
 
MRMESH_API void projectOnAll(
    const Vector3f& pt, 
    const AABBTreeObjects & tree, 
    float upDistLimitSq, 
    const ProjectOnAllCallback & callback, 
    ObjId skipObjId = {} ); 
 
[[nodiscard]] inline MeshOrPoints::ProjectionResult projectWorldPointOntoObject( const Vector3f& p, const Object& obj )
{
    auto mop = getMeshOrPointsXf( &obj );
    if ( !mop )
        return {};
    return mop->projector()( p );
}
 
[[nodiscard]] MRMESH_API MeshOrPoints::ProjectionResult projectWorldPointOntoObjectsRecursive(
    const Vector3f& p,
    const Object* root = nullptr,
    std::function<bool( const Object& )> projectPred = nullptr,
    std::function<bool( const Object& )> recursePred = nullptr
);
 
inline const MeshPart* MeshOrPoints::asMeshPart() const
{
    return std::visit( overloaded{
        []( const MeshPart & mp ) { return &mp; },
        []( const PointCloudPart & ) { return (const MeshPart*)nullptr; }
    }, var_ );
}
 
inline const PointCloudPart* MeshOrPoints::asPointCloudPart() const
{
    return std::visit( overloaded{
        []( const MeshPart & ) { return (const PointCloudPart *)nullptr; },
        []( const PointCloudPart & pcp ) { return &pcp; }
    }, var_ );
}
 
} // namespace MR