ign-pdal-tools 1.7.5__tar.gz → 1.7.7__tar.gz

{ign_pdal_tools-1.7.5 → ign_pdal_tools-1.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ign-pdal-tools
-Version: 1.7.5
+Version: 1.7.7
 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.7.5 → ign_pdal_tools-1.7.7}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ign-pdal-tools
-Version: 1.7.5
+Version: 1.7.7
 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.7.5 → ign_pdal_tools-1.7.7}/ign_pdal_tools.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ ign_pdal_tools.egg-info/dependency_links.txt
 ign_pdal_tools.egg-info/top_level.txt
 pdaltools/_version.py
 pdaltools/add_points_in_las.py
+pdaltools/add_points_in_pointcloud.py
 pdaltools/color.py
 pdaltools/las_add_buffer.py
 pdaltools/las_clip.py
@@ -18,6 +19,7 @@ pdaltools/replace_attribute_in_las.py
 pdaltools/standardize_format.py
 pdaltools/unlock_file.py
 test/test_add_points_in_las.py
+test/test_add_points_in_pointcloud.py
 test/test_color.py
 test/test_las_add_buffer.py
 test/test_las_clip.py

{ign_pdal_tools-1.7.5 → ign_pdal_tools-1.7.7}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.5"
+__version__ = "1.7.7"
 
 
 if __name__ == "__main__":

ign_pdal_tools-1.7.7/pdaltools/add_points_in_pointcloud.py

@@ -0,0 +1,170 @@
+import argparse
+
+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_origin_using_header_info
+
+
+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 get_tile_bbox(input_las, tile_width=1000) -> tuple:
+    """
+    Get the theoretical bounding box (xmin, ymin, xmax, ymax) of a LIDAR tile
+    using its origin and the predefined tile width.
+
+    Args:
+        input_las (str): Path to the LIDAR `.las/.laz` file.
+        tile_width (int): Width of the tile in meters (default: 1000).
+
+    Returns:
+        tuple: Bounding box as (xmin, ymin, xmax, ymax).
+    """
+    origin_x, origin_y = get_tile_origin_using_header_info(input_las)
+    bbox = (origin_x, origin_y - tile_width, origin_x + tile_width, origin_y)
+    return bbox
+
+
+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).
+    """
+    # Check if input points are empty
+    if input_points_with_z.empty:
+        raise ValueError("No points to add. The input GeoDataFrame is empty.")
+
+    # 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.5 → ign_pdal_tools-1.7.7}/pdaltools/las_info.py

@@ -3,6 +3,7 @@ import logging
 import os
 from typing import Dict, Tuple
 
+import laspy
 import osgeo.osr as osr
 import pdal
 
@@ -211,3 +212,20 @@ def get_writer_parameters_from_reader_metadata(metadata: Dict, a_srs=None) -> Di
         "a_srs": a_srs if a_srs else reader_metadata["comp_spatialreference"],
     }
     return params
+
+
+def get_epsg_from_las(filename: str) -> str:
+    """Extract EPSG code from LAS file metadata and return as 'EPSG:XXXX' format.
+
+    Args:
+        filename (str): full path of file for which to get the bounding box
+
+    Returns:
+        str : CRS's value of the data in 'EPSG:XXXX' format, or None if not found.
+    """
+    with laspy.open(filename) as las:
+        crs = las.header.parse_crs()
+        if crs is None:
+            return None  # Return None if CRS is not defined
+        epsg_code = crs.to_epsg()
+        return f"EPSG:{epsg_code}" if epsg_code else None

ign_pdal_tools-1.7.7/test/test_add_points_in_pointcloud.py

@@ -0,0 +1,172 @@
+import inspect
+import os
+from pathlib import Path
+
+import pdal
+import pytest
+
+from pdaltools import add_points_in_pointcloud
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+TMP_PATH = os.path.join(TEST_PATH, "data/output")
+DATA_LIDAR_PATH = os.path.join(TEST_PATH, "data/decimated_laz")
+DATA_POINTS_PATH = os.path.join(TEST_PATH, "data/points_3d")
+
+INPUT_FILE = 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")
+
+INPUT_FILE_SMALL = os.path.join(DATA_LIDAR_PATH, "test_semis_2021_0382_6565_LA93_IGN69.laz")
+INPUT_POINTS_SMALL = os.path.join(DATA_POINTS_PATH, "Points_virtuels_0382_6565.geojson")
+OUTPUT_FILE_SMALL = os.path.join(TMP_PATH, "test_semis_2021_0382_6565_LA93_IGN69.laz")
+
+
+def setup_module(module):
+    os.makedirs("test/data/output", exist_ok=True)
+
+
+def test_get_tile_bbox():
+    bbox = add_points_in_pointcloud.get_tile_bbox(INPUT_FILE, 1000)
+    assert bbox == (292000.0, 6832000.0, 293000.0, 6833000.0)  # check the bbox from LIDAR tile
+
+
+def test_clip_3d_points_to_tile():
+    # With EPSG
+    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(INPUT_POINTS, INPUT_FILE, "EPSG:2154", 1000)
+    assert len(points_clipped) == 678  # chech the entity's number of points
+
+
+def test_clip_3d_points_to_tile_from_epsg_none():
+    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(INPUT_POINTS, INPUT_FILE, None, 1000)
+    assert len(points_clipped) == 678  # chech the entity's number of points
+
+
+def test_add_line_to_lidar():
+    # Ensure the output file doesn't exist before the test
+    if Path(OUTPUT_FILE).exists():
+        os.remove(OUTPUT_FILE)
+
+    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(INPUT_POINTS, INPUT_FILE, "EPSG:2154", 1000)
+
+    add_points_in_pointcloud.add_points_to_las(points_clipped, INPUT_FILE, OUTPUT_FILE, "EPSG:2154", 68)
+    assert Path(OUTPUT_FILE).exists()  # check output exists
+
+    # Filter pointcloud by classes
+    pipeline = (
+        pdal.Reader.las(filename=OUTPUT_FILE, nosrs=True)
+        | pdal.Filter.range(
+            limits="Classification[68:68]",
+        )
+        | pdal.Filter.stats()
+    )
+    pipeline.execute()
+    metadata = pipeline.metadata
+    # Count the pointcloud's number from classe "68"
+    point_count = metadata["metadata"]["filters.stats"]["statistic"][0]["count"]
+    assert point_count == 678
+
+
+def test_add_line_to_lidar_from_epsg_none():
+    # Ensure the output file doesn't exist before the test
+    if Path(OUTPUT_FILE).exists():
+        os.remove(OUTPUT_FILE)
+
+    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(INPUT_POINTS, INPUT_FILE, None, 1000)
+
+    add_points_in_pointcloud.add_points_to_las(points_clipped, INPUT_FILE, OUTPUT_FILE, None, 68)
+    assert Path(OUTPUT_FILE).exists()  # check output exists
+
+    # Filter pointcloud by classes
+    pipeline = (
+        pdal.Reader.las(filename=OUTPUT_FILE, nosrs=True)
+        | pdal.Filter.range(
+            limits="Classification[68:68]",
+        )
+        | pdal.Filter.stats()
+    )
+    pipeline.execute()
+    metadata = pipeline.metadata
+    # Count the pointcloud's number from classe "68"
+    point_count = metadata["metadata"]["filters.stats"]["statistic"][0]["count"]
+    assert point_count == 678
+
+
+def test_get_tile_bbox_small():
+    # Tile is not complete (NOT 1km * 1km)
+    bbox = add_points_in_pointcloud.get_tile_bbox(INPUT_FILE_SMALL, 1000)
+    assert bbox == (382000.0, 6564000.0, 383000.0, 6565000.0)  # return BBOX 1km * 1km
+
+
+def test_add_line_to_lidar_small():
+    # Ensure the output file doesn't exist before the test
+    if Path(OUTPUT_FILE_SMALL).exists():
+        os.remove(OUTPUT_FILE_SMALL)
+
+    # Tile is not complete (NOT 1km * 1km)
+    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(
+        INPUT_POINTS_SMALL, INPUT_FILE_SMALL, "EPSG:2154", 1000
+    )
+
+    add_points_in_pointcloud.add_points_to_las(points_clipped, INPUT_FILE_SMALL, OUTPUT_FILE_SMALL, "EPSG:2154", 68)
+    assert Path(OUTPUT_FILE).exists()  # check output exists
+
+    # Filter pointcloud by classes
+    pipeline = (
+        pdal.Reader.las(filename=OUTPUT_FILE_SMALL, nosrs=True)
+        | pdal.Filter.range(
+            limits="Classification[68:68]",
+        )
+        | pdal.Filter.stats()
+    )
+    pipeline.execute()
+    metadata = pipeline.metadata
+    # Count the pointcloud's number from classe "68"
+    point_count = metadata["metadata"]["filters.stats"]["statistic"][0]["count"]
+    assert point_count == 186
+
+
+def test_add_points_from_geojson_to_las():
+    # 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:2154", 1000
+    )
+    assert Path(OUTPUT_FILE).exists()  # check output exists
+
+
+def test_add_points_from_geojson_to_las_no_epsg():
+    # Ensure the output file doesn't exist before the test
+    if Path(OUTPUT_FILE).exists():
+        os.remove(OUTPUT_FILE)
+
+    INPUT_FILE_WITHOUT_EPSG = os.path.join(TEST_PATH, "data/test_noepsg_043500_629205_IGN69.laz")
+
+    with pytest.raises(RuntimeError, match="does not have a valid EPSG code"):
+        add_points_in_pointcloud.add_points_from_geojson_to_las(
+            INPUT_POINTS, INPUT_FILE_WITHOUT_EPSG, OUTPUT_FILE, 68, None, 1000
+        )
+
+
+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)

{ign_pdal_tools-1.7.5 → ign_pdal_tools-1.7.7}/test/test_las_info.py

@@ -136,3 +136,17 @@ def test_get_writer_parameters_from_reader_metadata():
         out_expected_metadata.pop(key)
 
     assert out_metadata == out_expected_metadata
+
+
+def test_get_epsg_from_las_no_epsg():
+    input_file = os.path.join(DATA_PATH, "test_noepsg_043500_629205_IGN69.laz")
+
+    crs = las_info.get_epsg_from_las(input_file)
+    assert crs is None
+
+
+def test_get_epsg_from_las_with_epsg():
+    input_file = os.path.join(DATA_PATH, "test_data_77050_627755_LA93_IGN69.laz")
+
+    crs = las_info.get_epsg_from_las(input_file)
+    assert crs == "EPSG:2154"