Lidar is used to create impactful 3D point clouds that represent terrain and surface features. It can be used to generate digital elevation models (DEMs), contour lines, and terrain models. Users can classify, filter, and colorize lidar points based on their return type, elevation or intensity and can even perform feature extraction. This allows features like buildings, vegetation, powerlines, and more to be extracted from a lidar point cloud.
Exporting an Elevation Layer
Note: Before running this sample, configure these variables:
export_dir: the directory for resulting files to be exported to
A more complex sample script, showing a common workflow using Global Mapper Pro’s lidar tools: loading lidar data, creating an elevation layer from it, and exporting it to an elevation grid file. This sample grabs any loaded lidar layers, classifies the noise and ground points, and creates a class filter to only allow the use of ground points. An elevation grid is then generated, scaled to the size of the layer’s GlobalRect. Similar dimensions are then used to determine the export bounds for the newly created elevation grid. Then the elevation grid is exported to a directory specified by ‘resource_dir.’
import os
import globalmapper as gm
resource_dir = "Z:/GM-20069/GMPro_lidar_workflow_sample_data/Portland_Unclassified.laz"
export_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "../misc/GMPro_lidar_workflow_output/")
os.makedirs(export_dir, exist_ok=True)
# A more complex sample script, showing a common workflow using Global Mapper Pro's lidar tools: loading lidar data, creating
# an elevation layer from it, and exporting it to an elevation grid file. This sample grabs any loaded lidar layers, classifies
# the noise and ground points, and creates a class filter to only allow the use of ground points. An elevation grid is then generated,
# scaled to the size of the layer's GlobalRect. Similar dimensions are then used to determine the export bounds for the
# newly created elevation grid. Then the elevation grid is exported to a directory specified by 'resource_dir.'
err_LoadLayerList, array_pointer, array_size_param = gm.LoadLayerList(
resource_dir, gm.GM_LoadFlags_UseDefaultLoadOpts
)
layer_arr, num_layers = gm.GetLoadedLayerList()
all_layers = gm.GM_LayerHandle_array_frompointer(layer_arr)
### START SAMPLE
# Resolution of the output dataset in meters
pixel_resolution = 1.0
lidar_layers = []
# Load all LiDAR layers found into a list
for i in range(num_layers):
info = gm.GetLayerInfo(all_layers[i])
if info.mEnabled and info.mTypeName == "LIDAR_LAS":
lidar_layers.append(all_layers[i])
# If there's no lidar layers, no need to run the rest of the script
if len(lidar_layers):
# Classify noise points
print("Classifying noise...")
noise_setup = gm.GM_ClassifyNoiseSetup_t()
# Only check unclassified points for noise
noise_setup.mFlags += gm.GM_ClassifyNoise_UnclassifiedOnly
# Detect any points that resemble noisy lidar returns and reclassify them (best practice to do this first)
err_LidarClassifyNoise = gm.LidarClassifyNoise(
lidar_layers, noise_setup, 0
)
# Classify the ground points
print("Classifying ground...")
# Default settings work well for ground classification
err_LidarClassifyGround = gm.LidarClassifyGround(
lidar_layers, gm.GM_ClassifyGroundSetup_t(), 0
)
# Create the class filter to only use ground points
print("Applying class filter...")
# Save the current settings so they can be restored afterward
err_GetLidarClassFilter, prev_filter = gm.GetLidarClassFilter()
# New filter object with all classes disabled
err_LidarClassFilter_Init, class_filter = gm.LidarClassFilter_Init(False)
# Enable ground points to pass through the filter
err_LidarClassFilter_SetClassEnabled, mask = gm.LidarClassFilter_SetClassEnabled(
class_filter, gm.GM_LidarClass_Ground, True
)
# Apply new filter: only ground points will be used in lidar operations now
err_SetLidarClassFilter1 = gm.SetLidarClassFilter(class_filter)
# Get the dimensions of the layer in meters in case it isn't already
bounds = gm.GetLayerInfo(lidar_layers[0]).mGlobalRect
# Get the total width and height of the data in meters
err_CalcDistance1, width = gm.CalcDistance(
bounds.mMaxX, bounds.mMaxY, bounds.mMinX, bounds.mMaxY, 0
)
err_CalcDistance2, height = gm.CalcDistance(
bounds.mMaxX, bounds.mMaxY, bounds.mMaxX, bounds.mMinY, 0
)
groundcrs_width = (abs(bounds.mMaxX - bounds.mMinX) / width / pixel_resolution)
groundcrs_height = (abs(bounds.mMaxY - bounds.mMinY) / height / pixel_resolution)
# Create elevation grid layer from ground points at the approximate resolution
print("Generating elevation grid...")
grid_setup = gm.GM_GridGenSetup_t()
grid_setup.mXRes = groundcrs_width
grid_setup.mYRes = groundcrs_height
grid_setup.mGridAlg = gm.GM_GridAlg_BinAverage
# This value is high enough to fill gaps in most lidar data
grid_setup.mTightnessMult = 32
# Define how the gaps are filled
gap_fill = gm.GM_FillGapsParams_t()
gap_fill.mGapAlg = gm.GM_GapFillAlg_IDW
# Needs to be the same as grid_setup.mGridAlg
gap_fill.mGridAlg = gm.GM_GridAlg_BinAverage
grid_setup.mGapFillSetup = gap_fill
err_GenerateElevationGrid, grid_layer, tin_layer = gm.GenerateElevationGrid(lidar_layers, grid_setup)
# We don't need the TIN layer
err_CloseLayer = gm.CloseLayer(tin_layer)
# Reset the lidar class filter to previous settings
err_SetLidarClassFilter2 = gm.SetLidarClassFilter(prev_filter)
# Get the dimensions of grid layer in meters to use as the export size
bounds = gm.GetLayerInfo(grid_layer).mGlobalRect
err_CalcDistance3, grid_width = gm.CalcDistance(
bounds.mMaxX, bounds.mMaxY, bounds.mMinX, bounds.mMaxY, 0
)
err_CalcDistance4, grid_height = gm.CalcDistance(
bounds.mMaxX, bounds.mMaxY, bounds.mMaxX, bounds.mMinY, 0
)
# We are using the pixel_resolution variable for spacing
# A higher pixel_resolution value means a bigger pixels, and therefore a smaller file
pixel_width = round(grid_width / pixel_resolution)
pixel_height = round(grid_height / pixel_resolution)
# Export the new elevation data
print("Exporting elevation grid layer...")
err_ExportElevation = gm.ExportElevation(
export_dir + "ExampleDem.dem",
gm.GM_Export_DEM,
grid_layer,
bounds,
pixel_width,
pixel_height,
0,
gm.GM_ElevUnit_Centimeters,
)
else:
print("There are no lidar layers open.")
### END SAMPLE
assert (
gm.GM_Error_None == err_LoadLayerList
), f"LoadLayerList: Expected {gm.GM_Error_None}, got {err_LoadLayerList}"
assert (
gm.GM_Error_None == err_LidarClassifyNoise
), f"LidarClassifyNoise: Expected {gm.GM_Error_None}, got {err_LidarClassifyNoise}"
assert (
gm.GM_Error_None == err_LidarClassifyGround
), f"LidarClassifyGround: Expected {gm.GM_Error_None}, got {err_LidarClassifyGround}"
assert (
gm.GM_Error_None == err_GetLidarClassFilter
), f"GetLidarClassFilter: Expected {gm.GM_Error_None}, got {err_GetLidarClassFilter}"
assert (
gm.GM_Error_None == err_LidarClassFilter_Init
), f"LidarClassFilter_Init: Expected {gm.GM_Error_None}, got {err_LidarClassFilter_Init}"
assert (
gm.GM_Error_None == err_LidarClassFilter_SetClassEnabled
), f"LidarClassFilter_SetClassEnabled: Expected {gm.GM_Error_None}, got {err_LidarClassFilter_SetClassEnabled}"
assert (
gm.GM_Error_None == err_SetLidarClassFilter1
), f"SetLidarClassFilter1: Expected {gm.GM_Error_None}, got {err_SetLidarClassFilter1}"
assert (
gm.GM_Error_None == err_CalcDistance1
), f"CalcDistance1: Expected {gm.GM_Error_None}, got {err_CalcDistance1}"
assert (
gm.GM_Error_None == err_CalcDistance2
), f"CalcDistance2: Expected {gm.GM_Error_None}, got {err_CalcDistance2}"
assert (
gm.GM_Error_None == err_GenerateElevationGrid
), f"GenerateElevationGrid: Expected {gm.GM_Error_None}, got {err_GenerateElevationGrid}"
assert (
gm.GM_Error_None == err_SetLidarClassFilter2
), f"SetLidarClassFilter2: Expected {gm.GM_Error_None}, got {err_SetLidarClassFilter2}"
assert (
gm.GM_Error_None == err_CalcDistance3
), f"CalcDistance3: Expected {gm.GM_Error_None}, got {err_CalcDistance3}"
assert (
gm.GM_Error_None == err_CalcDistance4
), f"CalcDistance4: Expected {gm.GM_Error_None}, got {err_CalcDistance4}"
assert (
gm.GM_Error_None == err_ExportElevation
), f"ExportElevation: Expected {gm.GM_Error_None}, got {err_ExportElevation}"
assert (
gm.GM_Error_None == err_CloseLayer
), f"CloseLayer: Expected {gm.GM_Error_None}, got {err_CloseLayer}"
assert os.path.isdir(export_dir), f"Error creating the export directory: {export_dir}"
assert os.path.exists(resource_dir), f"Sample data doesn't exist: {resource_dir}"
if len(lidar_layers) == 0:
assert False, "No LiDAR layers were loaded"
# Expected path for file export
exported_filepath = os.path.join(export_dir, "ExampleDem.dem")
# Assert that the final expected output file exists and is not empty
assert os.path.exists(
exported_filepath
), f"Expected output file does not exist: {exported_filepath}"
assert (
os.path.getsize(exported_filepath) > 0
), f"Exported file is empty: {exported_filepath}"
# Check values for variables
# These are the values they held when this sample was created
assert width == 1554.5860896760855, "Incorrect width value"
assert height == 1206.9777319556936, "Incorrect height value"
assert grid_width == 1554.5860896760855, "Incorrect grid_width value"
assert grid_height == 1206.9777319556936, "Incorrect grid_height value"
assert groundcrs_height == 0.9997367540865648, "Incorrect groundcrs_height value"
assert groundcrs_width == 0.9997387795511684, "Incorrect groundcrs_width value"
assert pixel_width == 1555, "Incorrect pixel_width value"
assert pixel_height == 1207, "Incorrect pixel_height value"
Pixels to Points
Note: Before running this sample, configure these variables:
image_folder_path: the file path to the directory that contains the images for a P2P operationgc_points_file: the file path to a text file containing ground control pointsexport_dir: the absolute path to the desired export directory
This script demonstrates a pixels to points (P2P) process. First a setup object is configured. This involves assigning the image_folder_path and image mask to use for the imported images. Then the export directories and filenames are established for cloud, image, and mesh outputs that will be produced once the PixelsToPoints function is called. Now, the ground control points (GCPs) are read from a text file, extracting the image name, pixel coordinates, and real-world coordinates. It groups image pixel observations by GCP name and stores them in a dictionary. Then it creates control point objects (GM_P2PControlPoint_t) with the associated image pixels and adds them to the GCP list for use in the Pixels to Points process. The GCP list is then converted into an array so that it can be assigned to ‘aSetup.mControlPointList.’ Finally, the PixelsToPoints function is called, passing in the created setup object.
import os
import globalmapper as gm
image_folder_path = "Z:/GM-20069/pixels_to_points_sample_data/"
gc_points_file = "Z:/GM-20069/pixels_to_points_sample_data/gcp.txt"
export_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "../misc/pixels_to_points_output/")
os.makedirs(export_dir, exist_ok=True)
# This script demonstrates a pixels to points (P2P) process. First a setup object is configured. This involves assigning the
# image_folder_path and image mask to use for the imported images. Then the export directories and filenames are established
# for cloud, image, and mesh outputs that will be produced once the PixelsToPoints function is called. Now, the ground control
# points (GCPs) are read from a text file, extracting the image name, pixel coordinates, and real-world coordinates. Then it
# creates control point objects (GM_P2PControlPoint_t) with the associated image pixels and adds them to the GCP list for use
# in the Pixels to Points process. The GCP list is then converted into an array so that it can be assigned to 'aSetup.mControlPointList.'
# Finally, the PixelsToPoints function is called, passing in the created setup object.
### START SAMPLE
# The espg code for Mercator which is the correct projection for this dataset
ESPG_Code = 4326
err_LoadProjectionFromEPSGCode, projection = gm.LoadProjectionFromEPSGCode(ESPG_Code)
gm.SetProjection(projection)
# Import a sample for Pixels to Points
err_PixelsToPointsInitSetup, aSetup = gm.PixelsToPointsInitSetup()
# Path to image Folder
aSetup.mImageFolder = image_folder_path
# Image file name
aSetup.mImageFilenameMask = "*.JPG"
# Image reduce factor reduces image size, 2 is half size.
aSetup.mImageReduceFactor = 2
# Cloud Layer Name & Path
aSetup.mCloudLayerDesc = "P2P Cloud Layer"
aSetup.mCloudLayerFilename = export_dir + "p2p_test_cloud_output.gmp"
# Image Layer Name & Path
aSetup.mImageLayerDesc = "P2P Image Layer"
aSetup.mImageLayerFilename = export_dir + "p2p_test_image_output.gmp"
# Mesh Layer Name & Path
aSetup.mMeshLayerDesc = "P2P Mesh Layer"
aSetup.mMeshLayerFilename = export_dir + "p2p_test_mesh_output.obj"
# Sets Resampling Method to Nearest Neighbors
aSetup.mImageSamplingMethod = 0
# Get the ground control points from an external file
gcp_file = open(gc_points_file, "r")
gcp_text = gcp_file.readlines()
gcp_file.close()
# Define variable pix_arr null
pix_arr = None
# iterate through P2P_GCP text file
gcp_list = []
for line in gcp_text:
parts = line.strip().split(",")
if len(parts) < 7:
continue
gcp_name = parts[0]
image_name = parts[1]
pixel_x = float(parts[2])
pixel_y = float(parts[3])
world_x = float(parts[4])
world_y = float(parts[5])
elev = float(parts[6])
# Create a new control point object for each line
cp = gm.GM_P2PControlPoint_t()
cp.mName = gcp_name
# Set lat/lon/elev
geo = gm.GM_Point3D_t()
geo.mX, geo.mY, geo.mElev = world_x, world_y, elev
cp.mLatLonPos = geo
# Create the pixel object
pix = gm.GM_P2PImagePixel_t()
pix.mImageFilename = image_name
pix.mPixelPos = gm.GM_Point_t(pixel_x, pixel_y)
# Create an array and assign the single pixel
pixel_array = gm.GM_P2PImagePixel_array(1)
pixel_array[0] = pix
cp.mImagePixelList = pixel_array
cp.mImagePixelCount = 1
gcp_list.append(cp)
# Variable GCP Array is defined as list GCPS
# Converts ground control points from list format to array for
# use with function gm.PixelsToPointsInitSetup()
gcp_array = gm.GM_P2PControlPoint_array(len(gcp_list))
for i in range(len(gcp_list)):
gcp_array[i] = gcp_list[i]
# Attribute mControlPointList is assigned to gcp_array
# Attribute mControlPointCount is the length of list GCPS
aSetup.mControlPointList = gcp_array
aSetup.mControlPointCount = len(gcp_list)
# aReserved assigned to default, 0
aReserved = 0
# PixelsToPoints function is called
err_PixelstoPoints, info = gm.PixelsToPoints(aSetup, aReserved)
### END SAMPLE
assert (
gm.GM_Error_None == err_PixelsToPointsInitSetup
), f"PixelsToPointsInitSetup: Expected {gm.GM_Error_None}, got {err_PixelsToPointsInitSetup}"
assert (
gm.GM_Error_None == err_LoadProjectionFromEPSGCode
), f"LoadProjectionFromEPSGCode: Expected {gm.GM_Error_None}, got {err_LoadProjectionFromEPSGCode}"
assert (
gm.GM_Error_None == err_PixelstoPoints
), f"PixelstoPoints: Expected {gm.GM_Error_None}, got {err_PixelstoPoints}"
# Check if the image directory exists
assert os.path.isdir(
image_folder_path
), f"Image folder directory doesn't exist: {image_folder_path}"
assert os.path.isdir(export_dir), f"Error creating the export directory: {export_dir}"
# If the gcp points file exists
assert os.path.exists(gc_points_file), f"GCP file doesn't exist: {gc_points_file}"
expected_filenames = [
"p2p_test_cloud_output.gmp",
"p2p_test_image_output.gmp",
"p2p_test_mesh_output.mtl",
"p2p_test_mesh_output.obj",
"p2p_test_mesh_output.prj",
"scene_0_dense_mesh_material_0_map_kd.jpg",
]
# Make sure all expected files were exported
for name in expected_filenames:
full_filepath = os.path.join(export_dir, name)
# Assert that each expected file exists
assert os.path.exists(
full_filepath
), f"Expected output file does not exist: {full_filepath}"
# Assert that each expected file is not empty
assert (
os.path.getsize(full_filepath) > 0
), f"Exported file is empty: {full_filepath}"
assert os.path.getsize(gc_points_file) > 0, f"GCP file is empty: {gc_points_file}"
Colorize a Lidar Layer
This sample demonstrates how to use the lidar colorize function to update the color intensity fields of lidar points. The newly colorized points can be seen in Global Mapper if “Color by RGB/Elev” is selected in the Lidar Draw Mode dropdown list. This sample colorizes the lidar layer using 1 image layer, though many could be used. To do this, load more colored reference image layers into img_list.
import os
import globalmapper as gm
import_dir = "Z:/GM-20069/lidar_colorize_sample_data/"
# This sample demonstrates how to use the lidar colorize function to update the color intensity fields of lidar points. The newly
# colorized points can be seen in Global Mapper if "Color by RGB/Elev" is selected in the lidar Draw Mode dropdown list. This sample
# colorizes the lidar layer using 1 image layer, though many could be used. To do this, load more colored reference image layers into
# img_list.
# Close all layers that may be open
layers_are_open = gm.GetLoadedLayerList()
if layers_are_open:
arr_ptr, arr_size = layers_are_open
initial_layers = gm.GM_LayerHandle_array_frompointer(arr_ptr)
for i in range(arr_size):
gm.CloseLayer(initial_layers[i])
err_LoadLayerList1, array_pointer1, array_size_param1 = gm.LoadLayerList(
os.path.join(import_dir, "Augusta_Unclassified.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
err_LoadLayerList2, array_pointer2, array_size_param2 = gm.LoadLayerList(
os.path.join(import_dir, "Augusta_color.tif"),
gm.GM_LoadFlags_HideAllPrompts,
)
# Get handle for the loaded layers
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
### START SAMPLE
img_list = [layers_list[1]]
colorize_setup = gm.GM_LidarColorizeSetup_t()
colorize_setup.mIntensityMethod = gm.GM_LidarColorizeInten_Default
colorize_setup.mFlags = gm.GM_LidarColorize_DefaultFlags
colorize_setup.mFlags += gm.GM_LidarColorize_HideProgress
err_LidarColorize = gm.LidarColorize(layers_list[0], img_list, colorize_setup, 0)
### END SAMPLE
assert (
gm.GM_Error_None == err_LoadLayerList1
), f"LoadLayerList1: Expected {gm.GM_Error_None}, got {err_LoadLayerList1}"
assert (
gm.GM_Error_None == err_LoadLayerList2
), f"LoadLayerList2: Expected {gm.GM_Error_None}, got {err_LoadLayerList2}"
assert (
gm.GM_Error_None == err_LidarColorize
), f"LidarColorize: Expected {gm.GM_Error_None}, got {err_LidarColorize}"
assert os.path.isdir(import_dir), f"Import directory doesn't exist: {import_dir}"
assert os.path.exists(
os.path.join(import_dir, "Augusta_Unclassified.laz")
), f"Sample data doesn't exist"
assert os.path.exists(
os.path.join(import_dir, "Augusta_color.tif")
), f"Sample data doesn't exist"
Thin and Compare Lidar
Note: Before running this sample, configure these variables:
run_script_dir: the absolute path of the directory to be exported to
A sample that shows how the LidarThin and LidarCompare functions work. The first point cloud is thinned, this reduces the file size and can help improve processing speed for large datasets. The two point clouds are then compared, the differences between them are placed in a newly generated layer. LidarCompare can help identify geographic changes over time in a specific area. Afterwards, all of the loaded LAZ files are exported to a specified directory.
Learn how RunScript was used to run commands from the Global Mapper scripting language here.
import os
import globalmapper as gm
import_dir = "Z:/GM-20069/lidar_compare_thin_sample_data/"
run_script_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "../misc/lidar_compare_thin_output/")
os.makedirs(run_script_dir, exist_ok=True)
# A sample that shows how the LidarThin and LidarCompare functions work. The first point cloud is thinned, this reduces the file size
# and can help improve processing speed for large datasets. The two point clouds are then compared, the differences between them are
# placed in a newly generated layer. LidarCompare can help identify geographic changes over time in a specific area. Afterwards, all
# of the loaded LAZ files are exported to a specified directory.
# Close all layers that may be open
layers_are_open = gm.GetLoadedLayerList()
if layers_are_open:
arr_ptr, arr_size = layers_are_open
initial_layers = gm.GM_LayerHandle_array_frompointer(arr_ptr)
for i in range(arr_size):
gm.CloseLayer(initial_layers[i])
err_LoadLayerList1, array_pointer1, array_size_param1 = gm.LoadLayerList(
os.path.join(import_dir, "Kilauea_2009.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
err_LoadLayerList2, array_pointer2, array_size_param2 = gm.LoadLayerList(
os.path.join(import_dir, "Kilauea_2018.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
# Get handle for the loaded layers
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
### START SAMPLE
# Thin the point clouds for both lidar layers
thin_setup = gm.GM_LidarSpatialThinSetup_t()
thin_setup.mCreateNewCloud = False
err_LidarThin = gm.LidarThin(layers_list[0], thin_setup, 0)
thin_setup = gm.GM_LidarSpatialThinSetup_t()
thin_setup.mCreateNewCloud = False
err_LidarThin = gm.LidarThin(layers_list[1], thin_setup, 0)
# This function can compare multiple lidar layers against each other,
# but for this sample only 2 layers are being compared
# Compare the Kilauea_2009.laz to the Kilauea_2018.laz to view changes
list1 = [layers_list[1]] # Thinned
list2 = [layers_list[0]] # Original
compare_setup = gm.GM_LidarCompareSetup_t()
compare_setup.mFlags = gm.GM_LidarCompare_CreateNewLayers
compare_setup.mNewLayerDesc = "Kilauea_changes.laz"
err_LidarCompare = gm.LidarCompare(list1, list2, compare_setup, 0)
# Get handle for the loaded layers again to include the layer created by LidarCompare()
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
# Exports the lidar data, reflecting new class changes
for i in range(len(layers_list)):
# Get the name of the layer to be exported
layer_name = gm.GetLayerInfo(layers_list[i]).mDescription
if ".laz" in layer_name:
# Use the RunScript func to export lidar data as a .laz file
export_string = "EXPORT_VECTOR "
export_string += "FILENAME=" + run_script_dir + "new_" + layer_name + " "
export_string += "EXPORT_LAYER=" + layer_name + " "
export_string += "TYPE=LIDAR_LAS "
export_string += "ELEV_UNITS=METERS "
export_string += "VERT_CS_CODE=NAVD88 "
err_RunScript, handle, size = gm.RunScript(
export_string, gm.GM_LoadFlags_UseDefaultLoadOpts, 0
)
### END SAMPLE
assert (
gm.GM_Error_None == err_LoadLayerList1
), f"LoadLayerList1: Expected {gm.GM_Error_None}, got {err_LoadLayerList1}"
assert (
gm.GM_Error_None == err_LoadLayerList2
), f"LoadLayerList2: Expected {gm.GM_Error_None}, got {err_LoadLayerList2}"
assert (
gm.GM_Error_None == err_LidarThin
), f"LidarThin: Expected {gm.GM_Error_None}, got {err_LidarThin}"
assert (
gm.GM_Error_None == err_RunScript
), f"RunScript: Expected {gm.GM_Error_None}, got {err_RunScript}"
assert os.path.isdir(run_script_dir), f"Error creating the export directory: {run_script_dir}"
assert os.path.isdir(import_dir), f"Import directory doesn't exist: {import_dir}"
assert os.path.exists(
os.path.join(import_dir, "Kilauea_2009.laz")
), f"Sample data doesn't exist"
assert os.path.exists(
os.path.join(import_dir, "Kilauea_2018.laz")
), f"Sample data doesn't exist"
expected_filenames = [
"new_Kilauea_changes.laz",
"new_Kilauea_2009.laz",
"new_Kilauea_2018.laz",
]
# Make sure all expected files were exported
for name in expected_filenames:
full_filepath = os.path.join(run_script_dir, name)
# Assert that each expected file exists
assert os.path.exists(
full_filepath
), f"Expected output file does not exist: {full_filepath}"
# Assert that each expected file is not empty
assert (
os.path.getsize(full_filepath) > 0
), f"Exported file is empty: {full_filepath}"
Lidar Query Samples
Classifying Query Points
Note: Before running this sample, configure these variables:
run_script_dir: the absolute path of the directory to be exported to
This sample demonstrates a workflow using a lidar query. It loads multiple different lidar layers into a query. Query functions are then applied to classify all of the lidar layers in the query, demonstrating how multiple lidar layers can be classified with one function. The layers are then exported and some of their statistics are displayed.
Learn how RunScript was used to run commands from the Global Mapper scripting language here.
import os
import globalmapper as gm
import_dir = "Z:/GM-20069/lidar_query_classify_sample_data/"
run_script_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "../misc/lidar_query_classify_output/")
os.makedirs(run_script_dir, exist_ok=True)
# This sample demonstrates a workflow using a lidar query. It loads multiple different lidar layers into a query. Query functions are
# then applied to classify all of the lidar layers in the query, demonstrating how multiple lidar layers can be classified with one
# function. The layers are then exported and some of their statistics are displayed.
# Close all layers that may be open
layers_are_open = gm.GetLoadedLayerList()
if layers_are_open:
arr_ptr, arr_size = layers_are_open
initial_layers = gm.GM_LayerHandle_array_frompointer(arr_ptr)
for i in range(arr_size):
gm.CloseLayer(initial_layers[i])
err_LoadLayerList1, array_pointer1, array_size_param1 = gm.LoadLayerList(
os.path.join(import_dir, "Portland_Unclassified.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
err_LoadLayerList2, array_pointer2, array_size_param2 = gm.LoadLayerList(
os.path.join(import_dir, "Augusta_Unclassified.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
err_LoadLayerList3, array_pointer3, array_size_param3 = gm.LoadLayerList(
os.path.join(import_dir, "Gardiner_Unclassified.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
# Get handle for the loaded layer
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
### START SAMPLE
# Create the query of lidar layers (from a list of lidar layer handles)
err_CreateLidarQuery, query_pointer, query_size = gm.CreateLidarQuery(
layers_list, None, None
)
# Gets general info from the query
print("\nInitial Lidar Query Data:")
err_GetLidarQueryInfo, query_info = gm.GetLidarQueryInfo(query_pointer)
print("Number of layers: " + str(query_info.mLayerCount))
print("Total points among layers: " + str(query_info.mNumPoints) + "\n")
# Classify all lidar layers in the query (Default Settings)
print("Classifying noise...")
noise_setup = gm.GM_ClassifyNoiseSetup_t()
# Find any noise and reclassify it
noise_setup.mFlags += gm.GM_ClassifyNoise_UnclassifiedOnly
err_LidarClassifyNoiseFromQuery = gm.LidarClassifyNoiseFromQuery(
query_pointer, noise_setup, 0
)
print("Classifying ground...")
err_LidarClassifyGroundFromQuery = gm.LidarClassifyGroundFromQuery(
query_pointer, None, 0
)
print("Classifying buildings and vegetation...")
err_LidarClassifyBuildingVegFromQuery = gm.LidarClassifyBuildingVegFromQuery(
query_pointer, None, 0
)
# Free memory
err_FreeLidarQuery = gm.FreeLidarQuery(query_pointer)
# Export all of the newly classified lidar data
for i in range(len(layers_list)):
# Get the name of the layer to be exported
layer_name = gm.GetLayerInfo(layers_list[i]).mDescription
# Use the RunScript func to export lidar data as a .laz file
export_string = "EXPORT_VECTOR "
export_string += "FILENAME=" + run_script_dir + "new_" + layer_name + " "
export_string += "EXPORT_LAYER=" + layer_name + " "
export_string += "TYPE=LIDAR_LAS "
export_string += "ELEV_UNITS=METERS "
export_string += "VERT_CS_CODE=NAVD88 "
err_RunScript, handle, size = gm.RunScript(
export_string, gm.GM_LoadFlags_UseDefaultLoadOpts, 0
)
# Displays stats about each layer
err_GetLayerLidarStats, stats = gm.GetLayerLidarStats(layers_list[i], 0)
print("\n" + layer_name + " Stats:")
print("Average Elevation: " + str(stats.mAvgElev))
print("Standard Deviation (Elevation): " + str(stats.mStdDevElev))
print("Average Intensity: " + str(stats.mAvgIntensity))
print("Standard Deviation (Intensity): " + str(stats.mStdDevIntensity))
### END SAMPLE
assert (
gm.GM_Error_None == err_LoadLayerList1
), f"LoadLayerList1: Expected {gm.GM_Error_None}, got {err_LoadLayerList1}"
assert (
gm.GM_Error_None == err_LoadLayerList2
), f"LoadLayerList2: Expected {gm.GM_Error_None}, got {err_LoadLayerList2}"
assert (
gm.GM_Error_None == err_LoadLayerList3
), f"LoadLayerList3: Expected {gm.GM_Error_None}, got {err_LoadLayerList3}"
assert (
gm.GM_Error_None == err_CreateLidarQuery
), f"CreateLidarQuery: Expected {gm.GM_Error_None}, got {err_CreateLidarQuery}"
assert (
gm.GM_Error_None == err_GetLidarQueryInfo
), f"GetLidarQueryInfo: Expected {gm.GM_Error_None}, got {err_GetLidarQueryInfo}"
assert (
gm.GM_Error_None == err_LidarClassifyNoiseFromQuery
), f"LidarClassifyNoiseFromQuery: Expected {gm.GM_Error_None}, got {err_LidarClassifyNoiseFromQuery}"
assert (
gm.GM_Error_None == err_LidarClassifyGroundFromQuery
), f"LidarClassifyGroundFromQuery: Expected {gm.GM_Error_None}, got {err_LidarClassifyGroundFromQuery}"
assert (
gm.GM_Error_None == err_LidarClassifyBuildingVegFromQuery
), f"LidarClassifyBuildingVegFromQuery: Expected {gm.GM_Error_None}, got {err_LidarClassifyBuildingVegFromQuery}"
assert (
gm.GM_Error_None == err_FreeLidarQuery
), f"FreeLidarQuery: Expected {gm.GM_Error_None}, got {err_FreeLidarQuery}"
assert (
gm.GM_Error_None == err_GetLayerLidarStats
), f"GetLayerLidarStats: Expected {gm.GM_Error_None}, got {err_GetLayerLidarStats}"
assert os.path.isdir(run_script_dir), f"Error creating the export directory: {run_script_dir}"
assert os.path.isdir(import_dir), f"Import directory doesn't exist: {import_dir}"
assert os.path.exists(
os.path.join(import_dir, "Augusta_Unclassified.laz")
), "Sample data doesn't exist"
assert os.path.exists(
os.path.join(import_dir, "Portland_Unclassified.laz")
), "Sample data doesn't exist"
assert os.path.exists(
os.path.join(import_dir, "Gardiner_Unclassified.laz")
), "Sample data doesn't exist"
expected_filenames = [
"new_Augusta_Unclassified.laz",
"new_Gardiner_Unclassified.laz",
"new_Portland_Unclassified.laz",
]
# Make sure all expected files were exported
for name in expected_filenames:
full_filepath = os.path.join(run_script_dir, name)
# Assert that each expected file exists
assert os.path.exists(
full_filepath
), f"Expected output file does not exist: {full_filepath}"
# Assert that each expected file is not empty
assert (
os.path.getsize(full_filepath) > 0
), f"Exported file is empty: {full_filepath}"
Classifying a Graph and Extracting Query Features
Note: Before running this sample, configure these variables:
run_script_dir: the absolute path of the directory to be exported to
This sample demonstrates how to classify a graph and extract vector features from a lidar query. Ground, building, and high vegetation points are classified from the query as a graph-classification. Then all building and tree features are extracted from the lidar layers. Finally, the generated vector layers and loaded LAZ layers are exported to a specified directory. The exported vector features will keep their previous attribute values.
Learn how RunScript was used to run commands from the Global Mapper scripting language here.
import os
import globalmapper as gm
import_dir = "Z:/GM-20069/lidar_query_features_sample_data/"
run_script_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "../misc/lidar_query_features_output/")
os.makedirs(run_script_dir, exist_ok=True)
# This sample demonstrates how to classify a graph and extract vector features from a lidar query. Ground, building, and high vegetation
# points are classified from the query as a graph-classification. Then all building and tree features are extracted from the lidar layers.
# Finally, the generated vector layers and loaded LAZ layers are exported to a specified directory. The exported vector features will keep
# their previous attribute values.
# Close all layers that may be open
layers_are_open = gm.GetLoadedLayerList()
if layers_are_open:
arr_ptr, arr_size = layers_are_open
initial_layers = gm.GM_LayerHandle_array_frompointer(arr_ptr)
for i in range(arr_size):
gm.CloseLayer(initial_layers[i])
err_LoadLayerList1, array_pointer1, array_size_param1 = gm.LoadLayerList(
os.path.join(import_dir, "SM_Portland_Unclassified.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
err_LoadLayerList2, array_pointer2, array_size_param2 = gm.LoadLayerList(
os.path.join(import_dir, "SM_Augusta_Unclassified.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
# Get handle for the loaded layers
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
### START SAMPLE
# Create the query of lidar layers (from a list of lidar layer handles)
err_CreateLidarQuery1, query_pointer1, query_size1 = gm.CreateLidarQuery(
layers_list, None, None
)
# Classify ground points and then classify graph for building and vegetation points
err_LidarClassifyGroundFromQuery = gm.LidarClassifyGroundFromQuery(
query_pointer1, None, 0
)
seg_opts = gm.GM_SegmentationSetup_t()
seg_opts.mMaxMahalanobisDistance = 1
seg_opts.mMinClusterSize = 6
build_veg_opts = gm.GM_ClassifyBuildingVegSetup_t()
build_veg_opts.mGridBinSizeUnits = gm.GM_LidarResMult_Meters
build_veg_opts.mMeanGridBinMult = 3.4239962
build_veg_opts.mVegMinHeightAboveGround = 0
build_veg_opts.mBuildingMinHeightAboveGround = 0.5
build_veg_opts.mPlanarAngleMaxDiff = 5
build_veg_opts.mPlanarThresholdM = 0.079999998
build_veg_opts.mRoofInvalidMaxAngle = 78
build_veg_opts.mRoofInvalidMinAngle = 65
build_veg_opts.mTreeThresholdM = 0.15
graph_opts = gm.GM_ClassifyGraphSetup_t()
graph_opts.mTypes = 6
graph_opts.mFlags = 0
graph_opts.mSegmentationOpts = seg_opts
graph_opts.mBuildingVegOpts = build_veg_opts
err_LidarClassifyGraphFromQuery = gm.LidarClassifyGraphFromQuery(
query_pointer1, graph_opts, 0
)
# Extract all buildings and trees from the query
extract_opts = gm.GM_LidarExtractSetup_t()
extract_opts.mTypes = gm.GM_LidarExtract_Trees
extract_opts.mTypes += gm.GM_LidarExtract_Buildings
err_LidarExtractFeaturesFromQuery, generated_layers = gm.LidarExtractFeaturesFromQuery(
query_pointer1, extract_opts, 0
)
# Free memory
err_FreeLidarQuery1 = gm.FreeLidarQuery(query_pointer1)
# Get handle for the loaded layers again to access generated layers
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
for i in range(len(layers_list)):
# Get the name of the layer to be exported
layer_name = gm.GetLayerInfo(layers_list[i]).mDescription
# Export all of the newly classified lidar data
if ".laz" in layer_name:
# Use the RunScript func to export lidar data as a .laz file
export_string = "EXPORT_VECTOR "
export_string += "FILENAME=" + run_script_dir + "new_" + layer_name + " "
export_string += "EXPORT_LAYER=" + layer_name + " "
export_string += "TYPE=LIDAR_LAS "
export_string += "ELEV_UNITS=METERS "
export_string += "VERT_CS_CODE=NAVD88 "
err_RunScript, handle, size = gm.RunScript(
export_string, gm.GM_LoadFlags_UseDefaultLoadOpts, 0
)
else:
# Exports generated feature layers as shapefiles
# Ensures that the exported features keep their attributes
err_ExportVector = gm.ExportVector(
run_script_dir + layer_name,
gm.GM_Export_Shapefile,
layers_list[i],
None,
gm.GM_VectorExportFlags_HideProgress + gm.GM_VectorExportFlags_ExportAttrs,
gm.NULL,
)
### END SAMPLE
assert (
gm.GM_Error_None == err_LoadLayerList1
), f"LoadLayerList1: Expected {gm.GM_Error_None}, got {err_LoadLayerList1}"
assert (
gm.GM_Error_None == err_LoadLayerList2
), f"LoadLayerList2: Expected {gm.GM_Error_None}, got {err_LoadLayerList2}"
assert (
gm.GM_Error_None == err_CreateLidarQuery1
), f"CreateLidarQuery: Expected {gm.GM_Error_None}, got {err_CreateLidarQuery1}"
assert (
gm.GM_Error_None == err_FreeLidarQuery1
), f"FreeLidarQuery1: Expected {gm.GM_Error_None}, got {err_FreeLidarQuery1}"
assert (
gm.GM_Error_None == err_LidarClassifyGraphFromQuery
), f"LidarClassifyGraphFromQuery: Expected {gm.GM_Error_None}, got {err_LidarClassifyGraphFromQuery}"
assert (
gm.GM_Error_None == err_LidarExtractFeaturesFromQuery
), f"LidarExtractFeaturesFromQuery: Expected {gm.GM_Error_None}, got {err_LidarExtractFeaturesFromQuery}"
assert (
gm.GM_Error_None == err_RunScript
), f"RunScript: Expected {gm.GM_Error_None}, got {err_RunScript}"
assert (
gm.GM_Error_None == err_ExportVector
), f"ExportVector: Expected {gm.GM_Error_None}, got {err_ExportVector}"
assert os.path.isdir(run_script_dir), f"Error creating the export directory: {run_script_dir}"
assert os.path.isdir(import_dir), f"Import directory doesn't exist: {import_dir}"
assert os.path.exists(
os.path.join(import_dir, "SM_Augusta_Unclassified.laz")
), "Sample data doesn't exist"
assert os.path.exists(
os.path.join(import_dir, "SM_Portland_Unclassified.laz")
), "Sample data doesn't exist"
expected_filenames = [
"Building Footprints",
"Building Footprints.dbf",
"Building Footprints.shx",
"Extracted Trees",
"Extracted Trees.dbf",
"Extracted Trees.shx",
"new_SM_Augusta_Unclassified.laz",
"new_SM_Portland_Unclassified.laz",
]
# Make sure all expected files were exported
for name in expected_filenames:
full_filepath = os.path.join(run_script_dir, name)
# Assert that each expected file exists
assert os.path.exists(
full_filepath
), f"Expected output file does not exist: {full_filepath}"
# Assert that each expected file is not empty
assert (
os.path.getsize(full_filepath) > 0
), f"Exported file is empty: {full_filepath}"
Enhancing and Combining Lidar Queries
Note: Before running this sample, configure these variables:
run_script_dir: the absolute path of the directory to be exported to
The code below imports pre-classified lidar data and separates any points classified as buildings and medium vegetation into two separate queries. Each query of points is then modified upon meeting specific criteria. Building-classified points that are over 70 meters tall were assigned a lime green color. Medium Vegetation-classified points that are over 60 meters tall were assigned an orange color. The two queries are then merged and exported as a new LAZ file. The changes made to point color can be seen in Global Mapper if “Color by RGB/Elev” is selected in the Lidar Draw Mode dropdown list. This can make points of specific criteria easier to view/interact with.
Learn how RunScript was used to run commands from the Global Mapper scripting language here.
import os
import globalmapper as gm
import_dir = "Z:/GM-20069/lidar_query_points_sample_data/"
run_script_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "../misc/lidar_query_points_output/")
os.makedirs(run_script_dir, exist_ok=True)
# The code below imports pre-classified lidar data and separates any points classified as buildings and medium vegetation into two separate
# queries. Each query of points is then modified upon meeting specific criteria. Building-classified points that are over 70 meters tall were
# assigned a lime green color. Medium Vegetation-classified points that are over 60 meters tall were assigned an orange color. The two queries
# are then merged and exported as a new LAZ file. The changes made to point color can be seen in Global Mapper if "Color by RGB/Elev" is
# selected in the lidar Draw Mode dropdown list. This can make points of specific criteria easier to view/interact with.
# Close all layers that may be open
layers_are_open = gm.GetLoadedLayerList()
if layers_are_open:
arr_ptr, arr_size = layers_are_open
initial_layers = gm.GM_LayerHandle_array_frompointer(arr_ptr)
for i in range(arr_size):
gm.CloseLayer(initial_layers[i])
err_LoadLayerList, array_pointer, array_size_param = gm.LoadLayerList(
os.path.join(import_dir, "SM_Augusta_Classified.laz"),
gm.GM_LoadFlags_HideAllPrompts,
)
# Get handle for the loaded layers
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
### START SAMPLE
# Query to hold building points
err_CreateEmptyLidarQuery1, query_handle1 = gm.CreateEmptyLidarQuery()
# Query to hold meduim vegetation points
err_CreateEmptyLidarQuery2, query_handle2 = gm.CreateEmptyLidarQuery()
# Iterates through all of the lidar points in a layer and adds the ones classified as
# buildings and medium vegetation to their respective queries.
num_pts = gm.GetLayerInfo(layers_list[0]).mNumLidarPoints
for i in range(num_pts):
err_GetLidarPoint, point = gm.GetLidarPoint(
layers_list[0], i, gm.GM_GetFeature_UseLayerProj, 0
)
if not err_GetLidarPoint:
point_class = point.mClass
# Get Building points
if point_class == 6:
# Criteria for a tall building (change point color)
if point.mElevMeters >= 70:
point.mRed = 130
point.mGreen = 253
point.Blue = 0
# Using SetLidarPoint can be extremely slow if you are modifying very
# large numbers of lidar points. (This sample uses a lidar file with ~92,000 points)
err_SetLidarPoint1 = gm.SetLidarPoint(layers_list[0], i, point, 0)
# Add point to query
err_AddRemovePointToLidarQuery1 = gm.AddRemovePointToLidarQuery(
query_handle1, layers_list[0], i, 1
)
# Get Medium Vegetation points
elif point_class == 4:
# Criteria for a tall tree (change point color)
if point.mElevMeters >= 60:
point.mRed = 252
point.mGreen = 132
point.Blue = 3
err_SetLidarPoint2 = gm.SetLidarPoint(layers_list[0], i, point, 0)
# Add point to query
err_AddRemovePointToLidarQuery2 = gm.AddRemovePointToLidarQuery(
query_handle2, layers_list[0], i, 1
)
else:
print("Error: Couldn't retrieve lidar point")
# Merge the two queries together and create a layer based on the modified data
err_AddLidarQueryToQuery = gm.AddLidarQueryToQuery(query_handle1, query_handle2, 0)
err_CreateLayerFromLidarQuery, new_layer_handle = gm.CreateLayerFromLidarQuery(
query_handle1, "class_layer.laz", None, 0
)
# Free memory
err_FreeLidarQuery1 = gm.FreeLidarQuery(query_handle1)
err_FreeLidarQuery2 = gm.FreeLidarQuery(query_handle2)
# Get handle for the loaded layers (This step is repeated to include the new layer)
arr_ptr, arr_size = gm.GetLoadedLayerList()
layers_array = gm.GM_LayerHandle_array_frompointer(arr_ptr)
layers_list = gm.carray_to_list(layers_array, arr_size)
# To view the modified colors for class_layer.laz in Global Mapper,
# make sure "Color by RGB/Elev" is selected in the lidar Draw Mode dropdown list
# Exports the lidar data, reflecting new class changes
for i in range(len(layers_list)):
# Get the name of the layer to be exported
layer_name = gm.GetLayerInfo(layers_list[i]).mDescription
# Use the RunScript func to export lidar data as a .laz file
export_string = "EXPORT_VECTOR "
export_string += "FILENAME=" + run_script_dir + "new_" + layer_name + " "
export_string += "EXPORT_LAYER=" + layer_name + " "
export_string += "TYPE=LIDAR_LAS "
export_string += "ELEV_UNITS=METERS "
export_string += "VERT_CS_CODE=NAVD88 "
err_RunScript, handle, size = gm.RunScript(
export_string, gm.GM_LoadFlags_UseDefaultLoadOpts, 0
)
### END SAMPLE
assert (
gm.GM_Error_None == err_LoadLayerList
), f"LoadLayerList: Expected {gm.GM_Error_None}, got {err_LoadLayerList}"
assert (
gm.GM_Error_None == err_CreateEmptyLidarQuery1
), f"CreateEmptyLidarQuery1: Expected {gm.GM_Error_None}, got {err_CreateEmptyLidarQuery1}"
assert (
gm.GM_Error_None == err_CreateEmptyLidarQuery2
), f"CreateEmptyLidarQuery2: Expected {gm.GM_Error_None}, got {err_CreateEmptyLidarQuery2}"
assert (
gm.GM_Error_None == err_GetLidarPoint
), f"GetLidarPoint: Expected {gm.GM_Error_None}, got {err_GetLidarPoint}"
assert (
gm.GM_Error_None == err_SetLidarPoint1
), f"SetLidarPoint1: Expected {gm.GM_Error_None}, got {err_SetLidarPoint1}"
assert (
gm.GM_Error_None == err_SetLidarPoint2
), f"SetLidarPoint2: Expected {gm.GM_Error_None}, got {err_SetLidarPoint2}"
assert (
gm.GM_Error_None == err_AddRemovePointToLidarQuery1
), f"AddRemovePointToLidarQuery1: Expected {gm.GM_Error_None}, got {err_AddRemovePointToLidarQuery1}"
assert (
gm.GM_Error_None == err_AddRemovePointToLidarQuery2
), f"AddRemovePointToLidarQuery2: Expected {gm.GM_Error_None}, got {err_AddRemovePointToLidarQuery2}"
assert (
gm.GM_Error_None == err_AddLidarQueryToQuery
), f"AddLidarQueryToQuery: Expected {gm.GM_Error_None}, got {err_AddLidarQueryToQuery}"
assert (
gm.GM_Error_None == err_CreateLayerFromLidarQuery
), f"CreateLayerFromLidarQuery: Expected {gm.GM_Error_None}, got {err_CreateLayerFromLidarQuery}"
assert (
gm.GM_Error_None == err_FreeLidarQuery1
), f"FreeLidarQuery1: Expected {gm.GM_Error_None}, got {err_FreeLidarQuery1}"
assert (
gm.GM_Error_None == err_FreeLidarQuery2
), f"FreeLidarQuery2: Expected {gm.GM_Error_None}, got {err_FreeLidarQuery2}"
assert (
gm.GM_Error_None == err_RunScript
), f"RunScript: Expected {gm.GM_Error_None}, got {err_RunScript}"
assert os.path.isdir(run_script_dir), f"Error creating the export directory: {run_script_dir}"
assert os.path.isdir(import_dir), f"Import directory doesn't exist: {import_dir}"
assert os.path.exists(
os.path.join(import_dir, "SM_Augusta_Classified.laz")
), f"Sample data doesn't exist"
expected_filenames = [
"new_class_layer.laz",
"new_SM_Augusta_Classified.laz",
]
# Make sure all expected files were exported
for name in expected_filenames:
full_filepath = os.path.join(run_script_dir, name)
# Assert that each expected file exists
assert os.path.exists(
full_filepath
), f"Expected output file does not exist: {full_filepath}"
# Assert that each expected file is not empty
assert (
os.path.getsize(full_filepath) > 0
), f"Exported file is empty: {full_filepath}"