ign-pdal-tools 1.12.2__tar.gz → 1.13.0__tar.gz

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.12.2
+Version: 1.13.0
 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.12.2 → ign_pdal_tools-1.13.0}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.12.2
+Version: 1.13.0
 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.12.2 → ign_pdal_tools-1.13.0}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.12.2"
+__version__ = "1.13.0"
 
 
 if __name__ == "__main__":

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/pdaltools/add_points_in_pointcloud.py

@@ -29,7 +29,7 @@ def parse_args(argv=None):
         "--spatial_ref",
         type=str,
         required=False,
-        help="spatial reference for the writer",
+        help="spatial reference for the writer (eg: 'EPSG:2154')",
     )
     parser.add_argument(
         "--tile_width",
@@ -169,7 +169,7 @@ def add_points_to_las(
         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 |= pdal.Writer.las(filename=output_las, forward="all", extra_dims="all", a_srs=a_srs)
         pipeline.execute()
 
 
@@ -281,7 +281,7 @@ def add_points_from_geometry_to_las(
     gdf = gpd.read_file(input_geometry)
 
     if gdf.crs is None:
-        gdf.set_crs(epsg=spatial_ref, inplace=True)
+        gdf.set_crs(crs=spatial_ref, inplace=True)
 
     # Check if both Z in geometries and altitude_column are provided
     if gdf.geometry.has_z.any() and altitude_column:

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/pdaltools/create_random_laz.py

@@ -8,11 +8,12 @@ from typing import List, Tuple
 
 def create_random_laz(
     output_file: str,
-    point_format: int = 3,
+    point_format: int = 6,
     num_points: int = 100,
     crs: int = 2154,
     center: Tuple[float, float] = (650000, 6810000),
     extra_dims: List[Tuple[str, str]] = [],
+    classifications: List[int] = None,
 ):
     """
     Create a test LAZ file with EPSG code and additional dimensions.
@@ -26,6 +27,7 @@ def create_random_laz(
                 (default: (650000, 6810000) ; around Paris)
         extra_dims: List of tuples (dimension_name, dimension_type) where type can be:
                    'float32', 'float64', 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64'
+        classifications: Optional list of classification values. 
     """
 
     # Create a new point cloud
@@ -52,7 +54,7 @@ def create_random_laz(
         numpy_type = type_mapping[dim_type]
         header.add_extra_dim(laspy.ExtraBytesParams(name=dim_name, type=numpy_type))
 
-        # Create point cloud
+    # Create point cloud
     las = laspy.LasData(header)
     las.header.add_crs(CRS.from_string(f"epsg:{crs}"))
 
@@ -64,14 +66,19 @@ def create_random_laz(
     # Generate random intensity values
     las.intensity = np.random.randint(0, 255, num_points)
 
-    # Generate random classification values
-    # 66 is the max value for classification of IGN LidarHD
-    # cf. https://geoservices.ign.fr/sites/default/files/2022-05/DT_LiDAR_HD_1-0.pdf
-    if point_format > 3:
-        num_classifications = 66
+    # Set classification values
+    if classifications:
+        # Randomly select from the provided classification values
+        las.classification = np.random.choice(classifications, size=num_points, replace=True).astype(np.uint8)
     else:
-        num_classifications = 10
-    las.classification = np.random.randint(0, num_classifications, num_points)
+        # Generate random classification values if not provided
+        # 66 is the max value for classification of IGN LidarHD
+        # cf. https://geoservices.ign.fr/sites/default/files/2022-05/DT_LiDAR_HD_1-0.pdf
+        if point_format >= 6:
+            num_classifications = 66
+        else:
+            num_classifications = 10
+        las.classification = np.random.randint(0, num_classifications, num_points, dtype=np.uint8)
 
     # Generate random values for each extra dimension
     for dim_name, dim_type in extra_dims:
@@ -112,20 +119,24 @@ def parse_args():
     # Parse arguments (assuming argparse is used)
     parser = argparse.ArgumentParser(description="Create a random LAZ file.")
     parser.add_argument("--output_file", type=str, help="Path to save the LAZ file")
-    parser.add_argument("--point_format", type=int, default=3, help="Point format of the LAZ file")
+    parser.add_argument("--point_format", type=int, default=6, help="Point format of the LAZ file")
     parser.add_argument("--num_points", type=int, default=100, help="Number of points to generate")
     parser.add_argument(
         "--extra_dims", type=str, nargs="*", default=[], help="Extra dimensions in the format name:type"
     )
     parser.add_argument("--crs", type=int, default=2154, help="Projection code")
     parser.add_argument(
-        "--center", type=str, default="650000,6810000", help="Center of the area to generate points in"
+        "--center", type=float, nargs=2, default=[650000.0, 6810000.0],
+        help="Center coordinates (x y) of the area to generate points in (space-separated)"
+    )
+    parser.add_argument(
+        "--classifications", type=int, nargs='+',
+        help="List of classification values (space-separated)"
     )
     return parser.parse_args()
 
 
 def main():
-
     # Parse arguments
     args = parse_args()
 
@@ -133,10 +144,21 @@ def main():
     extra_dims = [tuple(dim.split(":")) for dim in args.extra_dims]
 
     # Parse center
-    center = tuple(map(float, args.center.split(",")))
+    center = tuple(args.center[:2])  # Only take first 2 values if more are provided
+    
+    # Parse classifications if provided
+    classifications = args.classifications
 
     # Call create_random_laz
-    result = create_random_laz(args.output_file, args.point_format, args.num_points, args.crs, center, extra_dims)
+    result = create_random_laz(
+        args.output_file, 
+        args.point_format, 
+        args.num_points, 
+        args.crs, 
+        center, 
+        extra_dims,
+        classifications
+    )
 
     # Test output file
     test_output_file(result, args.output_file)

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/pdaltools/las_rename_dimension.py

@@ -5,10 +5,12 @@ This script allows renaming dimensions in a LAS file while preserving all other
 """
 
 import argparse
+import logging
 import pdal
 import sys
 from pathlib import Path
 from pdaltools.las_remove_dimensions import remove_dimensions_from_points
+from pdaltools.las_info import las_info_metadata
 
 
 def rename_dimension(input_file: str, output_file: str, old_dims: list[str], new_dims: list[str]):
@@ -31,8 +33,14 @@ def rename_dimension(input_file: str, output_file: str, old_dims: list[str], new
         if dim in mandatory_dimensions:
             raise ValueError(f"New dimension {dim} cannot be a mandatory dimension (X,Y,Z,x,y,z)")
 
+    metadata = las_info_metadata(input_file)
+    input_dimensions = metadata["dimensions"]
+
     pipeline = pdal.Pipeline() | pdal.Reader.las(input_file)
     for old, new in zip(old_dims, new_dims):
+        if old not in input_dimensions:
+            logging.warning(f"Dimension {old} not found in input file : we cannot rename it")
+            continue
         pipeline |= pdal.Filter.ferry(dimensions=f"{old} => {new}")
     pipeline |= pdal.Writer.las(output_file)
     pipeline.execute()

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/pyproject.toml

@@ -3,18 +3,17 @@ name = "ign-pdal-tools"
 dynamic = ["version"]
 description = "Library for common LAS files manipulation with PDAL"
 readme = "README.md"
-authors = [
-    { name = "Guillaume Liegard", email = "guillaume.liegard@ign.fr" }
-]
+authors = [{ name = "Guillaume Liegard", email = "guillaume.liegard@ign.fr" }]
 
 [tool.setuptools.dynamic]
-version = {attr = "pdaltools._version.__version__"}
+version = { attr = "pdaltools._version.__version__" }
 [tool.setuptools]
-packages = [ "pdaltools" ]
+packages = ["pdaltools"]
 
 [tool.pytest.ini_options]
 markers = [
-    "geopf: marks tests that request the (sometimes unreliable) data.geopf.fr",
+  "geopf: marks tests that request the (sometimes unreliable) data.geopf.fr",
+  "pdal_custom: marks tests that only work with PDAL compiled on a custom fork and branch",
 ]
 
 [tool.black]

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/test/test_add_points_in_pointcloud.py

@@ -12,6 +12,7 @@ from pdaltools import add_points_in_pointcloud
 from pdaltools.count_occurences.count_occurences_for_attribute import (
     compute_count_one_file,
 )
+from pdaltools.las_info import las_info_metadata
 
 TEST_PATH = os.path.dirname(os.path.abspath(__file__))
 TMP_PATH = os.path.join(TEST_PATH, "tmp/add_points_in_pointcloud")
@@ -27,6 +28,7 @@ INPUT_LIGNES_3D_GEOJSON = os.path.join(DATA_LIGNES_PATH, "Lignes_3d_0292_6833.ge
 INPUT_LIGNES_SHAPE = os.path.join(DATA_LIGNES_PATH, "Lignes_3d_0292_6833.shp")
 OUTPUT_FILE = os.path.join(TMP_PATH, "test_semis_2023_0292_6833_LA93_IGN69.laz")
 INPUT_EMPTY_POINTS_2D = os.path.join(DATA_POINTS_3D_PATH, "Points_virtuels_2d_empty.geojson")
+INPUT_PCD_WITH_EXTRA_DIMS = os.path.join(DATA_LIDAR_PATH, "test_semis_2023_0292_6833_LA93_IGN69_extra_dims.laz")
 
 # Cropped las tile used to test adding points that belong to the theorical tile but not to the
 # effective las file extent
@@ -89,6 +91,7 @@ def test_clip_3d_lines_to_tile(input_file, epsg):
         (INPUT_PCD_CROPPED, None, INPUT_POINTS_2D_FOR_CROPPED_PCD, 451),
         # Should also work if there is no points (direct copy of the input file)
         (INPUT_PCD_CROPPED, None, INPUT_EMPTY_POINTS_2D, 0),
+        (INPUT_PCD_WITH_EXTRA_DIMS, None, INPUT_POINTS_2D, 2423),
     ],
 )
 def test_add_points_to_las(input_file, epsg, input_points_2d, expected_nb_points):
@@ -96,10 +99,18 @@ def test_add_points_to_las(input_file, epsg, input_points_2d, expected_nb_points
     if Path(OUTPUT_FILE).exists():
         os.remove(OUTPUT_FILE)
 
+    metadata_in = las_info_metadata(input_file)
+    input_dimensions = metadata_in["dimensions"]
+
     points = gpd.read_file(input_points_2d)
     add_points_in_pointcloud.add_points_to_las(points, input_file, OUTPUT_FILE, epsg, 68)
     assert Path(OUTPUT_FILE).exists()  # check output exists
 
+    metadata_out = las_info_metadata(OUTPUT_FILE)
+    output_dimensions = metadata_out["dimensions"]
+
+    assert input_dimensions == output_dimensions # All dimension should be preserve
+
     point_count = compute_count_one_file(OUTPUT_FILE)["68"]
     assert point_count == expected_nb_points  # Add all points from geojson
 

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/test/test_create_random_laz.py

@@ -138,6 +138,39 @@ def test_create_random_laz_data_ranges():
         assert np.all(las.uint_dim >= 0)
         assert np.all(las.uint_dim <= 100)
 
+@pytest.mark.parametrize(
+    "classifications",
+    [
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+        [1, 2, 3, 66, 68]
+    ]
+)
+def test_create_random_laz_classifications(classifications):
+    """Test that generated data is within expected ranges for different types"""
+    output_file = os.path.join(TMP_PATH, "test_data_ranges.laz")
+    extra_dims = [
+        ("float_dim", "float32"),
+        ("int_dim", "int32"),
+        ("uint_dim", "uint8"),
+    ]
+    create_random_laz(output_file, num_points=1000, extra_dims=extra_dims, classifications=classifications)
+
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+        
+        # Convert to set for faster lookups
+        valid_classifications = set(classifications)
+        
+        # Check that all classification values are in the provided list
+        unique_classes = set(np.unique(las.classification))
+        assert unique_classes.issubset(valid_classifications), \
+            f"Found unexpected classification values: {unique_classes - valid_classifications}"
+            
+        # Also check that we have the expected number of points
+        assert len(las.classification) == 1000, \
+            f"Expected 1000 points, got {len(las.classification)}"
+
 
 def test_main():
     """Test the main function"""
@@ -152,15 +185,17 @@ def test_main():
             "--output_file",
             output_file,
             "--point_format",
-            "3",
+            "6",
             "--num_points",
             "50",
             "--crs",
             "2154",
             "--center",
-            "650000,6810000",
+            "650000", "6810000",
             "--extra_dims",
             "height:float32",
+            "--classifications",
+            "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"
         ]
 
         # Run main function
@@ -174,6 +209,12 @@ def test_main():
             las = las_file.read()
             assert len(las.points) == 50
             assert "height" in las.point_format.dimension_names
+            
+            # Verify classifications are within the provided range
+            unique_classes = set(np.unique(las.classification))
+            expected_classes = set(range(1, 11))  # 1-10
+            assert unique_classes.issubset(expected_classes), \
+                f"Found unexpected classification values: {unique_classes - expected_classes}"
 
     finally:
         # Restore original sys.argv

{ign_pdal_tools-1.12.2 → ign_pdal_tools-1.13.0}/test/test_las_rename_dimension.py

@@ -4,6 +4,7 @@ import tempfile
 import numpy as np
 import laspy
 import sys
+import logging
 from pdaltools.las_rename_dimension import rename_dimension, main
 from pyproj import CRS
 
@@ -68,19 +69,27 @@ def test_rename_dimension():
             pass
 
 
-def test_rename_nonexistent_dimension():
+def test_rename_nonexistent_dimension(caplog):
     """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)
+    
+        try:
+            # Clear any existing log records
+            caplog.clear()
+        
+            # Set the logging level to capture WARNING
+            with caplog.at_level(logging.WARNING):
+                rename_dimension(input_file, output_file, ["nonexistent_dim"], ["new_dim"])
+                
+                # Check that the warning was logged
+                assert len(caplog.records) == 1
+                assert "Dimension nonexistent_dim not found in input file" in caplog.records[0].message
+        finally:
+            os.unlink(input_file)
+            os.unlink(output_file)
 
 
 def test_rename_to_existing_dimension():
@@ -98,19 +107,28 @@ def test_rename_to_existing_dimension():
         os.unlink(output_file)
 
 
-def test_rename_dimension_case_sensitive():
+def test_rename_dimension_case_sensitive(caplog):
     """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:
+            # Clear any existing log records
+            caplog.clear()
+        
+            # Set the logging level to capture WARNING
+            with caplog.at_level(logging.WARNING):
+                rename_dimension(input_file, output_file, ["TEST_DIM"], ["new_dim"])
+                
+                # Check that the warning was logged
+                assert len(caplog.records) == 1
+                assert "Dimension TEST_DIM not found in input file" in caplog.records[0].message
+        finally:
+            os.unlink(input_file)
+            os.unlink(output_file)
 
-    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():