ign-pdal-tools 1.12.0__tar.gz → 1.12.3__tar.gz

{ign_pdal_tools-1.12.0 → ign_pdal_tools-1.12.3}/PKG-INFO

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

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

@@ -1,4 +1,4 @@
-__version__ = "1.12.0"
+__version__ = "1.12.3"
 
 
 if __name__ == "__main__":

{ign_pdal_tools-1.12.0 → ign_pdal_tools-1.12.3}/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",
@@ -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.0 → ign_pdal_tools-1.12.3}/pdaltools/create_random_laz.py

@@ -1,78 +1,82 @@
 import numpy as np
 import laspy
 from pathlib import Path
-import sys
 import argparse
-import pdal
 from pyproj import CRS
-from typing import List, Tuple, Union
+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]] = [],
-                       ):
+
+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)
+        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,
+        "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 
+    # 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: 
+    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)
@@ -80,7 +84,7 @@ def create_random_laz(output_file: str, point_format: int = 3, num_points: int =
             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)
@@ -91,7 +95,7 @@ def create_random_laz(output_file: str, point_format: int = 3, num_points: int =
     }
 
 
-def test_output_file(result : dict, output_file: str):
+def test_output_file(result: dict, output_file: str):
 
     # Validate output file path
     output_path = Path(output_file)
@@ -103,15 +107,6 @@ def test_output_file(result : dict, output_file: str):
     print(f"Number of points: {result['num_points']}")
     print(f"Dimensions available: {result['dimensions']}")
 
-    # Print available dimensions using PDAL
-    pipeline = pdal.Pipeline() | pdal.Reader.las(result['output_file'])
-    pipeline.execute()
-    points = pipeline.arrays[0]
-    dimensions = list(points.dtype.fields.keys())
-    print("\nAvailable dimensions in input file:")
-    for dim in dimensions:
-        print(f"- {dim}")
-
 
 def parse_args():
     # Parse arguments (assuming argparse is used)
@@ -119,28 +114,33 @@ def parse_args():
     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(
+        "--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")
+    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)    
+    test_output_file(result, args.output_file)
+
 
 if __name__ == "__main__":
     main()

{ign_pdal_tools-1.12.0 → ign_pdal_tools-1.12.3}/pdaltools/las_comparison.py

@@ -2,50 +2,58 @@ 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) -> bool:
+
+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
-            
+            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
-            dimensions = dimensions_las1 
+                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. Available dimensions: {las1.point_format.dimension_names}")
-                    return False    
+                    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:
@@ -53,7 +61,7 @@ def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) ->
                 # 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
@@ -63,43 +71,47 @@ def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) ->
                         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
-                    
+                    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
-                
-        return True
-        
+                return False, 0, 0
+
+        return True, 0, 0
+
     except laspy.errors.LaspyException as e:
         print(f"LAS file error: {str(e)}")
-        return False
+        return False, 0, 0
     except FileNotFoundError as e:
         print(f"File not found: {str(e)}")
-        return False
+        return False, 0, 0
     except ValueError as e:
         print(f"Value error: {str(e)}")
-        return False
+        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.')
-    
+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 else 'different'}")
+    print(f"Dimensions comparison result: {'identical' if result[0] else 'different'}")
     return result
 
+
 if __name__ == "__main__":
-    main()
+    main()

{ign_pdal_tools-1.12.0 → ign_pdal_tools-1.12.3}/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.12.0 → ign_pdal_tools-1.12.3}/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.12.0 → ign_pdal_tools-1.12.3}/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.0 → ign_pdal_tools-1.12.3}/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