ign-pdal-tools 1.7.9__py3-none-any.whl → 1.7.11__py3-none-any.whl

{ign_pdal_tools-1.7.9.dist-info → ign_pdal_tools-1.7.11.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.7.9
+Version: 1.7.11
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
+Dynamic: license-file
 
 # ign-pdal-tools
 

{ign_pdal_tools-1.7.9.dist-info → ign_pdal_tools-1.7.11.dist-info}/RECORD

@@ -1,6 +1,7 @@
-pdaltools/_version.py,sha256=2YxDctk7vFYaW4gZ_YqrDboXUkA5pH4qHhNoYN-p2xc,74
+ign_pdal_tools-1.7.11.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
+pdaltools/_version.py,sha256=lXuB5yCoqB_XdA0YVaGjTGc2J_sFF0RE_IJePTMnyjI,75
 pdaltools/add_points_in_las.py,sha256=TGbt5JUkszjmbQiA2LCUntsjz6A8DHb7QPIXGDuEgWA,3643
-pdaltools/add_points_in_pointcloud.py,sha256=g9V_gUA-vOy3wuYdWXFSObDZtSKO2LhzXa5Vy-yypuA,5684
+pdaltools/add_points_in_pointcloud.py,sha256=UHdC8tFagsehGggkLJCcmBCi8gknJOL4s99f_2TJjsA,12538
 pdaltools/color.py,sha256=-a0ramyLMkZX4-M3siPq1zIio5u-a0p8UzvgcfoU6zU,8313
 pdaltools/las_add_buffer.py,sha256=sBpTywlfsHHS8KuCUa-eydB2hylshEvjrMQt5TrqXb8,11275
 pdaltools/las_clip.py,sha256=GvEOYu8RXV68e35kU8i42GwSkbo4P9TvmS6rkrdPmFM,1034
@@ -11,8 +12,7 @@ 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=pIThdWMNkTph0xgJVVRaM1o9aUMQhM6804PscScB3JI,1963
-ign_pdal_tools-1.7.9.dist-info/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
-ign_pdal_tools-1.7.9.dist-info/METADATA,sha256=hVkIMUlnlbfnsMplmEmwC4sSKdWXS6X1K85XJUhqrkc,5722
-ign_pdal_tools-1.7.9.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-ign_pdal_tools-1.7.9.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
-ign_pdal_tools-1.7.9.dist-info/RECORD,,
+ign_pdal_tools-1.7.11.dist-info/METADATA,sha256=Bh4cFjnGLLt4DpiPw8GQuknhDTrLQqx3H5EjkFzV1n4,5745
+ign_pdal_tools-1.7.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ign_pdal_tools-1.7.11.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
+ign_pdal_tools-1.7.11.dist-info/RECORD,,

{ign_pdal_tools-1.7.9.dist-info → ign_pdal_tools-1.7.11.dist-info}/WHEEL

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

pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.9"
+__version__ = "1.7.11"
 
 
 if __name__ == "__main__":

pdaltools/add_points_in_pointcloud.py

@@ -1,19 +1,21 @@
 import argparse
-import shutil
+from shutil import copy2
 
 import geopandas as gpd
 import laspy
 import numpy as np
 from pyproj import CRS
 from pyproj.exceptions import CRSError
-from shapely.geometry import box
+from shapely.geometry import MultiPoint, Point, box
 
 from pdaltools.las_info import get_epsg_from_las, get_tile_bbox
 
 
 def parse_args(argv=None):
     parser = argparse.ArgumentParser("Add points from GeoJSON in LIDAR tile")
-    parser.add_argument("--input_geojson", "-ig", type=str, required=True, help="Input GeoJSON file")
+    parser.add_argument(
+        "--input_geometry", "-ig", type=str, required=True, help="Input Geometry file (GeoJSON or Shapefile)"
+    )
     parser.add_argument("--input_las", "-i", type=str, required=True, help="Input las file")
     parser.add_argument("--output_las", "-o", type=str, required=True, default="", help="Output las file")
     parser.add_argument(
@@ -35,72 +37,112 @@ def parse_args(argv=None):
         default=1000,
         help="width of tiles in meters",
     )
+    parser.add_argument(
+        "--spacing",
+        type=float,
+        default=0.25,
+        help="spacing between generated points in meters (default. 25 cm)",
+    )
+    parser.add_argument(
+        "--altitude_column",
+        "-z",
+        type=str,
+        required=False,
+        default=None,
+        help="altitude column name from input geometry (use point.z if altitude_column is not set)",
+    )
 
     return parser.parse_args(argv)
 
 
-def clip_3d_points_to_tile(input_points: str, input_las: str, crs: str, tile_width: int) -> gpd.GeoDataFrame:
+def clip_3d_lines_to_tile(
+    input_lines: gpd.GeoDataFrame, input_las: str, crs: str, tile_width: int = 1000
+) -> gpd.GeoDataFrame:
     """
-    Add points from a GeoJSON file in the LIDAR's tile.
+    Select lines from a GeoDataFrame that intersect the the LIDAR tile.
 
     Args:
-        input_points (str): Path to the input GeoJSON file with 3D points.
+        input_lines (gpd.GeoDataFrame): GeoDataFrame with lines.
         input_las (str): Path to the LIDAR `.las/.laz` file.
         crs (str): CRS of the data.
         tile_width (int): Width of the tile in meters (default: 1000).
 
-    Return:
-        gpd.GeoDataFrame: Points 2d with "Z" value
+    Returns:
+        gpd.GeoDataFrame: Lines that intersect with the tile.
     """
     # Compute the bounding box of the LIDAR tile
     tile_bbox = get_tile_bbox(input_las, tile_width)
 
-    # Read the input GeoJSON with 3D points
-    points_gdf = gpd.read_file(input_points)
+    if crs:
+        input_lines = input_lines.to_crs(crs)
+
+    # Create a polygon from the bounding box
+    bbox_polygon = box(*tile_bbox)
+
+    # Clip the lines to the bounding box
+    clipped_lines = input_lines[input_lines.intersects(bbox_polygon)]
+
+    return clipped_lines
+
+
+def clip_3d_points_to_tile(
+    input_points: gpd.GeoDataFrame, input_las: str, crs: str, tile_width: int = 1000
+) -> gpd.GeoDataFrame:
+    """
+    Select points from a GeoDataFrame that intersect the LIDAR tile
+
+    Args:
+        input_points (gpd.GeoDataFrame): GeoDataFrame with 3D points.
+        input_las (str): Path to the LIDAR `.las/.laz` file.
+        crs (str): CRS of the data.
+        tile_width (int): Width of the tile in meters (default: 1000).
+
+    Return:
+        gpd.GeoDataFrame: Points 2D with "Z" value
+    """
+    # Compute the bounding box of the LIDAR tile
+    tile_bbox = get_tile_bbox(input_las, tile_width)
 
     if crs:
-        points_gdf = points_gdf.to_crs(crs)
+        input_points = input_points.to_crs(crs)
 
     # Create a polygon from the bounding box
     bbox_polygon = box(*tile_bbox)
 
     # Clip the points to the bounding box
-    clipped_points = points_gdf[points_gdf.intersects(bbox_polygon)].copy()
+    clipped_points = input_points[input_points.intersects(bbox_polygon)]
 
     return clipped_points
 
 
 def add_points_to_las(
-    input_points_with_z: gpd.GeoDataFrame, input_las: str, output_las: str, crs: str, virtual_points_classes=66
+    input_points_with_z: gpd.GeoDataFrame, input_las: str, output_las: str, crs: str, virtual_points_classes: int = 66
 ):
     """Add points (3D points in LAZ format) by LIDAR tiles (tiling file)
 
     Args:
-        input_points_with_z(gpd.GeoDataFrame): geometry columns (2D points) as encoded to WKT.
+        input_points_with_z (gpd.GeoDataFrame): geometry columns (3D points) as encoded to WKT.
         input_las (str): Path to the LIDAR tiles (LAZ).
         output_las (str): Path to save the updated LIDAR file (LAS/LAZ format).
         crs (str): CRS of the data.
         virtual_points_classes (int): The classification value to assign to those virtual points (default: 66).
     """
-
     if input_points_with_z.empty:
         print(
             "No points to add. All points of the geojson file are outside the tile. Copying the input file to output"
         )
-        shutil.copy(input_las, output_las)
-
         return
 
     # Extract XYZ coordinates and additional attribute (classification)
+    nb_points = len(input_points_with_z.geometry.x)
     x_coords = input_points_with_z.geometry.x
     y_coords = input_points_with_z.geometry.y
-    z_coords = input_points_with_z.RecupZ
-    classes = virtual_points_classes * np.ones(len(input_points_with_z.index))
+    z_coords = input_points_with_z.geometry.z
+    classes = virtual_points_classes * np.ones(nb_points)
 
-    with laspy.open(input_las, mode="r") as las:
-        las_data = las.read()
+    # Open the input LAS file to check and possibly update the header of the output
+    with laspy.open(input_las) as las:
         header = las.header
-
         if not header:
             header = laspy.LasHeader(point_format=8, version="1.4")
         if crs:
@@ -110,45 +152,173 @@ def add_points_to_las(
                 raise ValueError(f"Invalid CRS: {crs}")
             header.add_crs(crs_obj)
 
-        # Append new points
-        new_x = np.concatenate([las_data.x, x_coords])
-        new_y = np.concatenate([las_data.y, y_coords])
-        new_z = np.concatenate([las_data.z, z_coords])
-        new_classes = np.concatenate([las_data.classification, classes])
+    # Copy data pointcloud
+    copy2(input_las, output_las)
+
+    # Add the new points with 3D points
+    nb_points = len(x_coords)
+    with laspy.open(output_las, mode="a", header=header) as output_las:  # mode `a` for adding points
+        # create nb_points points with "0" everywhere
+        new_points = laspy.ScaleAwarePointRecord.zeros(nb_points, header=header)  # use header for input_las
+        # then fill in the gaps (X, Y, Z an classification)
+        new_points.x = x_coords.astype(new_points.x.dtype)
+        new_points.y = y_coords.astype(new_points.y.dtype)
+        new_points.z = z_coords.astype(new_points.z.dtype)
+        new_points.classification = classes.astype(new_points.classification.dtype)
 
-        updated_las = laspy.LasData(header)
-        updated_las.x = new_x
-        updated_las.y = new_y
-        updated_las.z = new_z
-        updated_las.classification = new_classes
+        output_las.append_points(new_points)
 
-        with laspy.open(output_las, mode="w", header=header, do_compress=True) as writer:
-            writer.write_points(updated_las.points)
 
+def line_to_multipoint(line, spacing: float, z_value: float = None):
+    """
+    Convert a LineString to a MultiPoint with equally spaced points and a given Z value.
+
+    Args:
+        line (shapely.geometry.LineString): The input LineString.
+        spacing (float): Spacing between generated points in meters.
+        z_value (float): The Z value to assign to each point.
+
+    Returns:
+        shapely.geometry.MultiPoint: A MultiPoint geometry with the generated points.
+    """
+    # Create points along the line with spacing
+    length = line.length
+    distances = np.arange(0, length + spacing, spacing)
+    points_nd = [line.interpolate(distance) for distance in distances]
+
+    if line.has_z:
+        multipoint = MultiPoint([Point(point.x, point.y, point.z) for point in points_nd])
+    else:
+        if z_value is None:
+            raise ValueError("z_value must be provided for 2D lines.")
+        multipoint = MultiPoint([Point(point.x, point.y, z_value) for point in points_nd])
 
-def add_points_from_geojson_to_las(
-    input_geojson: str, input_las: str, output_las: str, virtual_points_classes: int, spatial_ref: str, tile_width: int
+    return multipoint
+
+
+def generate_3d_points_from_lines(
+    lines_gdf: gpd.GeoDataFrame, spacing: float, altitude_column: str = None
+) -> gpd.GeoDataFrame:
+    """
+    Generate regularly spaced 3D points from 2.5D lines in a GeoJSON file.
+
+    Args:
+        lines_gdf (gpd.GeoDataFrame): GeoDataFrame with 2.5D lines.
+        spacing (float): Spacing between generated points in meters.
+        altitude_column (str, optional): Altitude column name from input geometry.
+        If not provided, use Z from geometry.
+
+    Returns:
+        gpd.GeoDataFrame: GeoDataFrame with generated 3D points.
+
+    Raises:
+        ValueError: If altitude_column is not provided or not found in the GeoDataFrame
+                    and Z coordinates are not available in the geometry.
+    """
+    # Check if altitude_column is provided and exists in the GeoDataFrame
+    if altitude_column and (altitude_column not in lines_gdf.columns):
+        raise ValueError("altitude_column must exist in the GeoDataFrame if provided.")
+
+    if altitude_column:
+        lines_gdf["geometry"] = lines_gdf.apply(
+            lambda row: line_to_multipoint(row.geometry, spacing, row[altitude_column]), axis=1
+        )
+    else:
+        # Check if geometries have Z values
+        if lines_gdf.geometry.has_z.any():
+            lines_gdf["geometry"] = lines_gdf.apply(
+                lambda row: line_to_multipoint(row.geometry, spacing, None), axis=1
+            )
+        else:
+            raise ValueError("Geometries do not have Z values and altitude_column is not provided.")
+
+    # Explode the MultiPoint geometries into individual points
+    points_gdf = lines_gdf.dissolve().explode(index_parts=False).reset_index(drop=True)
+
+    return points_gdf
+
+
+def add_points_from_geometry_to_las(
+    input_geometry: str,
+    input_las: str,
+    output_las: str,
+    virtual_points_classes: int,
+    spatial_ref: str,
+    tile_width: int,
+    spacing: float,
+    altitude_column: str,
 ):
-    """Add points with Z value(GeoJSON format) by LIDAR tiles (tiling file)
+    """Add points with Z value by LIDAR tiles (tiling file)
 
     Args:
-        input_geojson (str): Path to the input GeoJSON file with 3D points.
+        input_geometry (str): Path to the input geometry file (GeoJSON or Shapefile) with 3D points.
         input_las (str): Path to the LIDAR `.las/.laz` file.
         output_las (str): Path to save the updated LIDAR file (LAS/LAZ format).
         virtual_points_classes (int): The classification value to assign to those virtual points (default: 66).
         spatial_ref (str): CRS of the data.
         tile_width (int): Width of the tile in meters (default: 1000).
+        spacing (float): Spacing between generated points in meters.
+        altitude_column (str): Altitude column name from input geometry
 
     Raises:
         RuntimeError: If the input LAS file has no valid EPSG code.
+        ValueError: Unsupported geometry type in the input Geometry file OR
+                    The parameters "spacing" <= 0.
     """
     if not spatial_ref:
         spatial_ref = get_epsg_from_las(input_las)
         if spatial_ref is None:
             raise RuntimeError(f"LAS file {input_las} does not have a valid EPSG code.")
 
+    # Read the input GeoJSON
+    gdf = gpd.read_file(input_geometry)
+
+    if gdf.crs is None:
+        gdf.set_crs(epsg=spatial_ref, inplace=True)
+
+    # Check if both Z in geometries and altitude_column are provided
+    if gdf.geometry.has_z.any() and altitude_column:
+        raise ValueError("Both Z in geometries and altitude_column are provided. Please provide only one.")
+
+    # Store the unique geometry type in a variable
+    unique_geom_type = gdf.geometry.geom_type.unique()
+
+    # Check the geometry type
+    if len(unique_geom_type) != 1:
+        raise ValueError("Several geometry types found in geometry file. This case is not handled.")
+
+    if unique_geom_type in ["Point", "MultiPoint"]:
+        gdf = gdf.explode(index_parts=False).reset_index(drop=True)
+        if altitude_column:
+            # Add the Z dimension from the 'RecupZ' property
+            gdf["geometry"] = gdf.apply(
+                lambda row: Point(row["geometry"].x, row["geometry"].y, row[altitude_column]), axis=1
+            )
+            # If the geometry type is Point, use the points directly
+            points_gdf = gdf[["geometry"]]
+        else:
+            # Add the Z dimension from the Geometry Z
+            gdf["geometry"] = gdf.apply(
+                lambda row: Point(row["geometry"].x, row["geometry"].y, row["geometry"].z), axis=1
+            )
+            # If the geometry type is Point, use the points directly
+            points_gdf = gdf[["geometry"]]
+    elif unique_geom_type in ["LineString", "MultiLineString"]:
+        gdf = gdf.explode(index_parts=False).reset_index(drop=True)
+        gdf = clip_3d_lines_to_tile(gdf, input_las, spatial_ref, tile_width)
+        # If the geometry type is LineString, generate 3D points
+        if spacing <= 0:
+            raise NotImplementedError(
+                f"add_points_from_geometry_to_las requires spacing > 0 to run on (Multi)LineString geometries, \
+                but the values provided are geometry type: {unique_geom_type} and spacing = {spacing} "
+            )
+        else:
+            points_gdf = generate_3d_points_from_lines(gdf, spacing, altitude_column)
+    else:
+        raise ValueError("Unsupported geometry type in the input Geometry file.")
+
     # Clip points from GeoJSON by LIDAR tile
-    points_clipped = clip_3d_points_to_tile(input_geojson, input_las, spatial_ref, tile_width)
+    points_clipped = clip_3d_points_to_tile(points_gdf, input_las, spatial_ref, tile_width)
 
     # Add points by LIDAR tile and save the result
     add_points_to_las(points_clipped, input_las, output_las, spatial_ref, virtual_points_classes)
@@ -156,4 +326,4 @@ def add_points_from_geojson_to_las(
 
 if __name__ == "__main__":
     args = parse_args()
-    add_points_from_geojson_to_las(**vars(args))
+    add_points_from_geometry_to_las(**vars(args))