ign-pdal-tools 1.10.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

{ign_pdal_tools-1.10.0.dist-info → ign_pdal_tools-1.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.10.0
+Version: 1.12.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.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+ign_pdal_tools-1.12.0.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
+pdaltools/_version.py,sha256=uuG85nhWU5wpaYiHuTFYsaS18txZLNqRwMOK8z2G96k,75
+pdaltools/add_points_in_pointcloud.py,sha256=6NclQeAFYyVz3kfJ114BEFKfM5nwWWC2c8iN4IpaPOc,12662
+pdaltools/color.py,sha256=vJgpb8dOvT5rnq5NdVOaMdGc_pKL3damLy4HwGvigJQ,14472
+pdaltools/create_random_laz.py,sha256=RxRzMGZ33xoomu4eh-cLSj4tj5Gy41rBzk08lAKHHzg,5726
+pdaltools/las_add_buffer.py,sha256=rnFExAfi0KqlQpL4hDMh2aC08AcYdSHSB6WPG5RyFIc,11274
+pdaltools/las_clip.py,sha256=GvEOYu8RXV68e35kU8i42GwSkbo4P9TvmS6rkrdPmFM,1034
+pdaltools/las_comparison.py,sha256=pq0fa_kOkysPBBYNNcGg9FFyRLT6IANdPjaGwQALwVU,4193
+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.12.0.dist-info/METADATA,sha256=UAKzHKeQ_jlZB_uwlRWWfeV2vJO1HVEXvIfMu7om554,5778
+ign_pdal_tools-1.12.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ign_pdal_tools-1.12.0.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
+ign_pdal_tools-1.12.0.dist-info/RECORD,,

{ign_pdal_tools-1.10.0.dist-info → ign_pdal_tools-1.12.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.10.0"
+__version__ = "1.12.0"
 
 
 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 sys
+import argparse
+import pdal
+from pyproj import CRS
+from typing import List, Tuple, Union
+
+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']}")
+
+    # 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)
+    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,105 @@
+import laspy
+from pathlib import Path
+import numpy as np
+import argparse
+
+def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) -> bool:
+    """
+    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
+    """
+    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
+            
+        # 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 
+        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    
+
+        # 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
+                    
+            except KeyError:
+                print(f"Dimension '{dim}' not found in one or both files")
+                return False
+                
+        return True
+        
+    except laspy.errors.LaspyException as e:
+        print(f"LAS file error: {str(e)}")
+        return False
+    except FileNotFoundError as e:
+        print(f"File not found: {str(e)}")
+        return False
+    except ValueError as e:
+        print(f"Value error: {str(e)}")
+        return False
+
+# 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 else 'different'}")
+    return result
+
+if __name__ == "__main__":
+    main()

pdaltools/las_rename_dimension.py

@@ -13,20 +13,20 @@ 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.
+    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
-"""
+    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']
+    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)")
@@ -60,18 +60,18 @@ def main():
     )
 
     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)
 
 

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

@@ -1,18 +0,0 @@
-ign_pdal_tools-1.10.0.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
-pdaltools/_version.py,sha256=P7Y6oBanMwNtN5HNsPQJszr9apg6shwS8QyOphkF_c0,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=YSfxLspBPXvDklVztdPxQIK65FeDl7gEgQDWMWpXxm8,2560
-pdaltools/pcd_info.py,sha256=NIAH5KGikVDQLlbCcw9FuaPqe20UZvRfkHsDZd5kmZA,3210
-pdaltools/replace_attribute_in_las.py,sha256=po1F-fi8s7iilqKWaryW4JRbsmdMOUe0yGvG3AEKxtk,4771
-pdaltools/standardize_format.py,sha256=gqm2GJbtDkT4k4oC_NX2LIPh9R2BLh4sMHLKYgfKrMc,3973
-pdaltools/unlock_file.py,sha256=G2odk0cpp_X9r49Y90oK88v3qlihaMfg6acwmWqblik,1958
-ign_pdal_tools-1.10.0.dist-info/METADATA,sha256=nHBXaDPf2WckwbwvyXJZUo0oCz9fgePfI3sfExF2tXw,5778
-ign_pdal_tools-1.10.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-ign_pdal_tools-1.10.0.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
-ign_pdal_tools-1.10.0.dist-info/RECORD,,