ign-pdal-tools 1.7.6__tar.gz → 1.7.8__tar.gz

{ign_pdal_tools-1.7.6 → ign_pdal_tools-1.7.8}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ign-pdal-tools
-Version: 1.7.6
+Version: 1.7.8
 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.6 → ign_pdal_tools-1.7.8}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.6"
+__version__ = "1.7.8"
 
 
 if __name__ == "__main__":

ign_pdal_tools-1.7.8/pdaltools/add_points_in_pointcloud.py

@@ -0,0 +1,159 @@
+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.6 → ign_pdal_tools-1.7.8}/pdaltools/las_info.py

@@ -1,8 +1,10 @@
 import json
 import logging
 import os
+from pathlib import Path
 from typing import Dict, Tuple
 
+import laspy
 import osgeo.osr as osr
 import pdal
 
@@ -50,6 +52,23 @@ def get_tile_origin_using_header_info(filename: str, tile_width: int = 1000) ->
     return infer_tile_origin(minx, maxx, miny, maxy, tile_width)
 
 
+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, tile_width)
+    bbox = (origin_x, origin_y - tile_width, origin_x + tile_width, origin_y)
+    return bbox
+
+
 def get_epsg_from_header_info(metadata):
     if "srs" not in metadata.keys():
         raise RuntimeError("EPSG could not be inferred from metadata: No 'srs' key in metadata.")
@@ -142,7 +161,14 @@ def parse_filename(file: str):
     For example Semis_2021_0000_1111_LA93_IGN69.las"""
     basename = os.path.basename(file)  # Make sure that we work on the base name and not the full path
 
-    prefix1, prefix2, coordx, coordy, suffix = basename.split("_", 4)
+    try:
+        prefix1, prefix2, coordx, coordy, suffix = basename.split("_", 4)
+    except ValueError:
+        raise ValueError(
+            f"Filename {Path(file).name} does not have the expected format. "
+            "Expected prefix1_prefix2_coordx_coordy_suffix"
+        )
+
     prefix = f"{prefix1}_{prefix2}"
 
     return prefix, int(coordx), int(coordy), suffix
@@ -211,3 +237,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.8/test/test_add_points_in_pointcloud.py

@@ -0,0 +1,117 @@
+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)

{ign_pdal_tools-1.7.6 → ign_pdal_tools-1.7.8}/test/test_las_info.py

@@ -45,6 +45,27 @@ def test_get_tile_origin_using_header_info():
     assert (origin_x, origin_y) == (COORD_X * TILE_COORD_SCALE, COORD_Y * TILE_COORD_SCALE)
 
 
+@pytest.mark.parametrize(
+    "tile_filename, tile_width, expected_bbox",
+    [
+        (  # Standard 1000m tile width
+            os.path.join(DATA_PATH, "decimated_laz", "test_semis_2023_0292_6833_LA93_IGN69.laz"),
+            1000,
+            (292000.0, 6832000.0, 293000.0, 6833000.0),
+        ),
+        (
+            # Test 50m tile
+            INPUT_FILE,
+            50,
+            (INPUT_MINS[0], INPUT_MINS[1], INPUT_MAXS[0], INPUT_MAXS[1]),
+        ),
+    ],
+)
+def test_get_tile_bbox(tile_filename, tile_width, expected_bbox):
+    bbox = las_info.get_tile_bbox(tile_filename, tile_width)
+    assert bbox == expected_bbox  # check the bbox from LIDAR tile
+
+
 def test_get_epsg_from_quickinfo_metadata_ok():
     metadata = las_info.las_info_metadata(INPUT_FILE)
     assert las_info.get_epsg_from_header_info(metadata) == "2154"
@@ -136,3 +157,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"

{ign_pdal_tools-1.7.6 → ign_pdal_tools-1.7.8}/test/test_unlock.py

@@ -52,6 +52,10 @@ def test_copy_and_hack_decorator_color():
     assert os.path.isfile(LAS_FILE)
 
 
+@pytest.mark.xfail(
+    reason="Unlock is deprecated as versions of pdal >= 2.7.2 don't raise an error anymore when GlobalEncoding "
+    "is not set correctly for WKT see https://github.com/PDAL/PDAL/releases/tag/2.7.2"
+)
 def test_unlock_file():
     TMP_FILE = os.path.join(TMPDIR, "unlock_file.laz")
     shutil.copy(LAZ_FILE, TMP_FILE)

ign_pdal_tools-1.7.6/pdaltools/add_points_in_pointcloud.py

@@ -1,102 +0,0 @@
-import geopandas as gpd
-import laspy
-import numpy as np
-from shapely.geometry import box
-
-from pdaltools.las_info import get_tile_origin_using_header_info
-
-
-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) -> 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, e.g., 'EPSG:2154'.
-
-    Return:
-        gpd.GeoDataFrame: Points 2d with "Z" value
-    """
-    # Compute the bounding box of the LIDAR tile
-    tile_bbox = get_tile_bbox(input_las)
-
-    # Read the input GeoJSON with 3D points
-    points_gdf = gpd.read_file(input_points)
-
-    # Ensure the CRS matches
-    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, 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).
-        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))
-
-    # Read the existing LIDAR file
-    with laspy.open(input_las, mode="r") as las:
-        las_data = las.read()
-        header = las.header
-
-        # Create a new header if the original header is missing or invalid
-        if header is None:
-            header = laspy.LasHeader(point_format=6, version="1.4")  # Example format and version
-
-        # Append the clipped points to the existing LIDAR data
-        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])
-
-        # Create a new LAS file with updated data
-        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
-
-        # Write the updated LAS file
-        with laspy.open(output_las, mode="w", header=header, do_compress=True) as writer:
-            writer.write_points(updated_las.points)

ign_pdal_tools-1.7.6/test/test_add_points_in_pointcloud.py

@@ -1,82 +0,0 @@
-import os
-from pathlib import Path
-
-import pdal
-
-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():
-    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(INPUT_POINTS, INPUT_FILE, "EPSG:2154")
-    assert len(points_clipped) == 678  # chech the entity's number of points
-
-
-def test_add_line_to_lidar():
-    points_clipped = add_points_in_pointcloud.clip_3d_points_to_tile(INPUT_POINTS, INPUT_FILE, "EPSG:2154")
-
-    add_points_in_pointcloud.add_points_to_las(points_clipped, INPUT_FILE, OUTPUT_FILE, 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():
-    # 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")
-
-    add_points_in_pointcloud.add_points_to_las(points_clipped, INPUT_FILE_SMALL, OUTPUT_FILE_SMALL, 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