ign-pdal-tools 1.11.1__py3-none-any.whl → 1.12.2__py3-none-any.whl

{ign_pdal_tools-1.11.1.dist-info → ign_pdal_tools-1.12.2.dist-info}/METADATA

@@ -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.12.2.dist-info/RECORD

@@ -0,0 +1,20 @@
+ign_pdal_tools-1.12.2.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
+pdaltools/_version.py,sha256=hNkZafWzNyaa6UC2MRErLwCS5CjHrj7c2pqE_mjcoug,75
+pdaltools/add_points_in_pointcloud.py,sha256=6NclQeAFYyVz3kfJ114BEFKfM5nwWWC2c8iN4IpaPOc,12662
+pdaltools/color.py,sha256=vJgpb8dOvT5rnq5NdVOaMdGc_pKL3damLy4HwGvigJQ,14472
+pdaltools/create_random_laz.py,sha256=kFe5iHeHlkgKWRIKjK5l1AD65OG4qLYwAZdO1Wcvuos,5255
+pdaltools/las_add_buffer.py,sha256=rnFExAfi0KqlQpL4hDMh2aC08AcYdSHSB6WPG5RyFIc,11274
+pdaltools/las_clip.py,sha256=GvEOYu8RXV68e35kU8i42GwSkbo4P9TvmS6rkrdPmFM,1034
+pdaltools/las_comparison.py,sha256=B9hFGbmD0x4JEN4oHbiQFNbd0T-9P3mnAN67Czu0pZk,4505
+pdaltools/las_info.py,sha256=lMKxKzsViptDENI1wOlANG4qOvdc19ixyasYKD-N1ck,9512
+pdaltools/las_merge.py,sha256=tcFVueV9X9nNEaoAl5zCduY5DETlBg63MAgP2SuKiNo,4121
+pdaltools/las_remove_dimensions.py,sha256=f8imGhN6LNTuQ1GMJQRzIIV3Wab_oRPOyEnKi1CgfiM,2318
+pdaltools/las_rename_dimension.py,sha256=zXEKHyx1uQ3U0oZYo_BTnqbTHGSq5TIZHqZn_EPqNKQ,2576
+pdaltools/pcd_info.py,sha256=NIAH5KGikVDQLlbCcw9FuaPqe20UZvRfkHsDZd5kmZA,3210
+pdaltools/replace_attribute_in_las.py,sha256=MHpIizSupgWtbizteoRH8FKDE049hrAh4v_OhmRmSPU,4318
+pdaltools/standardize_format.py,sha256=I2oNiwhSMtr4e5ZK9qbB_yKmy3twOoO6QLiSFu4_AaI,3905
+pdaltools/unlock_file.py,sha256=G2odk0cpp_X9r49Y90oK88v3qlihaMfg6acwmWqblik,1958
+ign_pdal_tools-1.12.2.dist-info/METADATA,sha256=cOFyIrusuyvAsB_nrIRUaV0Y9h-Nle8ou8FU3POAoAA,5778
+ign_pdal_tools-1.12.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ign_pdal_tools-1.12.2.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
+ign_pdal_tools-1.12.2.dist-info/RECORD,,

pdaltools/_version.py

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

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.")
 

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()

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()

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__":

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.dist-info/RECORD

@@ -1,18 +0,0 @@
-ign_pdal_tools-1.11.1.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
-pdaltools/_version.py,sha256=ePCDD63wucRpBvp1zzN9uerMLecQK4e65Z3lJKH3_4M,75
-pdaltools/add_points_in_pointcloud.py,sha256=13xl8tnoaW6FsRHBPa77-c6Olw8uUw2KBUGoz8JcbBg,12675
-pdaltools/color.py,sha256=vJgpb8dOvT5rnq5NdVOaMdGc_pKL3damLy4HwGvigJQ,14472
-pdaltools/las_add_buffer.py,sha256=rnFExAfi0KqlQpL4hDMh2aC08AcYdSHSB6WPG5RyFIc,11274
-pdaltools/las_clip.py,sha256=GvEOYu8RXV68e35kU8i42GwSkbo4P9TvmS6rkrdPmFM,1034
-pdaltools/las_info.py,sha256=lMKxKzsViptDENI1wOlANG4qOvdc19ixyasYKD-N1ck,9512
-pdaltools/las_merge.py,sha256=tcFVueV9X9nNEaoAl5zCduY5DETlBg63MAgP2SuKiNo,4121
-pdaltools/las_remove_dimensions.py,sha256=f8imGhN6LNTuQ1GMJQRzIIV3Wab_oRPOyEnKi1CgfiM,2318
-pdaltools/las_rename_dimension.py,sha256=zXEKHyx1uQ3U0oZYo_BTnqbTHGSq5TIZHqZn_EPqNKQ,2576
-pdaltools/pcd_info.py,sha256=NIAH5KGikVDQLlbCcw9FuaPqe20UZvRfkHsDZd5kmZA,3210
-pdaltools/replace_attribute_in_las.py,sha256=po1F-fi8s7iilqKWaryW4JRbsmdMOUe0yGvG3AEKxtk,4771
-pdaltools/standardize_format.py,sha256=Z09yhY_dRaX0uNO0K_Ml5ZD3XpVDv4Q2gIyZHXaplAQ,4849
-pdaltools/unlock_file.py,sha256=G2odk0cpp_X9r49Y90oK88v3qlihaMfg6acwmWqblik,1958
-ign_pdal_tools-1.11.1.dist-info/METADATA,sha256=JnMi78wrNuEEwzqfP9ql8AcyBVRZJmazi-fmHUHuKeA,5778
-ign_pdal_tools-1.11.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ign_pdal_tools-1.11.1.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
-ign_pdal_tools-1.11.1.dist-info/RECORD,,