Method convertObject

source/MRVoxels/MRTeethMaskToDirectionVolume.cpp:104–176

}

Expected<TeethMaskToDirectionVolumeConvertor::ProcessResult> TeethMaskToDirectionVolumeConvertor::convertObject( int id ) const
{
    Box3i box;

    if ( auto it = presentObjects_.find( id ); it == presentObjects_.end() )
        return unexpected( fmt::format( "The mask does not contain specified object: {}", id ) );
    else
        box = it->second;


    const VolumeIndexer maskIndexer( mask_.dims );

    SimpleVolumeMinMax toothMask;
    toothMask.dims = box.size();
    toothMask.voxelSize = mask_.voxelSize;
    toothMask.data.resize( box.volume() );

    forEachInSimpleVolume( toothMask, [&box, &fullMask = mask_, &maskIndexer, &id] ( const auto& pt, float& v )
    {
        const auto fullPt = pt + box.min;
        if ( fullMask.data[maskIndexer.toVoxelId( fullPt )] == id )
            v = ( float )id;
        else
            v = 0;
    } );

    std::tie( toothMask.min, toothMask.max ) = parallelMinMax( toothMask.data );

    auto toothMaskVdb = simpleVolumeToVdbVolume( toothMask );

    return
        gridToMesh( toothMaskVdb.data, GridToMeshSettings{
            .voxelSize = toothMask.voxelSize,
            .isoValue = static_cast<float>( id ) - 0.001f
        } )
            .and_then( [voxelSize = toothMask.voxelSize, boxV = box] ( Mesh&& mesh )
            {
                Box3f box( mult( Vector3f( boxV.min ), voxelSize ), mult( Vector3f( boxV.max ), voxelSize ) );
                const auto xf = AffineXf3f::translation( box.min + voxelSize );

                MeshToDirectionVolumeParams p;
                p.vol.origin = box.min;
                p.vol.voxelSize = voxelSize;
                p.vol.dimensions = boxV.size();
                p.dist.maxDistSq = 1;
                p.dist.minDistSq = 0;
                p.projector = std::make_shared<PointsToMeshProjector>();

                mesh.transform( xf );

                p.projector->updateMeshData( &mesh );
                return meshToDirectionVolume( p )
                    .transform( [&xf] ( DirectionVolume&& volumes )
                    {
                        return ProcessResult{
                            .volume = std::move( volumes ),
                            .xf = xf
                        };