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

Example of generating a triangulation from a terrain scan (specific pointcloud).

  • C++
    #include <MRMesh/MRColor.h>
    #include <iostream>
    int main()
    {
    // CTM, JPEG and other formats beyond the basic ones come with the MRIOExtras library
    // load points
    MR::VertColors colors;
    pls.colors = &colors;
    auto loadRes = MR::PointsLoad::fromAnySupportedFormat( "TerrainPoints.ply", pls );
    if ( !loadRes.has_value() )
    {
    std::cerr << loadRes.error() << "\n";
    return 1; // error while loading file
    }
    auto triangulationRes = MR::delaunayTriangulationXY( *loadRes );
    if ( !triangulationRes.has_value() )
    {
    std::cerr << triangulationRes.error() << "\n";
    return 1; // error while triangulating
    }
    if ( loadRes->points.size() == colors.size() )
    ss.colors = &colors;
    auto saveRes = MR::MeshSave::toAnySupportedFormat( *triangulationRes, "TerrainMesh.ctm", ss );
    if ( !saveRes.has_value() )
    {
    std::cerr << saveRes.error() << "\n";
    return 1; // error while saving file
    }
    return 0;
    }
    int main()
    Definition LaplacianDeformation.cpp:4
    Expected< Mesh > delaunayTriangulationXY(VertCoords points, const ProgressCallback &cb={})
    void loadIOExtras()
    Expected< PointCloud > fromAnySupportedFormat(const std::filesystem::path &file, const PointsLoadSettings &settings={})
    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
    colors = mm.VertColors()
    lps = mm.PointsLoadSettings()
    lps.colors = colors
    pc = mm.loadPoints("TerrainPoints.ply",lps)
    terrain_mesh = mm.delaunayTriangulationXY(pc)
    mss = mm.SaveSettings()
    if (pc.points.size() == colors.size()):
    mss.colors = colors
    mm.saveMesh(terrain_mesh, "TerrainMesh.ctm",mss)
  • C
    #include <MRCMesh/MRPointsLoad.h>
    #include <MRCMesh/MRPointsLoadSettings.h>
    #include <MRCMesh/MRVector.h>
    #include <MRCMesh/MRPointCloud.h>
    #include <MRCMesh/MRDelaunayTriangulationXY.h>
    #include <MRCMesh/MRMeshSave.h>
    #include <MRCMesh/MRSaveSettings.h>
    #include <MRCMesh/MRColor.h>
    #include <MRCMisc/expected_MR_Mesh_std_string.h>
    #include <MRCMisc/expected_MR_PointCloud_std_string.h>
    #include <MRCMisc/expected_void_std_string.h>
    #include <MRCMisc/std_vector_MR_Color.h>
    #include <MRCMisc/std_vector_MR_Vector3f.h>
    #include <MRCMisc/std_string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main( void )
    {
    int rc = EXIT_FAILURE;
    // load points
    MR_VertColors* colors = MR_VertColors_DefaultConstruct();
    MR_PointsLoadSettings* pls = MR_PointsLoadSettings_DefaultConstruct();
    MR_PointsLoadSettings_Set_colors( pls, colors );
    MR_expected_MR_PointCloud_std_string* loadRes = MR_PointsLoad_fromAnySupportedFormat( "TerrainPoints.ply", NULL, pls );
    MR_PointCloud* pc = MR_expected_MR_PointCloud_std_string_value_mut( loadRes );
    if ( !pc )
    {
    fprintf( stderr, "Failed to load points: %s\n", MR_std_string_data( MR_expected_MR_PointCloud_std_string_error( loadRes ) ) );
    goto fail_load; // error while loading file
    }
    MR_expected_MR_Mesh_std_string* triangulationRes = MR_delaunayTriangulationXY_const_MR_PointCloud_ref( pc, NULL );
    MR_Mesh* mesh = MR_expected_MR_Mesh_std_string_value_mut( triangulationRes );
    if ( !mesh )
    {
    fprintf( stderr, "Failed to triangulate points: %s\n", MR_std_string_data( MR_expected_MR_Mesh_std_string_error( triangulationRes ) ) );
    goto fail_triangulation; // error while triangulating
    }
    MR_SaveSettings* ss = MR_SaveSettings_DefaultConstruct();
    if ( MR_VertColors_size( colors ) == MR_VertCoords_size( MR_PointCloud_Get_points( pc ) ) )
    {
    MR_SaveSettings_Set_colors( ss, colors );
    }
    MR_expected_void_std_string* saveEx = MR_MeshSave_toAnySupportedFormat( mesh, "TerrainMesh.ctm", NULL, ss );
    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_SaveSettings_Destroy( ss );
    fail_triangulation:
    MR_expected_MR_Mesh_std_string_Destroy( triangulationRes );
    fail_load:
    MR_expected_MR_PointCloud_std_string_Destroy( loadRes );
    MR_PointsLoadSettings_Destroy( pls );
    MR_VertColors_Destroy( colors );
    return rc;
    }
    const std::shared_ptr< const Mesh > & mesh() const
  • C#
    public static class TerrainTriangulationExample
    {
    public static void Main(string[] args)
    {
    // load points
    MR.VertColors colors = new();
    MR.PointsLoadSettings pls = new();
    pls.colors = colors;
    var pc = MR.PointsLoad.fromAnySupportedFormat("TerrainPoints.ply", pls);
    var mesh = MR.delaunayTriangulationXY(pc);
    MR.SaveSettings ss = new();
    if (pc.points.size() == colors.size())
    ss.colors = colors;
    MR.MeshSave.toAnySupportedFormat(mesh, "TerrainMesh.ctm", ss);
    }
    }
  • Rust
    use meshlib::{PointsLoadSettings, SaveSettings, VertColors};
    fn main() -> Result<(), String>
    {
    // load points
    let mut colors = VertColors::new();
    let mut pls = PointsLoadSettings::new();
    pls.set_colors(Some(&mut colors));
    let points = meshlib::points_load::from_any_supported_format("TerrainPoints.ply", Some(&pls)).into_result()?;
    let triangulation_res = meshlib::delaunay_triangulation_xy_const_mr_point_cloud_ref(&points, None).into_result()?;
    let mut ss = SaveSettings::new();
    if points.points().size() == colors.size()
    {
    ss.set_colors(Some(&colors));
    }
    meshlib::mesh_save::to_any_supported_format(&triangulation_res, "TerrainMesh.ctm", Some(&ss)).into_result()?;
    Ok(())
    }
  • Java
    import meshlib.Functions;
    import meshlib.Mesh;
    import meshlib.PointCloud;
    import meshlib.PointsLoadSettings;
    import meshlib.SaveSettings;
    import meshlib.VertColors;
    // The class isn't public because of the `.dox.java` file name, the launcher doesn't mind.
    class TerrainTriangulation
    {
    public static void main(String[] args)
    {
    // load points
    VertColors colors = new VertColors();
    PointsLoadSettings pls = new PointsLoadSettings();
    pls.setColors(colors);
    // An error is thrown as `UnexpectedResultException`.
    PointCloud pointCloud = meshlib.pointsload.Functions.fromAnySupportedFormat("TerrainPoints.ply", pls);
    Mesh triangulationRes = Functions.delaunayTriangulationXY_const_MR_PointCloud_ref(pointCloud, null);
    SaveSettings ss = new SaveSettings();
    if (pointCloud.points().size() == colors.size())
    ss.setColors(colors);
    meshlib.meshsave.Functions.toAnySupportedFormat(triangulationRes, "TerrainMesh.ctm", ss);
    }
    }
    const std::shared_ptr< const PointCloud > & pointCloud() const