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

{ign_pdal_tools-1.11.1.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.11.1
+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.11.1.dist-info → ign_pdal_tools-1.12.0.dist-info}/RECORD

@@ -1,9 +1,11 @@
-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
+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
@@ -12,7 +14,7 @@ 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,,
+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,,

pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.11.1"
+__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()