MRDistanceMapParams.h

Go to the documentation of this file.

#pragma once
 
#include "MRMatrix.h"
#include "MRBitSet.h"
#include "MRAffineXf3.h"
#include "MRVector2.h"
#include "MRBox.h"
#include "MRMeshPart.h"
 
namespace MR
{
 
 
struct MeshToDistanceMapParams
{
    MeshToDistanceMapParams() = default;
 
    MRMESH_API MeshToDistanceMapParams( const Vector3f& direction, const Vector2i& resolution, const MeshPart& mp, bool usePreciseBoundingBox = false );
    MRMESH_API MeshToDistanceMapParams( const Vector3f& direction, const Vector2f& pixelSize, const MeshPart& mp, bool usePreciseBoundingBox = false );
 
    MRMESH_API MeshToDistanceMapParams( const Matrix3f& rotation, const Vector3f& origin, const Vector2i& resolution, const Vector2f& size );
    MRMESH_API MeshToDistanceMapParams( const Matrix3f& rotation, const Vector3f& origin, const Vector2f& pixelSize, const Vector2i& resolution );
 
    MRMESH_API MeshToDistanceMapParams( const Matrix3f& rotation, const Vector2i& resolution, const MeshPart& mp, bool usePreciseBoundingBox = false );
 
    MRMESH_API MeshToDistanceMapParams( const AffineXf3f& xf, const Vector2i& resolution, const Vector2f& size );
    MRMESH_API MeshToDistanceMapParams( const AffineXf3f& xf, const Vector2f& pixelSize, const Vector2i& resolution );
 
    operator AffineXf3f() const
    {
        return { Matrix3f::fromColumns( xRange / float( resolution.x ), yRange / float( resolution.y ), direction ), orgPoint };
    }
    AffineXf3f xf() const { return operator AffineXf3f(); }
 
    Vector3f xRange = Vector3f( 1.f, 0.f, 0.f ); 
    Vector3f yRange = Vector3f( 0.f, 1.f, 0.f ); 
    Vector3f direction = Vector3f( 0.f, 0.f, 1.f ); 
    Vector3f orgPoint = Vector3f( 0.f, 0.f, 0.f ); 
 
    void setDistanceLimits( float min, float max )
    {
        useDistanceLimits = true;
        minValue = min;
        maxValue = max;
    }
    bool useDistanceLimits = false; 
    bool allowNegativeValues = false; 
    float minValue = 0.f; 
    float maxValue = 0.f; 
 
    Vector2i resolution; 
 
private:
    std::pair<Vector3f,Vector2f> orgSizeFromMeshPart_( const Matrix3f& rotation, const MeshPart& mp, bool presiceBox ) const;
    void initFromSize_( const AffineXf3f& worldOrientation, const Vector2i& resolution, const Vector2f& size );
};
 
struct DistanceMapToWorld;
 
struct ContourToDistanceMapParams
{
    ContourToDistanceMapParams() = default;
 
    MRMESH_API ContourToDistanceMapParams( const Vector2i& resolution, const Vector2f& oriPoint,
        const Vector2f& areaSize, bool withSign = false );
 
    MRMESH_API ContourToDistanceMapParams( const Vector2i& resolution, const Box2f& box, bool withSign = false );
 
    MRMESH_API ContourToDistanceMapParams( const Vector2i& resolution, const Contours2f& contours,
        float offset, bool withSign = false );
 
    MRMESH_API ContourToDistanceMapParams( float pixelSize, const Contours2f& contours,
        float offset, bool withSign = false );
 
    MRMESH_API explicit ContourToDistanceMapParams( const DistanceMapToWorld& toWorld );
    Vector2f toWorld( Vector2f point ) const
    {
        return orgPoint + Vector2f{ pixelSize.x * point.x, pixelSize.y * point.y };
    }
 
    operator AffineXf3f() const
    {
        return { Matrix3f::fromColumns( pixelSize.x * Vector3f::plusX(), pixelSize.y * Vector3f::plusY(), Vector3f::plusZ() ), { orgPoint.x, orgPoint.y, 0.F } };
    }
    AffineXf3f xf() const { return operator AffineXf3f(); }
 
    Vector2f pixelSize{ 1.F, 1.F }; 
    Vector2i resolution{ 1, 1 }; 
    Vector2f orgPoint{ 0.F, 0.F }; 
    bool withSign{ false }; 
};
 
struct DistanceMapToWorld
{
    DistanceMapToWorld() = default;
 
    MRMESH_API DistanceMapToWorld( const MeshToDistanceMapParams& params );
 
    MRMESH_API DistanceMapToWorld( const ContourToDistanceMapParams& params );
 
    DistanceMapToWorld( const AffineXf3f & xf )
        : orgPoint( xf.b )
        , pixelXVec( xf.A.col( 0 ) )
        , pixelYVec( xf.A.col( 1 ) )
        , direction( xf.A.col( 2 ) )
    {
    }
    
 
    Vector3f toWorld( float x, float y, float depth ) const
    {
        return orgPoint + x * pixelXVec + y * pixelYVec + depth * direction;
    }
 
    operator AffineXf3f() const
    {
        return { Matrix3f::fromColumns( pixelXVec, pixelYVec, direction ), orgPoint };
    }
    AffineXf3f xf() const { return operator AffineXf3f(); }
 
    Vector3f orgPoint;
    Vector3f pixelXVec{ Vector3f::plusX() };
    Vector3f pixelYVec{ Vector3f::plusY() };
    Vector3f direction{ Vector3f::plusZ() };
};
 
struct DistanceMapLoadSettings
{
    DistanceMapToWorld* distanceMapToWorld = nullptr;
    ProgressCallback progress;
};
 
struct DistanceMapSaveSettings
{
    const AffineXf3f* xf = nullptr;
    ProgressCallback progress;
};
 
 
} // namespace MR