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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.11.1
+Version: 1.12.2
 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.11.1 → ign_pdal_tools-1.12.2}/ign_pdal_tools.egg-info/SOURCES.txt

@@ -8,8 +8,10 @@ ign_pdal_tools.egg-info/top_level.txt
 pdaltools/_version.py
 pdaltools/add_points_in_pointcloud.py
 pdaltools/color.py
+pdaltools/create_random_laz.py
 pdaltools/las_add_buffer.py
 pdaltools/las_clip.py
+pdaltools/las_comparison.py
 pdaltools/las_info.py
 pdaltools/las_merge.py
 pdaltools/las_remove_dimensions.py
@@ -20,8 +22,10 @@ pdaltools/standardize_format.py
 pdaltools/unlock_file.py
 test/test_add_points_in_pointcloud.py
 test/test_color.py
+test/test_create_random_laz.py
 test/test_las_add_buffer.py
 test/test_las_clip.py
+test/test_las_comparison.py
 test/test_las_info.py
 test/test_las_merge.py
 test/test_las_remove_dimensions.py

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

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

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

@@ -1,18 +1,15 @@
 import argparse
-from shutil import copy2
 import tempfile
+from shutil import copy2
 
 import geopandas as gpd
 import laspy
 import numpy as np
-from pyproj import CRS
-from pyproj.exceptions import CRSError
+import pdal
 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")
@@ -223,6 +220,9 @@ def generate_3d_points_from_lines(
                     and Z coordinates are not available in the geometry.
     """
     # Check if altitude_column is provided and exists in the GeoDataFrame
+    if lines_gdf.empty:
+        return lines_gdf
+
     if altitude_column and (altitude_column not in lines_gdf.columns):
         raise ValueError("altitude_column must exist in the GeoDataFrame if provided.")
 

ign_pdal_tools-1.12.2/pdaltools/create_random_laz.py

@@ -0,0 +1,146 @@
+import numpy as np
+import laspy
+from pathlib import Path
+import argparse
+from pyproj import CRS
+from typing import List, Tuple
+
+
+def create_random_laz(
+    output_file: str,
+    point_format: int = 3,
+    num_points: int = 100,
+    crs: int = 2154,
+    center: Tuple[float, float] = (650000, 6810000),
+    extra_dims: List[Tuple[str, str]] = [],
+):
+    """
+    Create a test LAZ file with EPSG code and additional dimensions.
+
+    Args:
+        output_file: Path to save the LAZ file
+        point_format: Point format of the LAZ file (default: 3)
+        num_points: Number of points to generate
+        crs: EPSG code of the CRS (default: 2154)
+        center: Tuple of floats (x, y) of the center of the area to generate points in
+                (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'
+    """
+
+    # Create a new point cloud
+    header = laspy.LasHeader(point_format=point_format, version="1.4")
+
+    # Map string types to numpy types
+    type_mapping = {
+        "float32": np.float32,
+        "float64": np.float64,
+        "int8": np.int8,
+        "int16": np.int16,
+        "int32": np.int32,
+        "int64": np.int64,
+        "uint8": np.uint8,
+        "uint16": np.uint16,
+        "uint32": np.uint32,
+        "uint64": np.uint64,
+    }
+
+    for dim_name, dim_type in extra_dims:
+        if dim_type not in type_mapping:
+            raise ValueError(f"Unsupported dimension type: {dim_type}. Supported types: {list(type_mapping.keys())}")
+
+        numpy_type = type_mapping[dim_type]
+        header.add_extra_dim(laspy.ExtraBytesParams(name=dim_name, type=numpy_type))
+
+        # Create point cloud
+    las = laspy.LasData(header)
+    las.header.add_crs(CRS.from_string(f"epsg:{crs}"))
+
+    # Generate random points in a small area
+    las.x = np.random.uniform(center[0] - 1000, center[0] + 1000, num_points)
+    las.y = np.random.uniform(center[1] - 1000, center[1] + 1000, num_points)
+    las.z = np.random.uniform(0, 200, num_points)
+
+    # 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
+    else:
+        num_classifications = 10
+    las.classification = np.random.randint(0, num_classifications, num_points)
+
+    # Generate random values for each extra dimension
+    for dim_name, dim_type in extra_dims:
+        numpy_type = type_mapping[dim_type]
+
+        # Generate appropriate random values based on the type
+        if numpy_type in [np.float32, np.float64]:
+            las[dim_name] = np.random.uniform(0, 10, num_points).astype(numpy_type)
+        elif numpy_type in [np.int8, np.int16, np.int32, np.int64]:
+            las[dim_name] = np.random.randint(-100, 100, num_points).astype(numpy_type)
+        elif numpy_type in [np.uint8, np.uint16, np.uint32, np.uint64]:
+            las[dim_name] = np.random.randint(0, 100, num_points).astype(numpy_type)
+
+    # Write to file
+    las.write(output_file)
+    dimensions = list(las.point_format.dimension_names)
+    return {
+        "output_file": output_file,
+        "num_points": num_points,
+        "dimensions": dimensions,
+    }
+
+
+def test_output_file(result: dict, output_file: str):
+
+    # Validate output file path
+    output_path = Path(output_file)
+    if not output_path.exists():
+        raise ValueError(f"Error: Output file {output_file} does not exist")
+
+    # Print results
+    print(f"Successfully created test LAZ file at {result['output_file']}")
+    print(f"Number of points: {result['num_points']}")
+    print(f"Dimensions available: {result['dimensions']}")
+
+
+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("--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"
+    )
+    return parser.parse_args()
+
+
+def main():
+
+    # Parse arguments
+    args = parse_args()
+
+    # Parse extra dimensions
+    extra_dims = [tuple(dim.split(":")) for dim in args.extra_dims]
+
+    # Parse center
+    center = tuple(map(float, args.center.split(",")))
+
+    # Call create_random_laz
+    result = create_random_laz(args.output_file, args.point_format, args.num_points, args.crs, center, extra_dims)
+
+    # Test output file
+    test_output_file(result, args.output_file)
+
+
+if __name__ == "__main__":
+    main()

ign_pdal_tools-1.12.2/pdaltools/las_comparison.py

@@ -0,0 +1,117 @@
+import laspy
+from pathlib import Path
+import numpy as np
+import argparse
+from typing import Tuple
+
+
+def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) -> Tuple[bool, int, float]:
+    """
+    Compare specified dimensions between two LAS files.
+    If no dimensions are specified, compares all available dimensions.
+    Sorts points by x,y,z,gps_time coordinates before comparison to ensure point order consistency.
+
+    Args:
+        file1: Path to the first LAS file
+        file2: Path to the second LAS file
+        dimensions: List of dimension names to compare (optional)
+
+    Returns:
+        bool: True if all specified dimensions are identical, False otherwise
+        int: Number of points with different dimensions
+        float: Percentage of points with different dimensions
+    """
+    try:
+        # Read both LAS files
+        las1 = laspy.read(file1)
+        las2 = laspy.read(file2)
+
+        # Check if files have the same number of points
+        if len(las1) != len(las2):
+            print(f"Files have different number of points: {len(las1)} vs {len(las2)}")
+            return False, 0, 0
+        print(f"Files have the same number of points: {len(las1)} vs {len(las2)}")
+
+        # Sort points by x,y,z,gps_time coordinates
+        # Create sorting indices
+        sort_idx1 = np.lexsort((las1.z, las1.y, las1.x, las1.gps_time))
+        sort_idx2 = np.lexsort((las2.z, las2.y, las2.x, las2.gps_time))
+
+        # If no dimensions specified, compare all dimensions
+        dimensions_las1 = sorted(las1.point_format.dimension_names)
+        dimensions_las2 = sorted(las2.point_format.dimension_names)
+
+        if dimensions is None:
+            if dimensions_las1 != dimensions_las2:
+                print("Files have different dimensions")
+                return False, 0, 0
+            dimensions = dimensions_las1
+        else:
+            for dim in dimensions:
+                if dim not in dimensions_las1 or dim not in dimensions_las2:
+                    print(
+                        f"Dimension '{dim}' is not found in one or both files.\n"
+                        f"Available dimensions: {las1.point_format.dimension_names}"
+                    )
+                    return False, 0, 0
+
+        # Compare each dimension
+        for dim in dimensions:
+            try:
+                # Get sorted dimension arrays
+                dim1 = np.array(las1[dim])[sort_idx1]
+                dim2 = np.array(las2[dim])[sort_idx2]
+
+                # Compare dimensions
+                if not np.array_equal(dim1, dim2):
+                    # Find differences
+                    diff_indices = np.where(dim1 != dim2)[0]
+                    print(f"Found {len(diff_indices)} points with different {dim}:")
+                    for idx in diff_indices[:10]:  # Show first 10 differences
+                        print(f"Point {idx}: file1={dim1[idx]}, file2={dim2[idx]}")
+                    if len(diff_indices) > 10:
+                        print(f"... and {len(diff_indices) - 10} more differences")
+                    return False, len(diff_indices), 100 * len(diff_indices) / len(las1)
+
+            except KeyError:
+                print(f"Dimension '{dim}' not found in one or both files")
+                return False, 0, 0
+
+        return True, 0, 0
+
+    except laspy.errors.LaspyException as e:
+        print(f"LAS file error: {str(e)}")
+        return False, 0, 0
+    except FileNotFoundError as e:
+        print(f"File not found: {str(e)}")
+        return False, 0, 0
+    except ValueError as e:
+        print(f"Value error: {str(e)}")
+        return False, 0, 0
+
+
+# Update main function to use the new compare function
+def main():
+    parser = argparse.ArgumentParser(description="Compare dimensions between two LAS files")
+    parser.add_argument("file1", type=str, help="Path to first LAS file")
+    parser.add_argument("file2", type=str, help="Path to second LAS file")
+    parser.add_argument(
+        "--dimensions", nargs="*", help="List of dimensions to compare. If not specified, compares all dimensions."
+    )
+
+    args = parser.parse_args()
+
+    file1 = Path(args.file1)
+    file2 = Path(args.file2)
+
+    if not file1.exists() or not file2.exists():
+        print("Error: One or both files do not exist")
+        exit(1)
+
+    result = compare_las_dimensions(file1, file2, args.dimensions)
+    print(f"Dimensions comparison result: {'identical' if result[0] else 'different'}")
+    return result
+
+
+if __name__ == "__main__":
+    main()

{ign_pdal_tools-1.11.1 → ign_pdal_tools-1.12.2}/pdaltools/replace_attribute_in_las.py

@@ -4,13 +4,12 @@ import argparse
 import json
 import logging
 import os
-import tempfile
 from collections import Counter
 from typing import Dict, List
 
 import pdal
 
-from pdaltools.standardize_format import exec_las2las, get_writer_parameters
+from pdaltools.standardize_format import get_writer_parameters
 from pdaltools.unlock_file import copy_and_hack_decorator
 
 
@@ -106,26 +105,13 @@ def parse_replacement_map_from_path_or_json_string(replacement_map):
     return parsed_map
 
 
-def replace_values_clean(
-    input_file: str,
-    output_file: str,
-    replacement_map: Dict,
-    attribute: str = "Classification",
-    writer_parameters: Dict = {},
-):
-    filename = os.path.basename(output_file)
-    with tempfile.NamedTemporaryFile(suffix=filename) as tmp:
-        replace_values(input_file, tmp.name, replacement_map, attribute, writer_parameters)
-        exec_las2las(tmp.name, output_file)
-
-
 def main():
     args = parse_args()
     writer_params_from_parser = dict(dataformat_id=args.record_format, a_srs=args.projection)
     writer_parameters = get_writer_parameters(writer_params_from_parser)
     replacement_map = parse_replacement_map_from_path_or_json_string(args.replacement_map)
 
-    replace_values_clean(args.input_file, args.output_file, replacement_map, args.attribute, writer_parameters)
+    replace_values(args.input_file, args.output_file, replacement_map, args.attribute, writer_parameters)
 
 
 if __name__ == "__main__":

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

@@ -9,9 +9,6 @@
 """
 
 import argparse
-import os
-import platform
-import subprocess as sp
 import tempfile
 from typing import Dict, List
 
@@ -79,8 +76,8 @@ def get_writer_parameters(new_parameters: Dict) -> Dict:
     params = STANDARD_PARAMETERS | new_parameters
     return params
 
-
-def rewrite_with_pdal(
+@copy_and_hack_decorator
+def standardize(
     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)
@@ -109,32 +106,6 @@ def rewrite_with_pdal(
     pipeline.execute()
 
 
-def exec_las2las(input_file: str, output_file: str):
-    if platform.processor() == "arm" and platform.architecture()[0] == "64bit":
-        las2las = "las2las64"
-    else:
-        las2las = "las2las"
-    r = sp.run([las2las, "-i", input_file, "-o", output_file], stderr=sp.PIPE, stdout=sp.PIPE)
-    if r.returncode == 1:
-        msg = r.stderr.decode()
-        print(msg)
-        raise RuntimeError(msg)
-
-    output = r.stdout.decode()
-    for line in output.splitlines():
-        print(line)
-
-
-@copy_and_hack_decorator
-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, rename_dims)
-        exec_las2las(tmp.name, output_file)
-
-
 def main():
     args = parse_args()
     params_from_parser = dict(

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

@@ -220,6 +220,16 @@ def test_line_to_multipoint(line, spacing, z_value, expected_points):
                 Point(10, 10, 6.0),
             ],
         ),
+        # Test case for empty lines
+        (
+            gpd.GeoDataFrame(
+                {"geometry": [], "RecupZ": []},
+                crs="EPSG:2154",
+            ),
+            2.5,
+            "RecupZ",
+            [],
+        ),
     ],
 )
 def test_generate_3d_points_from_lines(lines_gdf, spacing, altitude_column, expected_points):
@@ -251,7 +261,7 @@ def test_generate_3d_points_from_lines(lines_gdf, spacing, altitude_column, expe
             678,
             0.25,
             "RecupZ",
-        ),  # should add only lignes (.shp) within tile extend
+        ),  # should add only lines (.shp) within tile extend
         (INPUT_PCD, INPUT_LIGNES_SHAPE, None, 678, 0.25, "RecupZ"),  # Should work with or with an input epsg
         (
             INPUT_PCD,
@@ -261,6 +271,14 @@ def test_generate_3d_points_from_lines(lines_gdf, spacing, altitude_column, expe
             0.25,
             None,
         ),  # Should work with or without an input epsg and without altitude_column
+        (
+            INPUT_PCD_CROPPED,
+            INPUT_LIGNES_3D_GEOJSON,
+            None,
+            0,
+            0.25,
+            None,
+        ),  # Should work with lines and add no points if there is no geometry in the tile extent
     ],
 )
 def test_add_points_from_geometry_to_las(input_file, input_points, epsg, expected_nb_points, spacing, altitude_column):
@@ -272,11 +290,11 @@ 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
@@ -287,7 +305,7 @@ def test_add_points_from_geometry_to_las(input_file, input_points, epsg, expecte
     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 → ign_pdal_tools-1.12.2}/test/test_color.py

@@ -315,15 +315,18 @@ def test_is_image_white_false():
     assert not color.is_image_white(input_path), "This image should NOT be detected as white"
 
 
-@pytest.mark.geopf
-def test_color_raise_for_white_image():
-    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
-    output_path = os.path.join(TMPDIR, "sample_lareunion_epsg2975.colorized.white.laz")
-
-    with pytest.raises(ValueError) as excinfo:
-        color.color(input_path, output_path, check_images=True)
-
-    assert "Downloaded image is white" in str(excinfo.value)
+# the test is not working, the image is not detected as white
+# certainly because of a fix on GPF side
+# TODO: find a new area where the GPF returns a white image
+#@pytest.mark.geopf
+#def test_color_raise_for_white_image():
+#    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
+#    output_path = os.path.join(TMPDIR, "sample_lareunion_epsg2975.colorized.white.laz")#
+
+#    with pytest.raises(ValueError) as excinfo:
+#        color.color(input_path, output_path, check_images=True)
+
+#    assert "Downloaded image is white" in str(excinfo.value)
 
 
 @pytest.mark.geopf