Terrain Output Workflow Implementation

This exercise uses the Script Editor to run a complete terrain-production workflow. The script reads the first point cloud already loaded in the current Mapping project, then performs subsampling, outlier removal, ground classification, DEM generation, DSM generation, and contour generation in sequence.

Before You Begin

• Open a Mapping project with the .LiMMP extension.
• Load at least one point cloud into the project. The script uses the first loaded point cloud and does not require a hard-coded data path.
• Confirm that the output location beside the project file is writable.
• Make sure the required point-cloud classification and Road Terrain functions are licensed and available.
• Save the project before running a long workflow.

The script creates a <project-name>_result folder beside the project file. It keeps the original point cloud, keeps the final classified point cloud, and removes intermediate point-cloud layers from the project after all six processing steps succeed. Files created on disk are not deleted.

Input point cloud loaded in the project

Understand the Complete Workflow

The six tools are not run as unrelated batch operations. Each point-cloud step passes its output to the next step. Subsampling feeds outlier removal, outlier removal feeds ground classification, and the final classified point cloud is then shared by DEM, DSM, and contour generation.

Current Mapping project
        |
        v
Read project information and check .LiMMP ----invalid----> Stop: wrong project type
        |
        v
Read project data and find first point cloud --missing----> Stop: load a point cloud
        |
        v
Create <project-name>_result output folder
        |
        v
PointCloud_Subsampling
        |
        v
PointCloud_Remove_Outliers
        |
        v
Classify_Classify_Ground_Points
        |
        +-------------------------+--------------------------+
        |                         |                          |
        v                         v                          v
Generate DEM                Generate DSM              Generate contours
Ground class 2              All classes 0-255         Ground class 2
        |                         |                          |
        v                         v                          v
Check DEM in project        Check DSM in project      Create or reuse contour layer
        |                         |
    Not loaded                  Not loaded
        |                         |
        v                         v
load_raster fallback        load_raster fallback
        |                         |                          |
        +-------------------------+--------------------------+
                                  |
                                  v
                   Remove intermediate subsampling and SOR layers
                                  |
                                  v
             Keep original cloud, final classified cloud, and terrain products

Any step raises an exception
        |
        v
Remove intermediate clouds already added to the project, keep the original cloud
and disk files, then report the error

This order first reduces the point count to control later processing cost, removes obvious outliers before classification, and makes all three terrain products use the same classified state instead of different intermediate results.

Add the Workflow Script

Create or open a Python Script Tool, open it in the Script Editor, and enter the following complete script.

"""Run the Standard LiDAR360MLS terrain workflow in the Python editor.

This standalone script reproduces the enabled six-stage processing sequence of
RoadTerrainWorkflowStartAction with the current gvscript Result V1 API. It uses
the first point cloud loaded in the active .LiMMP project and writes processing
outputs to the sibling <project-name>_result directory.
"""

import os
from pathlib import Path

from gvscript import mls


PRODUCT_NAME = "LiDAR360MLS Standard"
PROJECT_SUFFIX = ".limmp"


def path_key(path):
    return os.path.normcase(os.path.normpath(str(path)))


def type_key(value):
    return str(value).replace(" ", "").lower()


def project_point_clouds():
    result = mls.project.list_loaded_data()
    return [item for item in result.data.matchedData if type_key(item.type) == "pointcloud"]


def first_project_point_cloud():
    point_clouds = project_point_clouds()
    if not point_clouds:
        raise RuntimeError("No point cloud is loaded in the current project.")
    path = str(point_clouds[0].path)
    if not Path(path).is_file():
        raise FileNotFoundError("Input point cloud does not exist: {}".format(path))
    return point_clouds[0], path


def project_output_dir():
    result = mls.project.get_project_info()
    if not result.data.isOpen or not result.data.projectPath:
        raise RuntimeError("No mapping project is currently open.")
    project_path = Path(result.data.projectPath)
    if project_path.suffix.lower() != PROJECT_SUFFIX:
        raise RuntimeError(
            "{} requires a {} project, current project: {}".format(
                PRODUCT_NAME, PROJECT_SUFFIX, project_path
            )
        )
    output_dir = project_path.parent / (project_path.stem + "_result")
    output_dir.mkdir(parents=True, exist_ok=True)
    return str(output_dir).replace("\\", "/")


def point_cloud_outputs(step_name, result, fallback=None):
    outputs = list(result.data.outputs.get("point_clouds") or [])
    if outputs:
        print("{} outputs: {}".format(step_name, outputs))
        return outputs
    if fallback is not None:
        print("{} updated input point cloud in place: {}".format(step_name, fallback))
        return list(fallback)
    raise RuntimeError("{} returned no point-cloud output.".format(step_name))


def raster_outputs(step_name, result):
    outputs = list(result.data.outputs.get("rasters") or [])
    if not outputs:
        raise RuntimeError("{} returned no raster output.".format(step_name))
    print("{} outputs: {}".format(step_name, outputs))
    return outputs


def loaded_paths(data_type):
    result = mls.project.list_loaded_data()
    return {
        path_key(item.path)
        for item in result.data.matchedData
        if item.path and type_key(item.type) == type_key(data_type)
    }


def ensure_rasters_loaded(paths):
    loaded = loaded_paths("raster")
    for path in paths:
        if path_key(path) not in loaded:
            mls.io.load_raster(path=path)
            loaded.add(path_key(path))


def remove_from_project(paths):
    loaded = {
        path_key(item.path): item.id
        for item in mls.project.list_loaded_data().data.matchedData
        if item.path
    }
    for path in paths:
        item_id = loaded.get(path_key(path))
        if not item_id:
            continue
        result = mls.layer.io_remove_layer(id=item_id, raise_on_error=False)
        if not result.ok:
            print("Warning: unable to remove project item {}: {}".format(item_id, result.message))


def finish_point_cloud_outputs(generated_paths, final_paths):
    final_keys = {path_key(path) for path in final_paths}
    remove_paths = [path for path in generated_paths if path_key(path) not in final_keys]
    remove_from_project(dict.fromkeys(remove_paths))

    loaded = loaded_paths("pointcloud")
    missing = [path for path in final_paths if path_key(path) not in loaded]
    if missing:
        mls.io.load_point_cloud(paths=missing)


def run_road_terrain_workflow():
    input_item, input_path = first_project_point_cloud()
    output_dir = project_output_dir()
    generated_point_clouds = []
    print("Product: {}".format(PRODUCT_NAME))
    print("Input point cloud: {}".format(input_path))
    print("Output directory: {}".format(output_dir))

    try:
        subsampling = mls.point_cloud.pointcloud_subsampling_parameters()
        subsampling_result = mls.point_cloud.pointcloud_subsampling(
            input_paths=[input_path], output_path=output_dir, Parameters=subsampling
        )
        current = point_cloud_outputs("PointCloud_Subsampling", subsampling_result)
        generated_point_clouds.extend(current)

        remove_outliers = mls.point_cloud.pointcloud_remove_outliers_parameters()
        remove_outliers_result = mls.point_cloud.pointcloud_remove_outliers(
            input_paths=current, output_path=output_dir, Parameters=remove_outliers
        )
        current = point_cloud_outputs("PointCloud_Remove_Outliers", remove_outliers_result)
        generated_point_clouds.extend(current)

        classify_ground = mls.classify.classify_classify_ground_points_parameters()
        classify_result = mls.classify.classify_classify_ground_points(
            input_paths=current, Parameters=classify_ground
        )
        current = point_cloud_outputs(
            "Classify_Classify_Ground_Points", classify_result, fallback=current
        )
        generated_point_clouds.extend(current)
        final_point_clouds = list(current)

        dem = mls.road_terrain.pointcloud_to_dem_parameters()
        dem.outPutDir = output_dir
        dem_result = mls.road_terrain.pointcloud_to_dem(
            input_paths=final_point_clouds, Parameters=dem
        )
        dem_outputs = raster_outputs("RoadTerrain_PointCloud_To_DEM", dem_result)

        dsm = mls.road_terrain.pointcloud_to_dsm_parameters()
        dsm.outPutDir = output_dir
        dsm_result = mls.road_terrain.pointcloud_to_dsm(
            input_paths=final_point_clouds, Parameters=dsm
        )
        dsm_outputs = raster_outputs("RoadTerrain_PointCloud_To_DSM", dsm_result)

        contour = mls.road_terrain.pointcloud_to_contour_parameters()
        contour_result = mls.road_terrain.pointcloud_to_contour(
            input_paths=final_point_clouds, Parameters=contour
        )
        contour_outputs = list(contour_result.outputs)
        print("RoadTerrain_PointCloud_To_Contour outputs: {}".format(contour_outputs))

        finish_point_cloud_outputs(generated_point_clouds, final_point_clouds)
        ensure_rasters_loaded(dem_outputs)
        ensure_rasters_loaded(dsm_outputs)
        summary = {
            "product": PRODUCT_NAME,
            "input_id": input_item.id,
            "input_point_cloud": input_path,
            "output_directory": output_dir,
            "final_point_clouds": final_point_clouds,
            "dem": dem_outputs,
            "dsm": dsm_outputs,
            "contour": contour_outputs,
        }
        print("Terrain workflow finished: {}".format(summary))
        return summary
    except Exception:
        remove_from_project(dict.fromkeys(generated_point_clouds))
        raise


WORKFLOW_RESULT = run_road_terrain_workflow()

Core Function Responsibilities

generated_point_clouds records point clouds created during this run. current always holds the cloud passed to the next step, and final_point_clouds freezes the classified result. This prevents DEM, DSM, or contour generation from accidentally using an earlier subsampling or filtering result.

Processing Steps and Key Parameters

The script calls parameter factories to obtain the current defaults. To tune the workflow, change the parameter object after its factory call and before the corresponding tool call. Do not construct undeclared parameter dictionaries.

1. Point-cloud subsampling

pointcloud_subsampling_parameters() uses voxel sampling by default. This reduces the point count and controls the cost of outlier removal and classification.

2. Outlier removal

pointcloud_remove_outliers_parameters() runs the SOR statistical outlier filter. It receives the subsampled output instead of reading the original cloud again.

3. Ground classification

classify_classify_ground_points_parameters() uses TIN-based ground classification and writes detected ground points to class 2. Its result is shared by DEM, DSM, and contour generation.

The classification tool may create a new cloud or update the input in place. point_cloud_outputs(..., fallback=current) supports both result forms.

4. DEM generation

pointcloud_to_dem_parameters() uses only ground class 2 to produce a bare-earth elevation surface.

5. DSM generation

pointcloud_to_dsm_parameters() uses all classes from 0 through 255 to produce a surface that includes object tops. It uses type=1 and resultType=1; its resolution, tiling, buffer, hole-filling, and merge defaults match the DEM step.

The DEM and DSM tools may add their rasters to the project automatically. ensure_rasters_loaded() calls mls.io.load_raster() only when a result is still missing.

6. Contour generation

pointcloud_to_contour_parameters() uses ground class 2 and creates or reuses the current project's contour layer.

These values are the current defaults used by this exercise, not fixed recommendations for every dataset. Tune sampling density, classification thresholds, raster resolution, and contour intervals for the point density, terrain relief, target map scale, and delivery requirements.

Terrain workflow script in the Script Editor

Check and Run the Script

1. Select Check and resolve any reported syntax problem.
2. Save the script.
3. Select Run, or press F5.
4. Wait until all six processing calls finish. Only one script can run at a time, and there is no Stop command in the Script Editor.
5. Open the Output panel and confirm that the log contains output records for subsampling, outlier removal, ground classification, DEM, DSM, and contour generation.

Successful terrain workflow log

Verify the Results

After a successful run, inspect the project tree. It should retain the original point cloud, the final classified point cloud, a contour layer, and the generated DEM and DSM rasters. Subsampling and outlier-removal point-cloud layers are removed from the project tree, but their disk files remain in the result folder.

Final project data tree

Open the two raster results and compare their surface representation. The DEM is generated from ground class 2, while the DSM includes all point classes.

Generated DEM and DSM

Display the contour layer and verify that the lines follow the terrain surface.

Generated contour result

Troubleshooting

• No point cloud is loaded: Load a point cloud into the current project, then run the script again.
• The project suffix is rejected: Open a Standard LiDAR360MLS Mapping project with the .LiMMP extension.
• A processing call fails: Check the Output panel for the tool error code and message, then verify the license, plug-ins, input data, and available disk space.
• A raster is not visible: Refresh the project view. The script also loads a generated raster when the processing tool has not already added it.
• The result folder already exists: The script reuses the <project-name>_result folder. Review existing outputs before running the workflow again.