MeshLib Documentation
Loading...
Searching...
No Matches
Contour Triangulation Example

Example of generating a triangulation from a contour.

  • C++
    #include <MRMesh/MRMesh.h>
    #include <iostream>
    int main()
    {
    // CTM, JPEG and other formats beyond the basic ones come with the MRIOExtras library
    // load image as distance map
    auto imageLoadRes = MR::ImageLoad::fromAnySupportedFormat( "logo.jpg" );
    if ( !imageLoadRes.has_value() )
    {
    std::cerr << imageLoadRes.error() << "\n";
    return 1; // error while loading file
    }
    auto dmRes = MR::convertImageToDistanceMap( *imageLoadRes );
    if ( !dmRes.has_value() )
    {
    std::cerr << dmRes.error() << "\n";
    return 1; // error while converting image to distance map
    }
    auto pl2 = MR::distanceMapTo2DIsoPolyline( *dmRes, 210.0f );
    auto triangulationRes = MR::PlanarTriangulation::triangulateContours( pl2.contours() );
    auto saveRes = MR::MeshSave::toAnySupportedFormat( triangulationRes, "LogoMesh.ctm" );
    if ( !saveRes.has_value() )
    {
    std::cerr << saveRes.error() << "\n";
    return 1; // error while saving file
    }
    return 0;
    }
    int main()
    Definition LaplacianDeformation.cpp:4
    Polyline2 distanceMapTo2DIsoPolyline(const DistanceMap &distMap, float isoValue)
    Expected< DistanceMap > convertImageToDistanceMap(const Image &image, float threshold=1.f/255, bool invert=true)
    Mesh triangulateContours(const Contours2d &contours, const TriangulationParameters &params={})
    void loadIOExtras()
    Expected< Image > fromAnySupportedFormat(const std::filesystem::path &path)
    Expected< void > toAnySupportedFormat(const Mesh &mesh, const std::filesystem::path &file, const SaveSettings &settings={})
  • Python
    from meshlib import mrmeshpy as mm
    from pathlib import Path
    dm = mm.loadDistanceMapFromImage("logo.jpg") # load image
    pl2 = mm.distanceMapTo2DIsoPolyline(dm, 210) # make iso lines from image
    logo_mesh = mm.PlanarTriangulation.triangulateContours(pl2.contours()) # triangulate isolines
    mm.saveMesh(logo_mesh, "LogoMesh.ctm")
  • C
    #include <MRCMesh/MRImageLoad.h>
    #include <MRCMesh/MRDistanceMap.h>
    #include <MRCMesh/MRPolyline.h>
    #include <MRCMesh/MRMesh.h>
    #include <MRCMesh/MR2DContoursTriangulation.h>
    #include <MRCMesh/MRMeshSave.h>
    #include <MRCMisc/expected_MR_Mesh_std_string.h>
    #include <MRCMisc/expected_MR_Image_std_string.h>
    #include <MRCMisc/expected_MR_DistanceMap_std_string.h>
    #include <MRCMisc/expected_void_std_string.h>
    #include <MRCMisc/std_vector_std_vector_MR_Vector2f.h>
    #include <MRCMisc/std_string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main( void )
    {
    int rc = EXIT_FAILURE;
    // load image as distance map
    MR_expected_MR_Image_std_string* imageLoadRes = MR_ImageLoad_fromAnySupportedFormat( "logo.jpg", NULL );
    MR_Image* image = MR_expected_MR_Image_std_string_value_mut( imageLoadRes );
    if ( !image )
    {
    fprintf( stderr, "Failed to load image: %s\n", MR_std_string_data( MR_expected_MR_Image_std_string_error( imageLoadRes ) ) );
    goto fail_load; // error while loading file
    }
    MR_expected_MR_DistanceMap_std_string* dmRes = MR_convertImageToDistanceMap( image, NULL, NULL );
    MR_DistanceMap* dm = MR_expected_MR_DistanceMap_std_string_value_mut( dmRes );
    if ( !dm )
    {
    fprintf( stderr, "Failed to convert image to distance map: %s\n", MR_std_string_data( MR_expected_MR_DistanceMap_std_string_error( dmRes ) ) );
    goto fail_conversion; // error while converting image to distance map
    }
    MR_Polyline2* pl2 = MR_distanceMapTo2DIsoPolyline( dm, 210.0f );
    MR_std_vector_std_vector_MR_Vector2f* conts = MR_Polyline2_contours( pl2, NULL );
    MR_Mesh* triangulationRes = MR_PlanarTriangulation_triangulateContours_std_vector_std_vector_MR_Vector2f( conts, NULL );
    MR_expected_void_std_string* saveEx = MR_MeshSave_toAnySupportedFormat( triangulationRes, "LogoMesh.ctm", NULL, NULL );
    if ( MR_expected_void_std_string_error( saveEx ) )
    {
    fprintf( stderr, "Failed to save mesh: %s\n", MR_std_string_data( MR_expected_void_std_string_error( saveEx ) ) );
    goto fail_save; // error while saving file
    }
    rc = EXIT_SUCCESS;
    fail_save:
    MR_expected_void_std_string_Destroy( saveEx );
    MR_Mesh_Destroy( triangulationRes );
    MR_std_vector_std_vector_MR_Vector2f_Destroy( conts );
    MR_Polyline2_Destroy( pl2 );
    fail_conversion:
    MR_expected_MR_DistanceMap_std_string_Destroy( dmRes );
    fail_load:
    MR_expected_MR_Image_std_string_Destroy( imageLoadRes );
    return rc;
    }
  • C#
    public static class ContourTriangulationExample
    {
    public static void Main(string[] args)
    {
    // load image as distance map
    var image = MR.ImageLoad.fromAnySupportedFormat("logo.jpg");
    var dm = MR.convertImageToDistanceMap(image);
    var pl2 = MR.distanceMapTo2DIsoPolyline(dm, 210.0f);
    var triangulationRes = MR.PlanarTriangulation.triangulateContours(pl2.contours());
    MR.MeshSave.toAnySupportedFormat(triangulationRes, "LogoMesh.ctm");
    }
    }
  • Rust
    fn main() -> Result<(), String>
    {
    // load image as distance map
    let image = meshlib::image_load::from_any_supported_format("logo.jpg").into_result()?;
    let dm = meshlib::convert_image_to_distance_map(&image, None, None).into_result()?;
    let pl2 = meshlib::distance_map_to2_d_iso_polyline(&dm, 210.0);
    let triangulation_res = meshlib::planar_triangulation::triangulate_contours_std_vector_std_vector_mr_vector2f(&pl2.contours(None), None);
    meshlib::mesh_save::to_any_supported_format(&triangulation_res, "LogoMesh.ctm", None).into_result()?;
    Ok(())
    }
  • Java
    import meshlib.DistanceMap;
    import meshlib.Functions;
    import meshlib.Image;
    import meshlib.Mesh;
    import meshlib.Polyline2;
    // The class isn't public because of the `.dox.java` file name, the launcher doesn't mind.
    class ContourTriangulation
    {
    public static void main(String[] args)
    {
    // load image as distance map
    // An error is thrown as `UnexpectedResultException`.
    Image image = meshlib.imageload.Functions.fromAnySupportedFormat("logo.jpg");
    DistanceMap dm = Functions.convertImageToDistanceMap(image, null, null);
    Polyline2 pl2 = Functions.distanceMapTo2DIsoPolyline(dm, 210.0f);
    Mesh triangulationRes = meshlib.planartriangulation.Functions.triangulateContours(pl2.contours(null), null);
    meshlib.meshsave.Functions.toAnySupportedFormat(triangulationRes, "LogoMesh.ctm", null);
    }
    }