ign-pdal-tools 1.8.1__tar.gz → 1.11.1__tar.gz

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.8.1
+Version: 1.11.1
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.8.1
+Version: 1.11.1
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/ign_pdal_tools.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ pdaltools/las_clip.py
 pdaltools/las_info.py
 pdaltools/las_merge.py
 pdaltools/las_remove_dimensions.py
+pdaltools/las_rename_dimension.py
 pdaltools/pcd_info.py
 pdaltools/replace_attribute_in_las.py
 pdaltools/standardize_format.py
@@ -24,7 +25,9 @@ test/test_las_clip.py
 test/test_las_info.py
 test/test_las_merge.py
 test/test_las_remove_dimensions.py
+test/test_las_rename_dimension.py
 test/test_pcd_info.py
+test/test_pdal_custom.py
 test/test_replace_attribute_in_las.py
 test/test_standardize_format.py
 test/test_unlock.py

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.8.1"
+__version__ = "1.11.1"
 
 
 if __name__ == "__main__":

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/pdaltools/add_points_in_pointcloud.py

@@ -1,5 +1,6 @@
 import argparse
 from shutil import copy2
+import tempfile
 
 import geopandas as gpd
 import laspy
@@ -10,6 +11,8 @@ from shapely.geometry import MultiPoint, Point, box
 
 from pdaltools.las_info import get_epsg_from_las, get_tile_bbox
 
+import pdal
+
 
 def parse_args(argv=None):
     parser = argparse.ArgumentParser("Add points from GeoJSON in LIDAR tile")
@@ -127,13 +130,12 @@ def add_points_to_las(
         crs (str): CRS of the data.
         virtual_points_classes (int): The classification value to assign to those virtual points (default: 66).
     """
-    # Copy data pointcloud
-    copy2(input_las, output_las)
 
     if input_points_with_z.empty:
         print(
             "No points to add. All points of the geojson file are outside the tile. Copying the input file to output"
         )
+        copy2(input_las, output_las)
         return
 
     # Extract XYZ coordinates and additional attribute (classification)
@@ -148,24 +150,30 @@ def add_points_to_las(
         header = las.header
         if not header:
             header = laspy.LasHeader(point_format=8, version="1.4")
+
+    new_points = laspy.ScaleAwarePointRecord.zeros(nb_points, header=header)  # use header for input_las
+    # then fill in the gaps (X, Y, Z an classification)
+    new_points.x = x_coords.astype(new_points.x.dtype)
+    new_points.y = y_coords.astype(new_points.y.dtype)
+    new_points.z = z_coords.astype(new_points.z.dtype)
+    new_points.classification = classes.astype(new_points.classification.dtype)
+
+    with tempfile.NamedTemporaryFile(suffix="_new_points.las") as tmp:
+        with laspy.open(tmp.name, mode="w", header=header) as las_file:
+            las_file.write_points(new_points)
+
         if crs:
-            try:
-                crs_obj = CRS.from_user_input(crs)  # Convert to a pyproj.CRS object
-            except CRSError:
-                raise ValueError(f"Invalid CRS: {crs}")
-            header.add_crs(crs_obj)
-
-    # Add the new points with 3D points
-    with laspy.open(output_las, mode="a", header=header) as output_las:  # mode `a` for adding points
-        # create nb_points points with "0" everywhere
-        new_points = laspy.ScaleAwarePointRecord.zeros(nb_points, header=header)  # use header for input_las
-        # then fill in the gaps (X, Y, Z an classification)
-        new_points.x = x_coords.astype(new_points.x.dtype)
-        new_points.y = y_coords.astype(new_points.y.dtype)
-        new_points.z = z_coords.astype(new_points.z.dtype)
-        new_points.classification = classes.astype(new_points.classification.dtype)
-
-        output_las.append_points(new_points)
+            a_srs = crs
+        else:
+            a_srs = get_epsg_from_las(input_las)
+
+        # Use pdal to merge the new points with the existing points
+        pipeline = pdal.Pipeline()
+        pipeline |= pdal.Reader.las(filename=input_las)
+        pipeline |= pdal.Reader.las(filename=tmp.name)
+        pipeline |= pdal.Filter.merge()
+        pipeline |= pdal.Writer.las(filename=output_las, forward="all", a_srs=a_srs)
+        pipeline.execute()
 
 
 def line_to_multipoint(line, spacing: float, z_value: float = None):

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/pdaltools/las_add_buffer.py

@@ -158,7 +158,6 @@ def remove_points_from_buffer(input_file: str, output_file: str):
         pipeline |= pdal.Filter.range(limits=f"{ORIGINAL_TILE_TAG}[1:1]")
         pipeline |= pdal.Writer.las(filename=tmp_las.name, forward="all", extra_dims="all")
         pipeline.execute()
-
         remove_dimensions_from_las(tmp_las.name, dimensions=[ORIGINAL_TILE_TAG], output_las=output_file)
 
 

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/pdaltools/las_remove_dimensions.py

@@ -5,22 +5,36 @@ import pdal
 from pdaltools.las_info import get_writer_parameters_from_reader_metadata
 
 
-def remove_dimensions_from_las(input_las: str, dimensions: [str], output_las: str):
+def remove_dimensions_from_points(points, metadata, dimensions: [str], output_las: str):
     """
     export new las without some dimensions
     """
-    pipeline = pdal.Pipeline() | pdal.Reader.las(input_las)
-    pipeline.execute()
-    points = pipeline.arrays[0]
+
+    mandatory_dimensions = ["X", "Y", "Z", "x", "y", "z"]
+    output_dimensions_test = [dim for dim in dimensions if dim not in mandatory_dimensions]
+    assert len(output_dimensions_test) == len(
+        dimensions
+    ), "All dimensions to remove must not be mandatory dimensions (X,Y,Z,x,y,z)"
+
     input_dimensions = list(points.dtype.fields.keys())
     output_dimensions = [dim for dim in input_dimensions if dim not in dimensions]
     points_pruned = points[output_dimensions]
-    params = get_writer_parameters_from_reader_metadata(pipeline.metadata)
+    params = get_writer_parameters_from_reader_metadata(metadata)
     pipeline_end = pdal.Pipeline(arrays=[points_pruned])
     pipeline_end |= pdal.Writer.las(output_las, forward="all", **params)
     pipeline_end.execute()
 
 
+def remove_dimensions_from_las(input_las: str, dimensions: [str], output_las: str):
+    """
+    export new las without some dimensions
+    """
+    pipeline = pdal.Pipeline() | pdal.Reader.las(input_las)
+    pipeline.execute()
+    points = pipeline.arrays[0]
+    remove_dimensions_from_points(points, pipeline.metadata, dimensions, output_las)
+
+
 def parse_args():
     parser = argparse.ArgumentParser("Remove dimensions from las")
     parser.add_argument(

ign_pdal_tools-1.11.1/pdaltools/las_rename_dimension.py

@@ -0,0 +1,79 @@
+"""
+Rename dimensions in a LAS file using PDAL's Python API.
+
+This script allows renaming dimensions in a LAS file while preserving all other data.
+"""
+
+import argparse
+import pdal
+import sys
+from pathlib import Path
+from pdaltools.las_remove_dimensions import remove_dimensions_from_points
+
+
+def rename_dimension(input_file: str, output_file: str, old_dims: list[str], new_dims: list[str]):
+    """
+    Rename one or multiple dimensions in a LAS file using PDAL.
+
+    Args:
+        input_file: Path to the input LAS file
+        output_file: Path to save the output LAS file
+        old_dims: List of names of dimensions to rename
+        new_dims: List of new names for the dimensions
+    """
+
+    # Validate dimensions
+    if len(old_dims) != len(new_dims):
+        raise ValueError("Number of old dimensions must match number of new dimensions")
+
+    mandatory_dimensions = ["X", "Y", "Z", "x", "y", "z"]
+    for dim in new_dims:
+        if dim in mandatory_dimensions:
+            raise ValueError(f"New dimension {dim} cannot be a mandatory dimension (X,Y,Z,x,y,z)")
+
+    pipeline = pdal.Pipeline() | pdal.Reader.las(input_file)
+    for old, new in zip(old_dims, new_dims):
+        pipeline |= pdal.Filter.ferry(dimensions=f"{old} => {new}")
+    pipeline |= pdal.Writer.las(output_file)
+    pipeline.execute()
+    points = pipeline.arrays[0]
+
+    # Remove old dimensions
+    remove_dimensions_from_points(points, pipeline.metadata, old_dims, output_file)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Rename dimensions in a LAS file")
+    parser.add_argument("input_file", help="Input LAS file")
+    parser.add_argument("output_file", help="Output LAS file")
+    parser.add_argument(
+        "--old-dims",
+        nargs="+",
+        required=True,
+        help="Names of dimensions to rename (can specify multiple)",
+    )
+    parser.add_argument(
+        "--new-dims",
+        nargs="+",
+        required=True,
+        help="New names for the dimensions (must match --old-dims count)",
+    )
+
+    args = parser.parse_args()
+
+    # Validate input file
+    input_path = Path(args.input_file)
+    if not input_path.exists():
+        print(f"Error: Input file {args.input_file} does not exist", file=sys.stderr)
+        sys.exit(1)
+
+    # Validate output file
+    output_path = Path(args.output_file)
+    if output_path.exists():
+        print(f"Warning: Output file {args.output_file} already exists. It will be overwritten.")
+
+    rename_dimension(args.input_file, args.output_file, args.old_dims, args.new_dims)
+
+
+if __name__ == "__main__":
+    main()

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/pdaltools/standardize_format.py

@@ -1,11 +1,11 @@
 """Re-write las file with expected format:
-    - laz version
-    - [TODO] nomenclature ???
-    - record format
-    - global encoding
-    - projection
-    - precision
-    - no extra-dims
+- laz version
+- [TODO] nomenclature ???
+- record format
+- global encoding
+- projection
+- precision
+- no extra-dims
 """
 
 import argparse
@@ -18,6 +18,7 @@ from typing import Dict, List
 import pdal
 
 from pdaltools.unlock_file import copy_and_hack_decorator
+from pdaltools.las_rename_dimension import rename_dimension
 
 # Standard parameters to pass to the pdal writer
 STANDARD_PARAMETERS = dict(
@@ -60,6 +61,13 @@ def parse_args():
         help="List of extra dims to keep in the output (default=[], use 'all' to keep all extra dims), "
         "extra_dims must be specified with their type (see pdal.writers.las documentation, eg 'dim1=double')",
     )
+    parser.add_argument(
+        "--rename_dims",
+        default=[],
+        nargs="*",
+        type=str,
+        help="Rename dimensions in pairs: --rename_dims old_name1 new_name1 old_name2 new_name2 ...",
+    )
     return parser.parse_args()
 
 
@@ -73,11 +81,27 @@ def get_writer_parameters(new_parameters: Dict) -> Dict:
 
 
 def rewrite_with_pdal(
-    input_file: str, output_file: str, params_from_parser: Dict, classes_to_remove: List = []
+    input_file: str, output_file: str, params_from_parser: Dict, classes_to_remove: List = [], rename_dims: List = []
 ) -> None:
     params = get_writer_parameters(params_from_parser)
+
+    # Create temporary file for dimension renaming if needed
+    if rename_dims:
+        with tempfile.NamedTemporaryFile(suffix=".laz", delete=False) as tmp_file:
+            tmp_file_name = tmp_file.name
+
+            # Rename dimensions
+            old_dims = rename_dims[::2]
+            new_dims = rename_dims[1::2]
+            rename_dimension(input_file, tmp_file_name, old_dims, new_dims)
+
+            # Use renamed file as input
+            input_file = tmp_file_name
+    else:
+        tmp_file_name = input_file
+
     pipeline = pdal.Pipeline()
-    pipeline |= pdal.Reader.las(input_file)
+    pipeline |= pdal.Reader.las(tmp_file_name)
     if classes_to_remove:
         expression = "&&".join([f"Classification != {c}" for c in classes_to_remove])
         pipeline |= pdal.Filter.expression(expression=expression)
@@ -102,18 +126,24 @@ def exec_las2las(input_file: str, output_file: str):
 
 
 @copy_and_hack_decorator
-def standardize(input_file: str, output_file: str, params_from_parser: Dict, class_points_removed: []) -> None:
+def standardize(
+    input_file: str, output_file: str, params_from_parser: Dict, class_points_removed: [], rename_dims: []
+) -> None:
     filename = os.path.basename(output_file)
     with tempfile.NamedTemporaryFile(suffix=filename) as tmp:
-        rewrite_with_pdal(input_file, tmp.name, params_from_parser, class_points_removed)
+        rewrite_with_pdal(input_file, tmp.name, params_from_parser, class_points_removed, rename_dims)
         exec_las2las(tmp.name, output_file)
 
 
-if __name__ == "__main__":
+def main():
     args = parse_args()
     params_from_parser = dict(
         dataformat_id=args.record_format,
         a_srs=args.projection,
         extra_dims=args.extra_dims,
     )
-    standardize(args.input_file, args.output_file, params_from_parser, args.class_points_removed)
+    standardize(args.input_file, args.output_file, params_from_parser, args.class_points_removed, args.rename_dims)
+
+
+if __name__ == "__main__":
+    main()

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/pdaltools/unlock_file.py

@@ -1,5 +1,4 @@
-"""Tools to handle malformed las/laz files
-    """
+"""Tools to handle malformed las/laz files"""
 
 # https://gis.stackexchange.com/questions/413191/python-pdal-error-reading-format-1-4-las-file-readers-las-error-global-enco
 

{ign_pdal_tools-1.8.1 → ign_pdal_tools-1.11.1}/test/test_add_points_in_pointcloud.py

@@ -272,6 +272,22 @@ def test_add_points_from_geometry_to_las(input_file, input_points, epsg, expecte
         input_points, input_file, OUTPUT_FILE, 68, epsg, 1000, spacing, altitude_column
     )
     assert Path(OUTPUT_FILE).exists()  # check output exists
+    
+    # Read input and output files to compare headers
+    input_las = laspy.read(input_file)
+    output_las = laspy.read(OUTPUT_FILE)
+    
+    # Compare headers
+    assert input_las.header.version == output_las.header.version
+    assert input_las.header.system_identifier == output_las.header.system_identifier
+    assert input_las.header.extra_header_bytes == output_las.header.extra_header_bytes
+    assert input_las.header.extra_vlr_bytes == output_las.header.extra_vlr_bytes
+    assert input_las.header.number_of_evlrs == output_las.header.number_of_evlrs
+    assert input_las.header.point_format == output_las.header.point_format
+    assert np.array_equal(input_las.header.scales, output_las.header.scales)
+    assert np.array_equal(input_las.header.offsets, output_las.header.offsets)
+    assert input_las.header.vlrs[0].string == output_las.header.vlrs[0].string
+    
     point_count = compute_count_one_file(OUTPUT_FILE)["68"]
     assert point_count == expected_nb_points  # Add all points from geojson
 

ign_pdal_tools-1.11.1/test/test_las_rename_dimension.py

@@ -0,0 +1,159 @@
+import os
+import pytest
+import tempfile
+import numpy as np
+import laspy
+import sys
+from pdaltools.las_rename_dimension import rename_dimension, main
+from pyproj import CRS
+
+def create_test_las_file():
+    """Create a temporary LAS file with test data."""
+    with tempfile.NamedTemporaryFile(suffix='.las', delete=False) as tmp_file:
+        # Create a LAS file with some test points
+        header = laspy.LasHeader(point_format=3, version="1.4")
+        header.add_extra_dim(laspy.ExtraBytesParams(name="test_dim", type=np.float32))
+        header.add_extra_dim(laspy.ExtraBytesParams(name="test_dim2", type=np.int32))
+        
+        las = laspy.LasData(header)
+
+        crs_pyproj = CRS.from_string("epsg:4326")
+        las.header.add_crs(crs_pyproj)
+
+        # Add some test points
+        las.x = np.array([1.0, 2.0, 3.0])
+        las.y = np.array([4.0, 5.0, 6.0])
+        las.z = np.array([7.0, 8.0, 9.0])
+        las.test_dim = np.array([10.0, 11.0, 12.0])
+        las.test_dim2 = np.array([12, 13, 14])
+        
+        las.write(tmp_file.name)
+        return tmp_file.name
+
+def test_rename_dimension():
+    """Test renaming a dimension in a LAS file."""
+    # Create a temporary input LAS file
+    input_file = create_test_las_file()
+    
+    # Create temporary output file
+    with tempfile.NamedTemporaryFile(suffix='.las', delete=False) as tmp_file:
+        output_file = tmp_file.name
+    
+    try:
+        # Rename dimension using direct function call
+        rename_dimension(input_file, output_file, ["test_dim", "test_dim2"], ["new_test_dim", "new_test_dim2"])
+        
+        # Verify the dimension was renamed
+        with laspy.open(output_file) as las_file:
+            las = las_file.read()
+            assert "new_test_dim" in las.point_format.dimension_names
+            assert "test_dim" not in las.point_format.dimension_names
+            assert "new_test_dim2" in las.point_format.dimension_names
+            assert "test_dim2" not in las.point_format.dimension_names
+            
+            # Verify the data is preserved
+            np.testing.assert_array_equal(las.x, [1.0, 2.0, 3.0])
+            np.testing.assert_array_equal(las.y, [4.0, 5.0, 6.0])
+            np.testing.assert_array_equal(las.z, [7.0, 8.0, 9.0])
+            np.testing.assert_array_equal(las["new_test_dim"], [10.0, 11.0, 12.0])
+            np.testing.assert_array_equal(las["new_test_dim2"], [12, 13, 14])
+    finally:
+        # Clean up temporary files
+        try:
+            os.unlink(input_file)
+            os.unlink(output_file)
+        except:
+            pass
+
+def test_rename_nonexistent_dimension():
+    """Test attempting to rename a dimension that doesn't exist."""
+    input_file = create_test_las_file()
+    
+    with tempfile.NamedTemporaryFile(suffix='.las', delete=False) as tmp_file:
+        output_file = tmp_file.name
+    
+    try:
+        with pytest.raises(RuntimeError):
+            rename_dimension(input_file, output_file, ["nonexistent_dim"], ["new_dim"])
+    finally:
+        os.unlink(input_file)
+        os.unlink(output_file)
+
+def test_rename_to_existing_dimension():
+    """Test attempting to rename to an existing dimension."""
+    input_file = create_test_las_file()
+    
+    with tempfile.NamedTemporaryFile(suffix='.las', delete=False) as tmp_file:
+        output_file = tmp_file.name
+    
+    try:
+        with pytest.raises(ValueError):
+            rename_dimension(input_file, output_file, ["test_dim"], ["x"])
+    finally:
+        os.unlink(input_file)
+        os.unlink(output_file)
+
+def test_rename_dimension_case_sensitive():
+    """Test that dimension renaming is case-sensitive."""
+    input_file = create_test_las_file()
+    
+    with tempfile.NamedTemporaryFile(suffix='.las', delete=False) as tmp_file:
+        output_file = tmp_file.name
+    
+    try:
+        with pytest.raises(RuntimeError):
+            rename_dimension(input_file, output_file, ["TEST_DIM"], ["new_dim"])
+    finally:
+        os.unlink(input_file)
+        os.unlink(output_file)
+
+
+def test_rename_dimension_main():
+    """Test renaming dimensions using the main() function."""
+    # Create a temporary input LAS file
+    input_file = create_test_las_file()
+    
+    # Create temporary output file
+    with tempfile.NamedTemporaryFile(suffix='.las', delete=False) as tmp_file:
+        output_file = tmp_file.name
+    
+    try:
+        # Save original sys.argv
+        original_argv = sys.argv
+        
+        # Mock command-line arguments
+        sys.argv = [
+            "las_rename_dimension.py",  # script name
+            input_file,
+            output_file,
+            "--old-dims", "test_dim", "test_dim2",
+            "--new-dims", "new_test_dim", "new_test_dim2"
+        ]
+        
+        # Call main() function
+        main()
+        
+        # Restore original sys.argv
+        sys.argv = original_argv
+        
+        # Verify the dimension was renamed
+        with laspy.open(output_file) as las_file:
+            las = las_file.read()
+            assert "new_test_dim" in las.point_format.dimension_names
+            assert "test_dim" not in las.point_format.dimension_names
+            assert "new_test_dim2" in las.point_format.dimension_names
+            assert "test_dim2" not in las.point_format.dimension_names
+            
+            # Verify the data is preserved
+            np.testing.assert_array_equal(las.x, [1.0, 2.0, 3.0])
+            np.testing.assert_array_equal(las.y, [4.0, 5.0, 6.0])
+            np.testing.assert_array_equal(las.z, [7.0, 8.0, 9.0])
+            np.testing.assert_array_equal(las["new_test_dim"], [10.0, 11.0, 12.0])
+            np.testing.assert_array_equal(las["new_test_dim2"], [12, 13, 14])
+    finally:
+        # Clean up temporary files
+        try:
+            os.unlink(input_file)
+            os.unlink(output_file)
+        except:
+            pass

ign_pdal_tools-1.11.1/test/test_pdal_custom.py

@@ -0,0 +1,24 @@
+import os
+
+import pdal
+import pytest
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+
+
+# this test only works with PDAL compiled on a custom fork and branch, so we mark it to avoid running it.
+@pytest.mark.pdal_custom
+def test_pdal_read_severals_extra_dims():
+    test_file = os.path.join(TEST_PATH, "data/las_with_several_extra_byte_bloc.laz")
+
+    pipeline = pdal.Reader.las(filename=test_file).pipeline()
+    metadata = pipeline.quickinfo["readers.las"]
+
+    # dimensions should contains 'Deviation' and 'confidence'
+    assert "Deviation" in metadata["dimensions"]
+    assert "confidence" in metadata["dimensions"]
+
+    # Test Python PDAL bindings
+    pipeline = pdal.Reader.las(filename=test_file).pipeline()
+    num_points = pipeline.execute()
+    assert num_points > 0

ign_pdal_tools-1.11.1/test/test_standardize_format.py

@@ -0,0 +1,339 @@
+import logging
+import os
+import platform
+import shutil
+import subprocess as sp
+from test.utils import EXPECTED_DIMS_BY_DATAFORMAT, get_pdal_infos_summary
+import laspy
+import pdal
+import pytest
+import tempfile
+import sys
+
+from pdaltools.count_occurences.count_occurences_for_attribute import (
+    compute_count_one_file,
+)
+from pdaltools.standardize_format import exec_las2las, rewrite_with_pdal, standardize, main
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+TMP_PATH = os.path.join(TEST_PATH, "tmp")
+INPUT_DIR = os.path.join(TEST_PATH, "data")
+
+DEFAULT_PARAMS = {"dataformat_id": 6, "a_srs": "EPSG:2154", "extra_dims": []}
+DEFAULT_PARAMS_WITH_ALL_EXTRA_DIMS = {"dataformat_id": 6, "a_srs": "EPSG:2154", "extra_dims": "all"}
+
+MUTLIPLE_PARAMS = [
+    DEFAULT_PARAMS,
+    {"dataformat_id": 8, "a_srs": "EPSG:4326", "extra_dims": []},
+    {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": ["dtm_marker=double", "dsm_marker=double"]},
+    {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": "all"},
+]
+
+def setup_module(module):
+    try:
+        shutil.rmtree(TMP_PATH)
+
+    except FileNotFoundError:
+        pass
+    os.mkdir(TMP_PATH)
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        DEFAULT_PARAMS,
+        DEFAULT_PARAMS_WITH_ALL_EXTRA_DIMS,
+        {"dataformat_id": 8, "a_srs": "EPSG:4326", "extra_dims": []},
+        {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": ["dtm_marker=double", "dsm_marker=double"]},
+    ],
+)
+def test_rewrite_with_pdal_format(params):
+    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
+    output_file = os.path.join(TMP_PATH, "formatted.laz")
+    rewrite_with_pdal(input_file, output_file, params, [])
+    # check file exists
+    assert os.path.isfile(output_file)
+    # check values from metadata
+    json_info = get_pdal_infos_summary(output_file)
+    if pdal.info.version < "2.5":
+        raise NotImplementedError("This test is not implemented for pdal < 2.5")
+    elif pdal.info.version <= "2.5.2":
+        metadata = json_info["summary"]["metadata"][1]
+    else:
+        metadata = json_info["summary"]["metadata"]
+    assert metadata["compressed"] is True
+    assert metadata["minor_version"] == 4
+    assert metadata["global_encoding"] == 17
+    assert metadata["dataformat_id"] == params["dataformat_id"]
+    # Check that there is no extra dim
+    dimensions = set([d.strip() for d in json_info["summary"]["dimensions"].split(",")])
+    if params["extra_dims"] == "all":
+        assert EXPECTED_DIMS_BY_DATAFORMAT[params["dataformat_id"]].issubset(dimensions)
+    else:
+        extra_dims_names = [dim.split("=")[0] for dim in params["extra_dims"]]
+        assert dimensions == EXPECTED_DIMS_BY_DATAFORMAT[params["dataformat_id"]].union(extra_dims_names)
+
+    # Check that there is the expected number of points for each class
+    expected_points_counts = compute_count_one_file(input_file)
+
+    output_points_counts = compute_count_one_file(output_file)
+    assert output_points_counts == expected_points_counts
+
+    # TODO: Check srs
+    # TODO: check precision
+
+@pytest.mark.parametrize(
+    "params, rename_dims",
+    [
+        (DEFAULT_PARAMS_WITH_ALL_EXTRA_DIMS, []),  # No renaming
+        (DEFAULT_PARAMS, ["dtm_marker", "new_dtm_marker"]),  # Single dimension rename
+        (DEFAULT_PARAMS_WITH_ALL_EXTRA_DIMS, ["dtm_marker", "new_dtm_marker"]),  # Single dimension rename
+        (DEFAULT_PARAMS_WITH_ALL_EXTRA_DIMS, ["dtm_marker", "new_dtm_marker", "dsm_marker", "new_dsm_marker"]),  # Multiple dimensions rename
+    ],
+)
+def test_rewrite_with_pdal_rename_dimensions(params, rename_dims):
+    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
+    output_file = os.path.join(TMP_PATH, "formatted_with_rename.laz")
+    
+    # Check if we export all extra dims
+    export_with_all_extra_dims = params["extra_dims"] == "all"
+
+    # Get original dimensions
+    with laspy.open(input_file) as las_file:
+        las = las_file.read()
+        original_dims = las.point_format.dimension_names
+    
+    # Standardize with dimension renaming
+    rewrite_with_pdal(input_file, output_file, params, [], rename_dims)
+    
+    # Verify dimensions were renamed
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+
+        for i in range(0, len(rename_dims), 2):
+            old_dim = rename_dims[i]
+            new_dim = rename_dims[i + 1]
+            if export_with_all_extra_dims:
+                assert new_dim in las.point_format.dimension_names
+                assert old_dim not in las.point_format.dimension_names
+            else:
+                assert new_dim not in las.point_format.dimension_names
+                assert old_dim not in las.point_format.dimension_names
+
+        new_dims = las.point_format.dimension_names
+
+        # Make dimensions case-insensitive (ex : red => Red with pdal transform)
+        new_dims_lowercase = [dim.casefold() for dim in new_dims]
+        original_dims_lowercase = [dim.casefold() for dim in original_dims]
+
+        # Check that other dimensions are preserved
+        if export_with_all_extra_dims:
+            for dim in original_dims_lowercase:
+                old_dims_renammed = rename_dims[::2]
+                # If dimension wasn't renamed and is not NIR (wich is 'infrared' in Some las files)
+                if dim not in old_dims_renammed and dim != 'nir':  
+                    assert dim in new_dims_lowercase, f"Original dimension {dim} was removed unexpectedly"
+
+
+    # Verify points count is preserved
+    original_count = compute_count_one_file(input_file)
+    new_count = compute_count_one_file(output_file)
+    assert original_count == new_count, "Points count changed unexpectedly"
+
+
+@pytest.mark.parametrize(
+    "classes_to_remove",
+    [
+        [],
+        [2, 3],
+        [1, 2, 3, 4, 5, 6, 64],  # remove all classes
+    ],
+)
+def test_standardize_classes(classes_to_remove):
+    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
+    output_file = os.path.join(TMP_PATH, "formatted.laz")
+    rewrite_with_pdal(input_file, output_file, DEFAULT_PARAMS, classes_to_remove)
+    # Check that there is the expected number of points for each class
+    expected_points_counts = compute_count_one_file(input_file)
+    for cl in classes_to_remove:
+        expected_points_counts.pop(str(cl))
+
+    output_points_counts = compute_count_one_file(output_file)
+    assert output_points_counts == expected_points_counts
+
+
+def exec_lasinfo(input_file: str):
+    if platform.processor() == "arm" and platform.architecture()[0] == "64bit":
+        lasinfo = "lasinfo64"
+    else:
+        lasinfo = "lasinfo"
+    r = sp.run([lasinfo, "-stdout", input_file], stderr=sp.PIPE, stdout=sp.PIPE)
+    if r.returncode == 1:
+        msg = r.stderr.decode()
+        print(msg)
+        raise RuntimeError(msg)
+
+    output = r.stdout.decode()
+    return output
+
+
+def assert_lasinfo_no_warning(input_file: str):
+    errors = [line for line in exec_lasinfo(input_file).splitlines() if "WARNING" in line]
+
+    for line in errors:
+        print(line)
+
+    assert errors == [], errors
+
+
+def test_exec_las2las_error():
+    with pytest.raises(RuntimeError):
+        exec_las2las("not_existing_input_file", "output_file")
+
+def test_standardize_with_all_options():
+    """
+    Test standardize with all option
+    """
+    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
+    output_file = os.path.join(TMP_PATH, "test_standardize_with_all_extra_dims.laz")
+    
+    rename_dims = ["dtm_marker", "new_dtm_marker", "dsm_marker", "new_dsm_marker"]
+    remove_classes = ["64"]
+
+    # Standardize with all extra dimensions
+    params = DEFAULT_PARAMS_WITH_ALL_EXTRA_DIMS
+    standardize(input_file, output_file, params, remove_classes, rename_dims)
+    
+    # Check that there is the expected number of points for each class
+    expected_points_counts = compute_count_one_file(input_file)
+    for cl in remove_classes:
+        expected_points_counts.pop(str(cl))
+    output_points_counts = compute_count_one_file(output_file)
+    assert output_points_counts == expected_points_counts
+
+    # Get original dimensions
+    with laspy.open(input_file) as las_file:
+        original_las = las_file.read()
+        original_dims = original_las.point_format.dimension_names
+
+    # Verify all extra dimensions are preserved and renamed if needed
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+        new_dims = las.point_format.dimension_names
+        
+        # Make dimensions case-insensitive (ex : red => Red with pdal transform)
+        new_dims_lowercase = [dim.casefold() for dim in new_dims]
+        original_dims_lowercase = [dim.casefold() for dim in original_dims]
+        
+        # Verify all original dimensions are present
+        for dim in original_dims_lowercase:
+            old_dims_renammed = rename_dims[::2]
+            # If dimension wasn't renamed and is not NIR (wich is 'infrared' in Some las files)
+            if dim not in old_dims_renammed and dim != 'nir':
+                assert dim in new_dims_lowercase, f"Original dimension {dim} was removed unexpectedly"
+                    
+
+def test_standardize_does_NOT_produce_any_warning_with_Lasinfo():
+    # bad file on the store (44 Mo)
+    # input_file = (
+    #     "/var/data/store-lidarhd/developpement/standaLAS/demo_standardization/Semis_2022_0584_6880_LA93_IGN69.laz"
+    # )
+
+    input_file = os.path.join(TEST_PATH, "data/classified_laz/test_data_77050_627755_LA93_IGN69.laz")
+    output_file = os.path.join(TMP_PATH, "test_standardize_produce_no_warning_with_lasinfo.las")
+
+    # if you want to see input_file warnings
+    # assert_lasinfo_no_warning(input_file)
+
+    standardize(input_file, output_file, DEFAULT_PARAMS, [], [])
+    assert_lasinfo_no_warning(output_file)
+
+
+def test_standardize_malformed_laz():
+    input_file = os.path.join(TEST_PATH, "data/test_pdalfail_0643_6319_LA93_IGN69.laz")
+    output_file = os.path.join(TMP_PATH, "standardize_pdalfail_0643_6319_LA93_IGN69.laz")
+    standardize(input_file, output_file, DEFAULT_PARAMS, [], [])
+    assert os.path.isfile(output_file)
+
+
+def test_main_with_rename_dimensions():
+    """
+    Test the main function with dimension renaming
+    """
+    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
+    output_file = os.path.join(TMP_PATH, "test_main_with_rename.laz")
+    
+    # Save original sys.argv
+    original_argv = sys.argv
+    
+    try:
+        # Set up mock command-line arguments
+        sys.argv = [
+            "standardize_format",
+            "--input_file", input_file,
+            "--output_file", output_file,
+            "--record_format", "6",
+            "--projection", "EPSG:2154",
+            "--extra_dims", "all",
+            "--rename_dims", "dtm_marker", "new_dtm_marker", "dsm_marker", "new_dsm_marker"
+        ]
+        
+        # Run main function
+        main()
+        
+        # Verify output file exists
+        assert os.path.isfile(output_file)
+        
+        # Verify dimensions were renamed
+        with laspy.open(output_file) as las_file:
+            las = las_file.read()
+            assert "new_dsm_marker" in las.point_format.dimension_names
+            assert "new_dtm_marker" in las.point_format.dimension_names
+            assert "dtm_marker" not in las.point_format.dimension_names
+            assert "dsm_marker" not in las.point_format.dimension_names
+            
+    finally:
+        # Restore original sys.argv
+        sys.argv = original_argv
+
+
+def test_main_with_class_points_removed():
+    """
+    Test the main function with class points removed
+    """
+    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
+    output_file = os.path.join(TMP_PATH, "test_main_with_class_remove.laz")
+    
+    # Save original sys.argv
+    original_argv = sys.argv
+    
+    try:
+        # Set up mock command-line arguments
+        sys.argv = [
+            "standardize_format",
+            "--input_file", input_file,
+            "--output_file", output_file,
+            "--record_format", "6",
+            "--projection", "EPSG:2154",
+            "--class_points_removed", "64"
+        ]
+        
+        # Run main function
+        main()
+        
+        # Verify output file exists
+        assert os.path.isfile(output_file)
+        
+        # Verify points count is reduced
+        original_count = compute_count_one_file(input_file)
+        new_count = compute_count_one_file(output_file)
+        assert new_count < original_count, "Points count should be reduced after removing class 64"
+        
+    finally:
+        # Restore original sys.argv
+        sys.argv = original_argv
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    test_standardize_format()

ign_pdal_tools-1.8.1/test/test_standardize_format.py

@@ -1,159 +0,0 @@
-import logging
-import os
-import platform
-import shutil
-import subprocess as sp
-from test.utils import EXPECTED_DIMS_BY_DATAFORMAT, get_pdal_infos_summary
-
-import pdal
-import pytest
-
-from pdaltools.count_occurences.count_occurences_for_attribute import (
-    compute_count_one_file,
-)
-from pdaltools.standardize_format import exec_las2las, rewrite_with_pdal, standardize
-
-TEST_PATH = os.path.dirname(os.path.abspath(__file__))
-TMP_PATH = os.path.join(TEST_PATH, "tmp")
-INPUT_DIR = os.path.join(TEST_PATH, "data")
-
-DEFAULT_PARAMS = {"dataformat_id": 6, "a_srs": "EPSG:2154", "extra_dims": []}
-
-MUTLIPLE_PARAMS = [
-    DEFAULT_PARAMS,
-    {"dataformat_id": 8, "a_srs": "EPSG:4326", "extra_dims": []},
-    {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": ["dtm_marker=double", "dsm_marker=double"]},
-    {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": "all"},
-]
-
-
-def setup_module(module):
-    try:
-        shutil.rmtree(TMP_PATH)
-
-    except FileNotFoundError:
-        pass
-    os.mkdir(TMP_PATH)
-
-
-@pytest.mark.parametrize(
-    "params",
-    [
-        DEFAULT_PARAMS,
-        {"dataformat_id": 8, "a_srs": "EPSG:4326", "extra_dims": []},
-        {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": ["dtm_marker=double", "dsm_marker=double"]},
-        {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": "all"},
-    ],
-)
-def test_standardize_format(params):
-    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
-    output_file = os.path.join(TMP_PATH, "formatted.laz")
-    rewrite_with_pdal(input_file, output_file, params, [])
-    # check file exists
-    assert os.path.isfile(output_file)
-    # check values from metadata
-    json_info = get_pdal_infos_summary(output_file)
-    if pdal.info.version < "2.5":
-        raise NotImplementedError("This test is not implemented for pdal < 2.5")
-    elif pdal.info.version <= "2.5.2":
-        metadata = json_info["summary"]["metadata"][1]
-    else:
-        metadata = json_info["summary"]["metadata"]
-    assert metadata["compressed"] is True
-    assert metadata["minor_version"] == 4
-    assert metadata["global_encoding"] == 17
-    assert metadata["dataformat_id"] == params["dataformat_id"]
-    # Check that there is no extra dim
-    dimensions = set([d.strip() for d in json_info["summary"]["dimensions"].split(",")])
-    if params["extra_dims"] == "all":
-        assert EXPECTED_DIMS_BY_DATAFORMAT[params["dataformat_id"]].issubset(dimensions)
-    else:
-        extra_dims_names = [dim.split("=")[0] for dim in params["extra_dims"]]
-        assert dimensions == EXPECTED_DIMS_BY_DATAFORMAT[params["dataformat_id"]].union(extra_dims_names)
-
-    # Check that there is the expected number of points for each class
-    expected_points_counts = compute_count_one_file(input_file)
-
-    output_points_counts = compute_count_one_file(output_file)
-    assert output_points_counts == expected_points_counts
-
-    # TODO: Check srs
-    # TODO: check precision
-
-
-@pytest.mark.parametrize(
-    "classes_to_remove",
-    [
-        [],
-        [2, 3],
-        [1, 2, 3, 4, 5, 6, 64],  # remove all classes
-    ],
-)
-def test_standardize_classes(classes_to_remove):
-    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
-    output_file = os.path.join(TMP_PATH, "formatted.laz")
-    rewrite_with_pdal(input_file, output_file, DEFAULT_PARAMS, classes_to_remove)
-    # Check that there is the expected number of points for each class
-    expected_points_counts = compute_count_one_file(input_file)
-    for cl in classes_to_remove:
-        expected_points_counts.pop(str(cl))
-
-    output_points_counts = compute_count_one_file(output_file)
-    assert output_points_counts == expected_points_counts
-
-
-def exec_lasinfo(input_file: str):
-    if platform.processor() == "arm" and platform.architecture()[0] == "64bit":
-        lasinfo = "lasinfo64"
-    else:
-        lasinfo = "lasinfo"
-    r = sp.run([lasinfo, "-stdout", input_file], stderr=sp.PIPE, stdout=sp.PIPE)
-    if r.returncode == 1:
-        msg = r.stderr.decode()
-        print(msg)
-        raise RuntimeError(msg)
-
-    output = r.stdout.decode()
-    return output
-
-
-def assert_lasinfo_no_warning(input_file: str):
-    errors = [line for line in exec_lasinfo(input_file).splitlines() if "WARNING" in line]
-
-    for line in errors:
-        print(line)
-
-    assert errors == [], errors
-
-
-def test_exec_las2las_error():
-    with pytest.raises(RuntimeError):
-        exec_las2las("not_existing_input_file", "output_file")
-
-
-def test_standardize_does_NOT_produce_any_warning_with_Lasinfo():
-    # bad file on the store (44 Mo)
-    # input_file = (
-    #     "/var/data/store-lidarhd/developpement/standaLAS/demo_standardization/Semis_2022_0584_6880_LA93_IGN69.laz"
-    # )
-
-    input_file = os.path.join(TEST_PATH, "data/classified_laz/test_data_77050_627755_LA93_IGN69.laz")
-    output_file = os.path.join(TMP_PATH, "test_standardize_produce_no_warning_with_lasinfo.las")
-
-    # if you want to see input_file warnings
-    # assert_lasinfo_no_warning(input_file)
-
-    standardize(input_file, output_file, DEFAULT_PARAMS, [])
-    assert_lasinfo_no_warning(output_file)
-
-
-def test_standardize_malformed_laz():
-    input_file = os.path.join(TEST_PATH, "data/test_pdalfail_0643_6319_LA93_IGN69.laz")
-    output_file = os.path.join(TMP_PATH, "standardize_pdalfail_0643_6319_LA93_IGN69.laz")
-    standardize(input_file, output_file, DEFAULT_PARAMS, [])
-    assert os.path.isfile(output_file)
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    test_standardize_format()