MRDistanceMap.h

Go to the documentation of this file.

#pragma once
 
#include "MRRectIndexer.h"
#include "MRBitSet.h"
#include "MRAffineXf3.h"
#include "MRDistanceMapParams.h"
#include "MRPolyline.h"
#include "MRHeapBytes.h"
#include "MRImage.h"
#include "MRExpected.h"
#include <cfloat>
#include <filesystem>
#include <vector>
 
namespace MR
{
 
 
class [[nodiscard]] DistanceMap : public RectIndexer
{
public:
    DistanceMap() = default;
 
    [[nodiscard]] MRMESH_API DistanceMap( size_t resX, size_t resY );
 
    [[nodiscard]] MRMESH_API DistanceMap( const MR::Matrix<float>& m );
 
    [[nodiscard]] MRMESH_API bool isValid( size_t x, size_t y ) const;
    [[nodiscard]] MRMESH_API bool isValid( size_t i ) const;
 
    [[nodiscard]] bool isInBounds( size_t x, size_t y ) const { return x < size_t( dims_.x ) && y < size_t( dims_.y ); }
    [[nodiscard]] bool isInBounds( size_t i ) const { return i < size_; }
 
    [[nodiscard]] MRMESH_API std::optional<float> get( size_t x, size_t y ) const;
    [[nodiscard]] MRMESH_API std::optional<float> get( size_t i ) const;
    [[nodiscard]] float& getValue( size_t x, size_t y )
    {
        return data_[toIndex( { int( x ), int( y ) } )];
    }
    [[nodiscard]] float  getValue( size_t x, size_t y ) const
    {
        return data_[toIndex( { int( x ), int( y ) } )];
    }
    [[nodiscard]] float& getValue( size_t i )
    {
        return data_[i];
    }
    [[nodiscard]] float  getValue( size_t i ) const
    {
        return data_[i];
    }
 
    float* data() { return data_.data(); }
    const float* data() const { return data_.data(); }
 
    [[nodiscard]] MRMESH_API std::optional<float> getInterpolated( float x, float y ) const;
 
    [[nodiscard]] MRMESH_API std::optional<Vector3f> unproject( size_t x, size_t y, const AffineXf3f& toWorld ) const;
 
    [[nodiscard]] MRMESH_API std::optional<Vector3f> unprojectInterpolated( float x, float y, const AffineXf3f& toWorld ) const;
 
    MRMESH_API void negate();
 
    [[nodiscard]] MRMESH_API DistanceMap max( const DistanceMap& rhs ) const;
    MRMESH_API const DistanceMap& mergeMax( const DistanceMap& rhs );
    [[nodiscard]] MRMESH_API DistanceMap min( const DistanceMap& rhs ) const;
    MRMESH_API const DistanceMap& mergeMin( const DistanceMap& rhs );
    [[nodiscard]] MRMESH_API DistanceMap operator- ( const DistanceMap& rhs ) const;
    MRMESH_API const DistanceMap& operator-= ( const DistanceMap& rhs );
 
    MRMESH_API void set( size_t x, size_t y, float val );
    MRMESH_API void set( size_t i, float val );
    MRMESH_API void set( std::vector<float> data );
    MRMESH_API void unset( size_t x, size_t y );
    MRMESH_API void unset( size_t i );
 
    MRMESH_API void invalidateAll();
    MRMESH_API void clear();
 
    [[nodiscard]] MRMESH_API DistanceMap getDerivativeMap() const;
    [[nodiscard]] MRMESH_API std::pair< DistanceMap, DistanceMap > getXYDerivativeMaps() const;
 
    [[nodiscard]] MRMESH_API std::vector< std::pair<size_t, size_t> > getLocalMaximums() const;
 
    [[nodiscard]] size_t resX() const
    {
        return dims_.x;
    }
    [[nodiscard]] size_t resY() const
    {
        return dims_.y;
    }
 
    [[nodiscard]] size_t numPoints() const
    {
        return size();
    }
 
    [[nodiscard]] MRMESH_API std::pair<float, float> getMinMaxValues() const;
    [[nodiscard]] MRMESH_API std::pair<size_t, size_t> getMinIndex() const;
    [[nodiscard]] MRMESH_API std::pair<size_t, size_t> getMaxIndex() const;
 
    [[nodiscard]] size_t heapBytes() const
    {
        return MR::heapBytes( data_ );
    }
 
private:
    std::vector<float> data_;
};
 
MRMESH_API DistanceMap combineXYderivativeMaps( std::pair<DistanceMap, DistanceMap> XYderivativeMaps );
 
MRMESH_API DistanceMap computeDistanceMap( const MeshPart& mp, const MeshToDistanceMapParams& params,
    ProgressCallback cb = {}, std::vector<MeshTriPoint> * outSamples = nullptr );
 
MRMESH_API DistanceMap computeDistanceMapD( const MeshPart& mp, const MeshToDistanceMapParams& params,
    ProgressCallback cb = {}, std::vector<MeshTriPoint> * outSamples = nullptr );
 
struct [[nodiscard]] ContoursDistanceMapOffset
{
    const Vector<float, UndirectedEdgeId>& perEdgeOffset;
    enum class OffsetType
    {
        Normal, 
        Shell   
    } type{ OffsetType::Shell };
};
 
struct [[nodiscard]] ContoursDistanceMapOptions
{
    enum SignedDetectionMethod
    {
        ContourOrientation,
        WindingRule
    } signMethod{ ContourOrientation };
    const ContoursDistanceMapOffset* offsetParameters{ nullptr };
    const PixelBitSet* region{ nullptr };
    std::vector<UndirectedEdgeId>* outClosestEdges{ nullptr };
    float minDist{ 0 };
    float maxDist{ FLT_MAX };
};
 
[[nodiscard]] MRMESH_API DistanceMap distanceMapFromContours( const Polyline2& contours, const ContourToDistanceMapParams& params,
    const ContoursDistanceMapOptions& options = {} );
 
MRMESH_API void distanceMapFromContours( DistanceMap & distMap, const Polyline2& polyline, const ContourToDistanceMapParams& params,
    const ContoursDistanceMapOptions& options = {} );
 
[[nodiscard]] MRMESH_API std::vector<Vector3f> edgePointsFromContours( const Polyline2& polyline, float pixelSize, float threshold );
 
[[nodiscard]] MRMESH_API Polyline2 distanceMapTo2DIsoPolyline( const DistanceMap& distMap, float isoValue );
 
[[nodiscard]] MRMESH_API Polyline2 distanceMapTo2DIsoPolyline( const DistanceMap& distMap,
    const ContourToDistanceMapParams& params, float isoValue );
 
[[nodiscard]] MRMESH_API std::pair<Polyline2, AffineXf3f> distanceMapTo2DIsoPolyline( const DistanceMap& distMap,
    const AffineXf3f& xf, float isoValue, bool useDepth = false );
[[nodiscard]] MRMESH_API Polyline2 distanceMapTo2DIsoPolyline( const DistanceMap& distMap, float pixelSize, float isoValue );
 
[[nodiscard]] MRMESH_API Polyline2 polylineOffset( const Polyline2& polyline, float pixelSize, float offset );
 
[[nodiscard]] MRMESH_API Polyline2 contourUnion( const Polyline2& contoursA, const Polyline2& contoursB,
    const ContourToDistanceMapParams& params, float offsetInside = 0 );
 
[[nodiscard]] MRMESH_API Polyline2 contourIntersection( const Polyline2& contoursA, const Polyline2& contoursB,
    const ContourToDistanceMapParams& params, float offsetInside = 0.f );
 
[[nodiscard]] MRMESH_API Polyline2 contourSubtract( const Polyline2& contoursA, const Polyline2& contoursB,
    const ContourToDistanceMapParams& params, float offsetInside = 0.f );
 
[[nodiscard]] MRMESH_API Expected<Mesh> distanceMapToMesh( const DistanceMap& distMap, const AffineXf3f& toWorld, ProgressCallback cb = {} );
 
[[nodiscard]] MRMESH_API Image convertDistanceMapToImage( const DistanceMap& distMap, float threshold = 1.f / 255 );
 
[[deprecated( "convert to an image and save it explicitly" )]]
MRMESH_API VoidOrErrStr saveDistanceMapToImage( const DistanceMap& distMap, const std::filesystem::path& filename, float threshold = 1.f / 255 );
 
[[nodiscard]] MRMESH_API Expected<DistanceMap> convertImageToDistanceMap( const Image& image, float threshold = 1.f / 255 );
 
[[deprecated( "load an image and convert from it explicitly" )]]
[[nodiscard]] MRMESH_API Expected<DistanceMap> loadDistanceMapFromImage( const std::filesystem::path& filename, float threshold = 1.f / 255 );
 
 
} // namespace MR