MRMoveMeshToVoxelMaxDeriv.h

Go to the documentation of this file.

#pragma once
 
#include "MRVoxelsFwd.h"
 
#include "MRVoxelsVolumeAccess.h"
#include "MRVolumeInterpolation.h"
#include "MRMesh/MRMatrix3.h"
#include "MRMesh/MRAffineXf.h"
#include "MRMesh/MRBestFitParabola.h"
#include "MRMesh/MRBestFitPolynomial.h"
 
 
namespace MR
{
 
struct MoveMeshToVoxelMaxDerivSettings
{
    int iters = 30;
 
    int samplePoints = 6;
 
    int degree = 3;
 
    float outlierThreshold = 1.f;
 
    float intermediateSmoothForce = 0.3f;
 
    float preparationSmoothForce = 0.1f;
};
 
 
template <typename VolumeType = VdbVolume>
MRVOXELS_API Expected<VertBitSet> moveMeshToVoxelMaxDeriv(
        Mesh& mesh, const AffineXf3f& meshXf,
        const VolumeType& volume, const AffineXf3f& volumeXf,
        const MoveMeshToVoxelMaxDerivSettings& settings,
        ProgressCallback callback = {}
);
 
extern template MRVOXELS_API Expected<VertBitSet> moveMeshToVoxelMaxDeriv<VdbVolume>( Mesh& mesh, const AffineXf3f& meshXf,
    const VdbVolume& volume, const AffineXf3f& volumeXf,
    const MoveMeshToVoxelMaxDerivSettings& settings,
    ProgressCallback callback );
extern template MRVOXELS_API Expected<VertBitSet> moveMeshToVoxelMaxDeriv<SimpleVolumeMinMax>( Mesh& mesh, const AffineXf3f& meshXf,
    const SimpleVolumeMinMax& volume, const AffineXf3f& volumeXf,
    const MoveMeshToVoxelMaxDerivSettings& settings,
    ProgressCallback callback );
extern template MRVOXELS_API Expected<VertBitSet> moveMeshToVoxelMaxDeriv<FunctionVolume>( Mesh& mesh, const AffineXf3f& meshXf,
    const FunctionVolume& volume, const AffineXf3f& volumeXf,
    const MoveMeshToVoxelMaxDerivSettings& settings,
    ProgressCallback callback );
 
 
template <typename MeshType, typename VolumeType>
class MRVOXELS_CLASS MeshOnVoxelsT
{
public:
    MRVOXELS_API MeshOnVoxelsT( MeshType& mesh, const AffineXf3f& meshXf, const VolumeType& volume, const AffineXf3f& volumeXf );
    MRVOXELS_API MeshOnVoxelsT( const MeshOnVoxelsT& other );
 
    MRVOXELS_API MeshType& mesh() const;
 
    MRVOXELS_API const VolumeType& volume() const;
 
 
    MRVOXELS_API int numVerts() const;
 
    MRVOXELS_API float voxelSize() const;
 
 
    MRVOXELS_API AffineXf3f xf() const;
 
    MRVOXELS_API Vector3f xf( const Vector3f& pt ) const;
 
    MRVOXELS_API AffineXf3f xfInv() const;
 
    MRVOXELS_API Vector3f xfInv( const Vector3f &pt ) const;
 
 
    MRVOXELS_API Vector3f point( VertId v ) const;
 
    MRVOXELS_API float getValue( const Vector3f& pos ) const;
 
    MRVOXELS_API Vector3f getOffsetVector( VertId v ) const;
 
    MRVOXELS_API static float pseudoIndex( float index, int count );
 
    MRVOXELS_API static float pseudoIndex( int index, int count );
 
    MRVOXELS_API static float indexFromPseudoIndex( float pseudoIndex, int count );
 
    MRVOXELS_API void getPoints( std::vector<Vector3f>& result, const Vector3f& pos, const Vector3f& offset ) const;
 
    MRVOXELS_API void getValues( std::vector<float>& result, const Vector3f& pos, const Vector3f& offset ) const;
 
    MRVOXELS_API static void getDerivatives( std::vector<float>& result, const std::vector<float>& values );
 
    static Parabolaf getBestParabola( auto begin, auto end )
    {
        BestFitParabola<float> bestFitParabola;
        auto size = std::distance( begin, end );
        for ( auto it = begin; it != end; ++it )
            bestFitParabola.addPoint( pseudoIndex( int( it - begin ), int( size ) ), *it );
        return bestFitParabola.getBestParabola();
    }
 
    template <size_t degree>
    static Polynomialf<degree> getBestPolynomial( const std::vector<float>& values )
    {
        BestFitPolynomial<double, degree> bestFit( 0.f );
        for ( size_t i = 0; i < values.size(); ++i )
            bestFit.addPoint( pseudoIndex( int( i ), int( values.size() ) ), values[i] );
        auto poly = bestFit.getBestPolynomial().template cast<float>();
        return poly;
    }
 
    MRVOXELS_API static PolynomialWrapperf getBestPolynomial( const std::vector<float>& values, size_t degree );
 
private:
    MeshType& mesh_;
    const VolumeType& volume_;
    float voxelSize_;
    VoxelsVolumeAccessor<VolumeType> accessor_;
    VoxelsVolumeInterpolatedAccessor<VoxelsVolumeAccessor<VolumeType>> interpolator_;
    AffineXf3f xf_, xfInv_;
    Matrix3f xfNormal_;
    bool noXf_; 
    int numVerts_;
};
 
 
using MeshOnVoxelsVdb = MeshOnVoxelsT<Mesh, VdbVolume>;
using MeshOnVoxelsVdbC = MeshOnVoxelsT<const Mesh, VdbVolume>;
 
using MeshOnVoxelsSimple = MeshOnVoxelsT<Mesh, SimpleVolumeMinMax>;
using MeshOnVoxelsSimpleC = MeshOnVoxelsT<const Mesh, SimpleVolumeMinMax>;
 
using MeshOnVoxelsFunction = MeshOnVoxelsT<Mesh, FunctionVolume>;
using MeshOnVoxelsFunctionC = MeshOnVoxelsT<const Mesh, FunctionVolume>;
}