ign-pdal-tools 1.7.9__tar.gz → 1.7.11__tar.gz

{ign_pdal_tools-1.7.9 → ign_pdal_tools-1.7.11}/PKG-INFO

@@ -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 → ign_pdal_tools-1.7.11}/ign_pdal_tools.egg-info/PKG-INFO

@@ -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 → ign_pdal_tools-1.7.11}/pdaltools/_version.py

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

ign_pdal_tools-1.7.11/pdaltools/add_points_in_pointcloud.py

@@ -0,0 +1,329 @@
+import argparse
+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 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_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(
+        "--virtual_points_classes",
+        "-c",
+        type=int,
+        default=66,
+        help="classification value to assign to the added virtual points",
+    )
+    parser.add_argument(
+        "--spatial_ref",
+        type=str,
+        required=False,
+        help="spatial reference for the writer",
+    )
+    parser.add_argument(
+        "--tile_width",
+        type=int,
+        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_lines_to_tile(
+    input_lines: gpd.GeoDataFrame, input_las: str, crs: str, tile_width: int = 1000
+) -> gpd.GeoDataFrame:
+    """
+    Select lines from a GeoDataFrame that intersect the the LIDAR tile.
+
+    Args:
+        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).
+
+    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)
+
+    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:
+        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 = 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: int = 66
+):
+    """Add points (3D points in LAZ format) by LIDAR tiles (tiling file)
+
+    Args:
+        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"
+        )
+        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.geometry.z
+    classes = virtual_points_classes * np.ones(nb_points)
+
+    # 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:
+            try:
+                crs_obj = CRS.from_user_input(crs)  # Convert to a pyproj.CRS object
+            except CRSError:
+                raise ValueError(f"Invalid CRS: {crs}")
+            header.add_crs(crs_obj)
+
+    # 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)
+
+        output_las.append_points(new_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])
+
+    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 by LIDAR tiles (tiling file)
+
+    Args:
+        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(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)
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    add_points_from_geometry_to_las(**vars(args))

ign_pdal_tools-1.7.11/test/test_add_points_in_pointcloud.py

@@ -0,0 +1,332 @@
+import inspect
+import os
+from pathlib import Path
+
+import geopandas as gpd
+import laspy
+import numpy as np
+import pytest
+from shapely.geometry import LineString, MultiPoint, Point
+
+from pdaltools import add_points_in_pointcloud
+from pdaltools.count_occurences.count_occurences_for_attribute import (
+    compute_count_one_file,
+)
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+TMP_PATH = os.path.join(TEST_PATH, "tmp/add_points_in_pointcloud")
+DATA_LIDAR_PATH = os.path.join(TEST_PATH, "data/decimated_laz")
+DATA_POINTS_3D_PATH = os.path.join(TEST_PATH, "data/points_3d")
+DATA_LIGNES_PATH = os.path.join(TEST_PATH, "data/lignes_3d")
+
+INPUT_PCD = os.path.join(DATA_LIDAR_PATH, "test_semis_2023_0292_6833_LA93_IGN69.laz")
+INPUT_POINTS_2D = os.path.join(DATA_POINTS_3D_PATH, "Points_virtuels_2d_with_value_z_0292_6833.geojson")
+INPUT_POINTS_3D = os.path.join(DATA_POINTS_3D_PATH, "Points_virtuels_0292_6833.geojson")
+INPUT_LIGNES_2D_GEOJSON = os.path.join(DATA_LIGNES_PATH, "Lignes_2d_0292_6833.geojson")
+INPUT_LIGNES_3D_GEOJSON = os.path.join(DATA_LIGNES_PATH, "Lignes_3d_0292_6833.geojson")
+INPUT_LIGNES_SHAPE = os.path.join(DATA_LIGNES_PATH, "Lignes_3d_0292_6833.shp")
+OUTPUT_FILE = os.path.join(TMP_PATH, "test_semis_2023_0292_6833_LA93_IGN69.laz")
+
+# Cropped las tile used to test adding points that belong to the theorical tile but not to the
+# effective las file extent
+INPUT_PCD_CROPPED = os.path.join(DATA_LIDAR_PATH, "test_semis_2021_0382_6565_LA93_IGN69_cropped.laz")
+INPUT_POINTS_2D_FOR_CROPPED_PCD = os.path.join(
+    DATA_POINTS_3D_PATH, "Points_virtuels_2d_with_value_z_0382_6565.geojson"
+)
+INPUT_POINTS_3D_FOR_CROPPED_PCD = os.path.join(DATA_POINTS_3D_PATH, "Points_virtuels_0382_6565.geojson")
+OUTPUT_FILE_CROPPED_PCD = os.path.join(TMP_PATH, "test_semis_2021_0382_6565_LA93_IGN69.laz")
+
+
+def setup_module(module):
+    os.makedirs(TMP_PATH, exist_ok=True)
+
+
+@pytest.mark.parametrize(
+    "input_file, epsg",
+    [
+        (INPUT_POINTS_2D, "EPSG:2154"),  # should work when providing an epsg value + GeoJSON POINTS 2D
+        (INPUT_POINTS_3D, "EPSG:2154"),  # should work when providing an epsg value + GeoJSON POINTS 3D
+        (INPUT_POINTS_2D, None),  # Should also work with no epsg value (get from las file) + GeoJSON POINTS 2D
+        (INPUT_POINTS_3D, None),  # Should also work with no epsg value (get from las file) + GeoJSON POINTS 3D
+    ],
+)
+def test_clip_3d_points_to_tile(input_file, epsg):
+    points_input = gpd.read_file(input_file)
+    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(points_input, INPUT_PCD, epsg, 1000)
+    assert len(points_clipped) == 678  # check the entity's number of points
+
+
+@pytest.mark.parametrize(
+    "input_file, epsg",
+    # Test on the same geomtries contained in various geometry formats
+    [
+        (INPUT_LIGNES_SHAPE, "EPSG:2154"),  # should work when providing an epsg value + shapefile
+        (INPUT_LIGNES_2D_GEOJSON, "EPSG:2154"),  # should work when providing an epsg value + GeoJSON 2D
+        (INPUT_LIGNES_3D_GEOJSON, "EPSG:2154"),  # should work when providing an epsg value + GeoJSON 3D
+        (INPUT_LIGNES_SHAPE, None),  # Should also work with no epsg value (get from las file) + shapefile
+        (INPUT_LIGNES_2D_GEOJSON, None),  # Should also work with no epsg value (get from las file) + GeoJSON 2D
+        (INPUT_LIGNES_3D_GEOJSON, None),  # Should also work with no epsg value (get from las file) + GeoJSON 3D
+    ],
+)
+def test_clip_3d_lines_to_tile(input_file, epsg):
+    # With lines contained in the LIDAR tile
+    lines_input = gpd.read_file(input_file)
+    lines_clipped = add_points_in_pointcloud.clip_3d_lines_to_tile(lines_input, INPUT_PCD, epsg, 1000)
+    assert len(lines_clipped) == 22  # check the entity's number of lines
+
+    # Without lines contained in the LIDAR tile
+    lines_input = gpd.read_file(input_file)
+    lines_clipped = add_points_in_pointcloud.clip_3d_lines_to_tile(lines_input, INPUT_PCD_CROPPED, epsg, 1000)
+    assert len(lines_clipped) == 0  # check the entity's number of lines
+
+
+@pytest.mark.parametrize(
+    "input_file, epsg, expected_nb_points",
+    [
+        (INPUT_PCD, "EPSG:2154", 2423),  # should work when providing an epsg value
+        (INPUT_PCD, None, 2423),  # Should also work with no epsg value (get from las file)
+        (INPUT_PCD_CROPPED, None, 2423),
+    ],
+)
+def test_add_points_to_las(input_file, epsg, expected_nb_points):
+    # Ensure the output file doesn't exist before the test
+    if Path(OUTPUT_FILE).exists():
+        os.remove(OUTPUT_FILE)
+
+    points = gpd.read_file(INPUT_POINTS_2D)
+    add_points_in_pointcloud.add_points_to_las(points, input_file, OUTPUT_FILE, epsg, 68)
+    assert Path(OUTPUT_FILE).exists()  # check output exists
+
+    point_count = compute_count_one_file(OUTPUT_FILE)["68"]
+    assert point_count == expected_nb_points  # Add all points from geojson
+
+    # Read original and updated point clouds
+    original_las = laspy.read(input_file)
+    updated_las = laspy.read(OUTPUT_FILE)
+
+    original_count = len(original_las.points)
+    added_count = len(points)
+
+    # Check total point count
+    assert len(updated_las.points) == original_count + added_count
+
+    default_zero_fields = [
+        "gps_time",
+        "intensity",
+        "return_number",
+        "number_of_returns",
+        "scan_direction_flag",
+        "edge_of_flight_line",
+        "R",
+        "G",
+        "B",
+    ]
+    # Ensure original points retain their values (gps_tme, intensity, etc)
+    for field in default_zero_fields:
+        if hasattr(updated_las, field):
+            values = getattr(updated_las, field)
+            original_values = getattr(original_las, field)
+            assert np.all(values[:original_count] == original_values[:original_count])
+
+    # Ensure added points have zero values for gps_time, intensity, etc
+    for field in default_zero_fields:
+        if hasattr(updated_las, field):
+            values = getattr(updated_las, field)
+            assert np.all(values[original_count:] == 0)
+
+
+@pytest.mark.parametrize(
+    "line, spacing, z_value, expected_points",
+    [
+        # End point is a multiple of spacing, z_value is provided
+        (
+            LineString([(0, 0), (4, 0)]),
+            2,
+            0.5,
+            [
+                Point(0, 0, 0.5),
+                Point(2, 0, 0.5),
+                Point(4, 0, 0.5),
+            ],
+        ),
+        # End point is not a multiple of spacing, z_value is provided
+        (
+            LineString([(9, 0), (9, 9)]),
+            5,
+            0.5,
+            [Point(9, 0, 0.5), Point(9, 5, 0.5), Point(9, 9, 0.5)],
+        ),
+        # End point is not a multiple of spacing, z_value is provided in point.z instead of z_value
+        (
+            LineString([(0, 0, 1), (4, 0, 1)]),
+            2,
+            0.5,
+            [
+                Point(0, 0, 1),
+                Point(2, 0, 1),
+                Point(4, 0, 1),
+            ],
+        ),
+    ],
+)
+def test_line_to_multipoint(line, spacing, z_value, expected_points):
+    multipoint = add_points_in_pointcloud.line_to_multipoint(line, spacing, z_value)
+    assert multipoint.equals(MultiPoint(expected_points))
+
+
+@pytest.mark.parametrize(
+    "lines_gdf, spacing, altitude_column, expected_points",
+    [
+        # Test case for 2D lines with Z values in "RecupZ"
+        (
+            gpd.GeoDataFrame(
+                {"geometry": [LineString([(0, 0), (10, 0)]), LineString([(10, 0), (10, 10)])], "RecupZ": [5.0, 10.0]},
+                crs="EPSG:2154",
+            ),
+            2.5,
+            "RecupZ",
+            [
+                Point(0, 0, 5.0),
+                Point(2.5, 0, 5.0),
+                Point(5.0, 0, 5.0),
+                Point(7.5, 0, 5.0),
+                Point(10, 0, 5.0),
+                Point(10, 2.5, 10.0),
+                Point(10, 5.0, 10.0),
+                Point(10, 7.5, 10.0),
+                Point(10, 10, 10.0),
+            ],
+        ),
+        # Test case for 3D lines
+        (
+            gpd.GeoDataFrame(
+                {"geometry": [LineString([(0, 0, 3), (10, 0, 3)]), LineString([(10, 0, 6), (10, 10, 6)])]},
+                crs="EPSG:2154",
+            ),
+            2.5,
+            None,
+            [
+                Point(0, 0, 3.0),
+                Point(2.5, 0, 3.0),
+                Point(5.0, 0, 3.0),
+                Point(7.5, 0, 3.0),
+                Point(10, 0, 3.0),
+                Point(10, 2.5, 6.0),
+                Point(10, 5.0, 6.0),
+                Point(10, 7.5, 6.0),
+                Point(10, 10, 6.0),
+            ],
+        ),
+    ],
+)
+def test_generate_3d_points_from_lines(lines_gdf, spacing, altitude_column, expected_points):
+    points_gdf = add_points_in_pointcloud.generate_3d_points_from_lines(lines_gdf, spacing, altitude_column)
+
+    # Check the result
+    assert points_gdf.geometry.tolist() == expected_points
+
+
+@pytest.mark.parametrize(
+    "input_file, input_points, epsg, expected_nb_points, spacing, altitude_column",
+    [
+        (INPUT_PCD, INPUT_POINTS_2D, "EPSG:2154", 678, 0, "RecupZ"),  # should add only points 2.5D within tile extent
+        (INPUT_PCD, INPUT_POINTS_3D, "EPSG:2154", 678, 0, None),  # should add only points 3D within tile extent
+        (INPUT_PCD_CROPPED, INPUT_POINTS_3D_FOR_CROPPED_PCD, "EPSG:2154", 186, 0, None),
+        (INPUT_PCD_CROPPED, INPUT_POINTS_2D_FOR_CROPPED_PCD, "EPSG:2154", 186, 0, "RecupZ"),
+        (
+            INPUT_PCD,
+            INPUT_LIGNES_2D_GEOJSON,
+            "EPSG:2154",
+            678,
+            0.25,
+            "RecupZ",
+        ),  # should add only lines (.GeoJSON) within tile extend
+        (
+            INPUT_PCD,
+            INPUT_LIGNES_SHAPE,
+            "EPSG:2154",
+            678,
+            0.25,
+            "RecupZ",
+        ),  # should add only lignes (.shp) within tile extend
+        (INPUT_PCD, INPUT_LIGNES_SHAPE, None, 678, 0.25, "RecupZ"),  # Should work with or with an input epsg
+        (
+            INPUT_PCD,
+            INPUT_LIGNES_3D_GEOJSON,
+            None,
+            678,
+            0.25,
+            None,
+        ),  # Should work with or without an input epsg and without altitude_column
+    ],
+)
+def test_add_points_from_geometry_to_las(input_file, input_points, epsg, expected_nb_points, spacing, altitude_column):
+    # Ensure the output file doesn't exist before the test
+    if Path(OUTPUT_FILE).exists():
+        os.remove(OUTPUT_FILE)
+
+    add_points_in_pointcloud.add_points_from_geometry_to_las(
+        input_points, input_file, OUTPUT_FILE, 68, epsg, 1000, spacing, altitude_column
+    )
+    assert Path(OUTPUT_FILE).exists()  # check output exists
+    point_count = compute_count_one_file(OUTPUT_FILE)["68"]
+    assert point_count == expected_nb_points  # Add all points from geojson
+
+
+@pytest.mark.parametrize(
+    "input_file, input_points, epsg, spacing, altitude_column",
+    [
+        (INPUT_PCD, INPUT_LIGNES_SHAPE, None, 0, "RecupZ"),  # spacing <= 0
+        (INPUT_PCD, INPUT_LIGNES_SHAPE, None, -5, "RecupZ"),  # spacing < 0
+        (
+            INPUT_PCD,
+            INPUT_LIGNES_3D_GEOJSON,
+            None,
+            0,
+            None,
+        ),  # spacing <= 0
+    ],
+)
+def test_add_points_from_geometry_to_las_nok(input_file, input_points, epsg, spacing, altitude_column):
+    # Ensure the output file doesn't exist before the test
+    if Path(OUTPUT_FILE).exists():
+        os.remove(OUTPUT_FILE)
+
+    with pytest.raises(NotImplementedError, match=".*LineString.*spacing.*"):
+        add_points_in_pointcloud.add_points_from_geometry_to_las(
+            input_points,
+            input_file,
+            OUTPUT_FILE,
+            68,
+            epsg,
+            1000,
+            spacing,
+            altitude_column,
+        )
+
+
+def test_parse_args():
+    # sanity check for arguments parsing
+    args = add_points_in_pointcloud.parse_args(
+        [
+            "--input_geometry",
+            "data/points_3d/Points_virtuels_0292_6833.geojson",
+            "--input_las",
+            "data/decimated_laz/test_semis_2023_0292_6833_LA93_IGN69.laz",
+            "--output_las",
+            "data/output/test_semis_2023_0292_6833_LA93_IGN69.laz",
+            "--virtual_points_classes",
+            "68",
+            "--spatial_ref",
+            "EPSG:2154",
+            "--tile_width",
+            "1000",
+            "--spacing",
+            "0",
+            "--altitude_column",
+            "RecupZ",
+        ]
+    )
+    parsed_args_keys = args.__dict__.keys()
+    main_parameters = inspect.signature(add_points_in_pointcloud.add_points_from_geometry_to_las).parameters.keys()
+    assert set(parsed_args_keys) == set(main_parameters)

ign_pdal_tools-1.7.9/pdaltools/add_points_in_pointcloud.py

@@ -1,159 +0,0 @@
-import argparse
-import shutil
-
-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 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_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(
-        "--virtual_points_classes",
-        "-c",
-        type=int,
-        default=66,
-        help="classification value to assign to the added virtual points",
-    )
-    parser.add_argument(
-        "--spatial_ref",
-        type=str,
-        required=False,
-        help="spatial reference for the writer",
-    )
-    parser.add_argument(
-        "--tile_width",
-        type=int,
-        default=1000,
-        help="width of tiles in meters",
-    )
-
-    return parser.parse_args(argv)
-
-
-def clip_3d_points_to_tile(input_points: str, input_las: str, crs: str, tile_width: int) -> gpd.GeoDataFrame:
-    """
-    Add points from a GeoJSON file in the LIDAR's tile.
-
-    Args:
-        input_points (str): Path to the input GeoJSON file 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)
-
-    # Read the input GeoJSON with 3D points
-    points_gdf = gpd.read_file(input_points)
-
-    if crs:
-        points_gdf = points_gdf.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()
-
-    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
-):
-    """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_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)
-    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))
-
-    with laspy.open(input_las, mode="r") as las:
-        las_data = las.read()
-        header = las.header
-
-        if not header:
-            header = laspy.LasHeader(point_format=8, version="1.4")
-        if crs:
-            try:
-                crs_obj = CRS.from_user_input(crs)  # Convert to a pyproj.CRS object
-            except CRSError:
-                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])
-
-        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
-
-        with laspy.open(output_las, mode="w", header=header, do_compress=True) as writer:
-            writer.write_points(updated_las.points)
-
-
-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
-):
-    """Add points with Z value(GeoJSON format) by LIDAR tiles (tiling file)
-
-    Args:
-        input_geojson (str): Path to the input GeoJSON file 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).
-
-    Raises:
-        RuntimeError: If the input LAS file has no valid EPSG code.
-    """
-    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.")
-
-    # Clip points from GeoJSON by LIDAR tile
-    points_clipped = clip_3d_points_to_tile(input_geojson, 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)
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    add_points_from_geojson_to_las(**vars(args))

ign_pdal_tools-1.7.9/test/test_add_points_in_pointcloud.py

@@ -1,117 +0,0 @@
-import inspect
-import os
-from pathlib import Path
-
-import geopandas as gpd
-import pytest
-
-from pdaltools import add_points_in_pointcloud
-from pdaltools.count_occurences.count_occurences_for_attribute import (
-    compute_count_one_file,
-)
-
-TEST_PATH = os.path.dirname(os.path.abspath(__file__))
-TMP_PATH = os.path.join(TEST_PATH, "tmp/add_points_in_pointcloud")
-DATA_LIDAR_PATH = os.path.join(TEST_PATH, "data/decimated_laz")
-DATA_POINTS_PATH = os.path.join(TEST_PATH, "data/points_3d")
-
-INPUT_PCD = os.path.join(DATA_LIDAR_PATH, "test_semis_2023_0292_6833_LA93_IGN69.laz")
-INPUT_POINTS = os.path.join(DATA_POINTS_PATH, "Points_virtuels_0292_6833.geojson")
-OUTPUT_FILE = os.path.join(TMP_PATH, "test_semis_2023_0292_6833_LA93_IGN69.laz")
-
-# Cropped las tile used to test adding points that belong to the theorical tile but not to the
-# effective las file extent
-INPUT_PCD_CROPPED = os.path.join(DATA_LIDAR_PATH, "test_semis_2021_0382_6565_LA93_IGN69_cropped.laz")
-INPUT_POINTS_FOR_CROPPED_PCD = os.path.join(DATA_POINTS_PATH, "Points_virtuels_0382_6565.geojson")
-OUTPUT_FILE_CROPPED_PCD = os.path.join(TMP_PATH, "test_semis_2021_0382_6565_LA93_IGN69.laz")
-
-
-def setup_module(module):
-    os.makedirs(TMP_PATH, exist_ok=True)
-
-
-@pytest.mark.parametrize(
-    "epsg",
-    [
-        "EPSG:2154",  # should work when providing an epsg value
-        None,  # Should also work with no epsg value (get from las file)
-    ],
-)
-def test_clip_3d_points_to_tile(epsg):
-    # With EPSG
-    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(INPUT_POINTS, INPUT_PCD, epsg, 1000)
-    assert len(points_clipped) == 678  # check the entity's number of points
-
-
-@pytest.mark.parametrize(
-    "input_file, epsg, expected_nb_points",
-    [
-        (INPUT_PCD, "EPSG:2154", 2423),  # should work when providing an epsg value
-        (INPUT_PCD, None, 2423),  # Should also work with no epsg value (get from las file)
-        (INPUT_PCD_CROPPED, None, 2423),
-    ],
-)
-def test_add_points_to_las(input_file, epsg, expected_nb_points):
-    # Ensure the output file doesn't exist before the test
-    if Path(OUTPUT_FILE).exists():
-        os.remove(OUTPUT_FILE)
-
-    points = gpd.read_file(INPUT_POINTS)
-    add_points_in_pointcloud.add_points_to_las(points, input_file, OUTPUT_FILE, epsg, 68)
-    assert Path(OUTPUT_FILE).exists()  # check output exists
-
-    point_count = compute_count_one_file(OUTPUT_FILE)["68"]
-    assert point_count == expected_nb_points  # Add all points from geojson
-
-
-@pytest.mark.parametrize(
-    "input_file, input_points, epsg, expected_nb_points",
-    [
-        (INPUT_PCD, INPUT_POINTS, None, 678),  # should add only points within tile extent
-        (INPUT_PCD_CROPPED, INPUT_POINTS_FOR_CROPPED_PCD, None, 186),
-        (
-            INPUT_PCD_CROPPED,
-            INPUT_POINTS,
-            None,
-            0,
-        ),  # Should add no points when there is only points outside the tile extent
-        (
-            INPUT_PCD_CROPPED,
-            INPUT_POINTS_FOR_CROPPED_PCD,
-            "EPSG:2154",
-            186,
-        ),  # Should work with or without an input epsg
-    ],
-)
-def test_add_points_from_geojson_to_las(input_file, input_points, epsg, expected_nb_points):
-    # Ensure the output file doesn't exist before the test
-    if Path(OUTPUT_FILE).exists():
-        os.remove(OUTPUT_FILE)
-
-    add_points_in_pointcloud.add_points_from_geojson_to_las(input_points, input_file, OUTPUT_FILE, 68, epsg, 1000)
-    assert Path(OUTPUT_FILE).exists()  # check output exists
-    point_count = compute_count_one_file(OUTPUT_FILE)["68"]
-    assert point_count == expected_nb_points  # Add all points from geojson
-
-
-def test_parse_args():
-    # sanity check for arguments parsing
-    args = add_points_in_pointcloud.parse_args(
-        [
-            "--input_geojson",
-            "data/points_3d/Points_virtuels_0292_6833.geojson",
-            "--input_las",
-            "data/decimated_laz/test_semis_2023_0292_6833_LA93_IGN69.laz",
-            "--output_las",
-            "data/output/test_semis_2023_0292_6833_LA93_IGN69.laz",
-            "--virtual_points_classes",
-            "68",
-            "--spatial_ref",
-            "EPSG:2154",
-            "--tile_width",
-            "1000",
-        ]
-    )
-    parsed_args_keys = args.__dict__.keys()
-    main_parameters = inspect.signature(add_points_in_pointcloud.add_points_from_geojson_to_las).parameters.keys()
-    assert set(parsed_args_keys) == set(main_parameters)