ign-pdal-tools 1.14.0__tar.gz → 1.15.1__tar.gz

{ign_pdal_tools-1.14.0 → ign_pdal_tools-1.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.14.0
+Version: 1.15.1
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown
@@ -128,3 +128,5 @@ To generate a pip package and deploy it on pypi, use the [Makefile](Makefile) at
 To build a docker image with the library installed: `make docker-build`
 
 To test the docker image: `make docker-test`
+
+To build a docker image with a custom version of PDAL: `make docker-build-custom-pdal` ; the custom version is defined in the Makefile (see Makefile for details) 

{ign_pdal_tools-1.14.0 → ign_pdal_tools-1.15.1}/README.md

@@ -119,3 +119,5 @@ To generate a pip package and deploy it on pypi, use the [Makefile](Makefile) at
 To build a docker image with the library installed: `make docker-build`
 
 To test the docker image: `make docker-test`
+
+To build a docker image with a custom version of PDAL: `make docker-build-custom-pdal` ; the custom version is defined in the Makefile (see Makefile for details) 

{ign_pdal_tools-1.14.0 → ign_pdal_tools-1.15.1}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.14.0
+Version: 1.15.1
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown
@@ -128,3 +128,5 @@ To generate a pip package and deploy it on pypi, use the [Makefile](Makefile) at
 To build a docker image with the library installed: `make docker-build`
 
 To test the docker image: `make docker-test`
+
+To build a docker image with a custom version of PDAL: `make docker-build-custom-pdal` ; the custom version is defined in the Makefile (see Makefile for details) 

{ign_pdal_tools-1.14.0 → ign_pdal_tools-1.15.1}/ign_pdal_tools.egg-info/SOURCES.txt

@@ -34,7 +34,7 @@ test/test_las_merge.py
 test/test_las_remove_dimensions.py
 test/test_las_rename_dimension.py
 test/test_pcd_info.py
-test/test_pdal_custom.py
+test/test_pdal.py
 test/test_replace_area_in_pointcloud.py
 test/test_replace_attribute_in_las.py
 test/test_standardize_format.py

{ign_pdal_tools-1.14.0 → ign_pdal_tools-1.15.1}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.14.0"
+__version__ = "1.15.1"
 
 
 if __name__ == "__main__":

{ign_pdal_tools-1.14.0 → ign_pdal_tools-1.15.1}/pdaltools/las_info.py

@@ -254,3 +254,19 @@ def get_epsg_from_las(filename: str) -> str:
             return None  # Return None if CRS is not defined
         epsg_code = crs.to_epsg()
         return f"EPSG:{epsg_code}" if epsg_code else None
+
+
+def list_dims(las_filename):
+    """List dimensions
+
+    Args:
+        las_file (_type_): _description_
+
+    Returns:
+        List<String>: Dimensions names
+    """
+    pipeline = pdal.Pipeline()
+    pipeline |= pdal.Reader.las(filename=las_filename)
+    pipeline.execute()
+
+    return list(pipeline.arrays[0].dtype.fields.keys())

ign_pdal_tools-1.15.1/pdaltools/replace_area_in_pointcloud.py

@@ -0,0 +1,213 @@
+import argparse
+import warnings
+
+import numpy as np
+import pdal
+from numpy.lib import recfunctions as rfn
+from osgeo import gdal
+
+from pdaltools.las_info import get_writer_parameters_from_reader_metadata
+
+
+def argument_parser():
+    parser = argparse.ArgumentParser(
+        "Replace points in a pointcloud, based on an area. "
+        "Source may come from from another pointcloud (command from_cloud), "
+        "or may be derivated from a digital surface model (command from_DSM).\n"
+    )
+    subparsers = parser.add_subparsers(required=True)
+
+    # first command is 'from_cloud'
+    from_cloud = subparsers.add_parser("from_cloud", help="Source is a point cloud")
+    from_cloud.add_argument("--source_cloud", "-s", required=True, type=str, help="path of source point cloud")
+    add_common_options(from_cloud)
+    from_cloud.set_defaults(func=from_cloud_func)
+
+    # second command is 'from_DSM'
+    from_DSM = subparsers.add_parser("from_DSM", help="Source is a digital surface model (DSM)")
+    from_DSM.add_argument(
+        "--source_dsm",
+        "-d",
+        required=True,
+        type=str,
+        help="path of the source digital surface model (DSM), used to generate source points",
+    )
+    from_DSM.add_argument(
+        "--source_ground_area",
+        "-g",
+        required=True,
+        type=str,
+        help=(
+            "area of the ground, used to intersect source cloud. "
+            "(shapefile, geojson or other format readable by GDAL)"
+        ),
+    )
+    from_DSM.add_argument(
+        "--source_classification",
+        "-c",
+        required=True,
+        type=int,
+        help="classification to apply to the points extracted from the DSM",
+    )
+    add_common_options(from_DSM)
+    from_DSM.set_defaults(func=from_DSM_func)
+
+    return parser
+
+
+def add_common_options(parser):
+    parser.add_argument(
+        "--source_pdal_filter", "-f", type=str, help="pdal filter expression to apply to source point cloud"
+    )
+    parser.add_argument("--target_cloud", "-t", type=str, required=True, help="path of target cloud to be modified")
+    parser.add_argument(
+        "--replacement_area",
+        "-r",
+        required=True,
+        type=str,
+        help="area to replace (shapefile, geojson or other format readable by GDAL)",
+    )
+    parser.add_argument("--output_cloud", "-o", required=True, type=str, help="output cloud file")
+
+
+def from_cloud_func(args):
+    replace_area(
+        target_cloud=args.target_cloud,
+        pipeline_source=pipeline_read_from_cloud(args.source_cloud),
+        replacement_area=args.replacement_area,
+        output_cloud=args.output_cloud,
+        source_pdal_filter=args.source_pdal_filter,
+    )
+
+
+def from_DSM_func(args):
+    replace_area(
+        target_cloud=args.target_cloud,
+        pipeline_source=pipeline_read_from_DSM(
+            dsm=args.source_dsm, ground_area=args.source_ground_area, classification=args.source_classification
+        ),
+        replacement_area=args.replacement_area,
+        output_cloud=args.output_cloud,
+        source_pdal_filter=args.source_pdal_filter,
+    )
+
+
+def get_writer_params(input_file):
+    pipeline = pdal.Pipeline()
+    pipeline |= pdal.Reader.las(filename=input_file)
+    pipeline.execute()
+    params = get_writer_parameters_from_reader_metadata(pipeline.metadata)
+    return params
+
+
+def pipeline_read_from_cloud(filename):
+    pipeline_source = pdal.Pipeline()
+    pipeline_source |= pdal.Reader.las(filename=filename)
+    return pipeline_source
+
+
+def pipeline_read_from_DSM(dsm, ground_area, classification):
+    # get nodata value
+    ds = gdal.Open(dsm)
+    band = ds.GetRasterBand(1)
+    nodata_value = band.GetNoDataValue()
+    ds.Close()
+
+    pipeline = pdal.Pipeline()
+    pipeline |= pdal.Reader.gdal(filename=dsm, header="Z")
+    pipeline |= pdal.Filter.expression(expression=f"Z != {nodata_value}")
+
+    pipeline |= pdal.Filter.ferry(dimensions="=> geometryFid")
+    pipeline |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
+    pipeline |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=ground_area)
+    # Keep only points in the area
+    pipeline |= pdal.Filter.expression(expression="geometryFid>=0")
+
+    # assign class
+    pipeline |= pdal.Filter.ferry(dimensions="=>Classification")
+    pipeline |= pdal.Filter.assign(assignment=f"Classification[:]={classification}")
+
+    return pipeline
+
+
+def replace_area(
+    target_cloud, pipeline_source, replacement_area, output_cloud, source_pdal_filter="", target_pdal_filter=""
+):
+    crops = []
+    # pipeline to read target_cloud and remove points inside the polygon
+    pipeline_target = pdal.Pipeline()
+    pipeline_target |= pdal.Reader.las(filename=target_cloud)
+    pipeline_target |= pdal.Filter.ferry(dimensions="=> geometryFid")
+    # Assign -1 to all points because overlay replaces values from 0 and more
+    pipeline_target |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
+    if target_pdal_filter:
+        pipeline_target |= pdal.Filter.expression(expression=target_pdal_filter)
+    pipeline_target |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=replacement_area)
+    # Keep only points out of the area
+    pipeline_target |= pdal.Filter.expression(expression="geometryFid==-1", tag="A")
+    pipeline_target.execute()
+
+    # get input dimensions dtype from target
+    if pipeline_target.arrays:
+        input_dim_dtype = pipeline_target.arrays[0].dtype
+    else:
+        # re-read the LAS only if we cant have dimensions with previous pipeline (empty output)
+        pipeline_target2 = pdal.Pipeline()
+        pipeline_target2 |= pdal.Reader.las(filename=target_cloud)
+        pipeline_target2.execute()
+        input_dim_dtype = pipeline_target2.arrays[0].dtype
+
+    # get input dimensions names
+    input_dimensions = list(input_dim_dtype.fields.keys())
+
+    # do not keep geometryFid
+    output_dimensions = [dim for dim in input_dimensions if dim not in "geometryFid"]
+
+    # add target to the result after keeping only the expected dimensions
+    if pipeline_target.arrays:
+        target_cloud_pruned = pipeline_target.arrays[0][output_dimensions]
+        crops.append(target_cloud_pruned)
+
+    # pipeline to read source_cloud and remove points outside the polygon
+    pipeline_source |= pdal.Filter.ferry(dimensions="=> geometryFid")
+    pipeline_source |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
+    if source_pdal_filter:
+        pipeline_source |= pdal.Filter.expression(expression=source_pdal_filter)
+    pipeline_source |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=replacement_area)
+    # Keep only points in the area
+    pipeline_source |= pdal.Filter.expression(expression="geometryFid>=0", tag="B")
+    pipeline_source.execute()
+
+    # add source to the result
+    if pipeline_source.arrays:
+        # eventually add dimensions in source to have same dimensions as target cloud
+        # we do that in numpy (instead of PDAL filter) to keep dimension types
+        source_cloud_crop = pipeline_source.arrays[0]
+        nb_points = source_cloud_crop.shape[0]
+        source_dims = source_cloud_crop.dtype.fields.keys()
+        for dim_name, dim_type in input_dim_dtype.fields.items():
+            if dim_name not in source_dims:
+                source_cloud_crop = rfn.append_fields(
+                    base=source_cloud_crop,
+                    names=dim_name,
+                    data=np.zeros(nb_points, dtype=dim_type[0]),
+                    dtypes=dim_type[0],
+                )
+
+        source_cloud_pruned = source_cloud_crop[output_dimensions]
+        crops.append(source_cloud_pruned)
+
+    # Merge
+    if not crops:
+        warnings.warn("WARNING: Empty LAS, extra dims are lost")
+
+    pipeline = pdal.Filter.merge().pipeline(*crops)
+
+    writer_params = get_writer_params(target_cloud)
+    pipeline |= pdal.Writer.las(filename=output_cloud, **writer_params)
+    pipeline.execute()
+
+
+if __name__ == "__main__":
+    args = argument_parser().parse_args()
+    args.func(args)

{ign_pdal_tools-1.14.0 → ign_pdal_tools-1.15.1}/pyproject.toml

@@ -13,7 +13,6 @@ packages = ["pdaltools"]
 [tool.pytest.ini_options]
 markers = [
   "geopf: marks tests that request the (sometimes unreliable) data.geopf.fr",
-  "pdal_custom: marks tests that only work with PDAL compiled on a custom fork and branch",
 ]
 
 [tool.black]

ign_pdal_tools-1.14.0/test/test_pdal_custom.py → ign_pdal_tools-1.15.1/test/test_pdal.py

@@ -5,10 +5,11 @@ import pytest
 
 TEST_PATH = os.path.dirname(os.path.abspath(__file__))
 
+#this test files concatenate somes tests on PDAL features
+#it allows us to test the PDAL version used in the library is modern enough
 
-# this test only works with PDAL compiled on a custom fork and branch, so we mark it to avoid running it.
-@pytest.mark.pdal_custom
 def test_pdal_read_severals_extra_dims():
+# test that we can read a las file with several extra dims
     test_file = os.path.join(TEST_PATH, "data/las_with_several_extra_byte_bloc.laz")
 
     pipeline = pdal.Reader.las(filename=test_file).pipeline()

ign_pdal_tools-1.15.1/test/test_replace_area_in_pointcloud.py

@@ -0,0 +1,339 @@
+import os
+import shutil
+import test.utils as tu
+
+import laspy
+import numpy as np
+import pdal
+import pytest
+
+from pdaltools.count_occurences.count_occurences_for_attribute import (
+    compute_count_one_file,
+)
+from pdaltools.las_info import list_dims
+from pdaltools.replace_area_in_pointcloud import (
+    argument_parser,
+    pipeline_read_from_cloud,
+    pipeline_read_from_DSM,
+    replace_area,
+)
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+TMP_PATH = os.path.join(TEST_PATH, "tmp/replace_area_in_pointcloud")
+INPUT_DIR = os.path.join(TEST_PATH, "data/replace_area_in_pointcloud")
+
+TARGET_CLOUD = os.path.join(INPUT_DIR, "target_cloud_crop.laz")
+REPLACE_AREA = os.path.join(INPUT_DIR, "replace_area.geojson")
+
+# source may be a cloud
+SOURCE_CLOUD = os.path.join(INPUT_DIR, "source_cloud_crop.laz")
+
+# source may be a digital surface model
+SOURCE_DSM = os.path.join(INPUT_DIR, "DSM.tif")
+SOURCE_GROUND_AREA = os.path.join(INPUT_DIR, "ground_area.geojson")
+SOURCE_CLASSIF = 68
+
+TMP_EXTRA_DIMS = os.path.join(TMP_PATH, "input_with_extra_dims")
+TARGET_EXTRA_DIM = os.path.join(TMP_EXTRA_DIMS, "target_cloud_crop_extra_dim.laz")
+
+
+def setup_module(module):
+    try:
+        shutil.rmtree(TMP_PATH)
+
+    except FileNotFoundError:
+        pass
+    os.mkdir(TMP_PATH)
+
+    # target file with extra dims is used is severals tests.
+    generate_target_extra_dim()
+
+
+def generate_extra_dim(input, output, new_dims):
+    pipeline = pdal.Pipeline() | pdal.Reader.las(input)
+    for dim in new_dims.keys():
+        pipeline |= pdal.Filter.ferry(dimensions=f"=>{dim}")
+        pipeline |= pdal.Filter.assign(assignment=f"{dim}[:]=1")
+
+    extra_dims = ",".join(f"{k}={v}" for k, v in new_dims.items())
+    pipeline |= pdal.Writer.las(output, forward="all", extra_dims=extra_dims)
+    pipeline.execute()
+
+
+def generate_target_extra_dim():
+    """generate target with an extra dim target with value 1, and target2"""
+
+    os.makedirs(TMP_EXTRA_DIMS)
+    generate_extra_dim(input=TARGET_CLOUD, output=TARGET_EXTRA_DIM, new_dims={"target": "uint16", "target2": "uint8"})
+
+    target_dims = list_dims(TARGET_EXTRA_DIM)
+    assert "target" in target_dims, "target should have 'target' dimension"
+    assert "target2" in target_dims, "target should have 'target2' dimension"
+
+
+# Utils functions
+def get_nb_points(path):
+    """Get number of points in a las file"""
+    with laspy.open(path) as f:
+        nb_points = f.header.point_count
+
+    return nb_points
+
+
+def test_replace_area_base():
+    output_file = os.path.join(TMP_PATH, "test_replace_area", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+
+    replace_area(
+        target_cloud=TARGET_CLOUD,
+        pipeline_source=pipeline_read_from_cloud(SOURCE_CLOUD),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+    )
+    # Check that we have the expected number of points in the output
+    assert get_nb_points(output_file) == 6461
+
+    # Check that there are only points from the target pointcloud outside the replacement geometry
+    output_file_outside_geometry = os.path.join(os.path.dirname(output_file), "replaced_outside_area.laz")
+    pipeline = pdal.Pipeline()
+    pipeline |= pdal.Reader.las(filename=output_file)
+    pipeline |= pdal.Filter.ferry(dimensions="=> geometryFid")
+    pipeline |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
+    pipeline |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=REPLACE_AREA)
+    pipeline |= pdal.Filter.expression(expression="geometryFid==-1")
+    pipeline |= pdal.Writer.las(filename=output_file_outside_geometry)
+    pipeline.execute()
+    counts_outside_area = compute_count_one_file(output_file_outside_geometry, "Classification")
+    assert counts_outside_area == {"1": 3841, "2": 2355}
+
+    # Check that there are only points from the source pointcloud inside the replacement geometry
+    output_file_in_area = os.path.join(os.path.dirname(output_file), "replaced_in_area.laz")
+    pipeline = pdal.Pipeline()
+    pipeline |= pdal.Reader.las(filename=output_file)
+    pipeline |= pdal.Filter.ferry(dimensions="=> geometryFid")
+    pipeline |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
+    pipeline |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=REPLACE_AREA)
+    pipeline |= pdal.Filter.expression(expression="geometryFid>=0")
+    pipeline |= pdal.Writer.las(filename=output_file_in_area)
+    pipeline.execute()
+    counts_in_area = compute_count_one_file(output_file_in_area, "Classification")
+
+    assert counts_in_area == {"0": 265}
+
+    # Check output dimensions are the same as input dimensions
+    target_dimensions = tu.get_pdal_infos_summary(TARGET_CLOUD)["summary"]["dimensions"].split(",")
+    output_dimensions = tu.get_pdal_infos_summary(output_file)["summary"]["dimensions"].split(",")
+
+    assert output_dimensions == target_dimensions
+
+
+def test_replace_area_with_target_filter():
+    filter = "Classification==2"
+    output_file = os.path.join(TMP_PATH, "test_replace_with_target_filter", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+    replace_area(
+        target_cloud=TARGET_CLOUD,
+        pipeline_source=pipeline_read_from_cloud(SOURCE_CLOUD),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+        target_pdal_filter=filter,
+    )
+    assert get_nb_points(output_file) == 2620
+
+
+def test_replace_area_with_source_filter():
+    filter = "Z>=2550"
+    output_file = os.path.join(TMP_PATH, "test_replace_with_source_filter", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+    replace_area(
+        target_cloud=TARGET_CLOUD,
+        pipeline_source=pipeline_read_from_cloud(SOURCE_CLOUD),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+        source_pdal_filter=filter,
+    )
+    assert get_nb_points(output_file) == 6390
+
+
+def test_replace_area_two_datasources():
+    target_file_class1 = os.path.join(INPUT_DIR, "target_cloud_crop_class1.laz")  # Classification=2
+    source_file_class2 = os.path.join(INPUT_DIR, "source_cloud_crop_class2.laz")  # Classification=1
+    output_file = os.path.join(TMP_PATH, "test_replace_two_datasources", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+    replace_area(
+        target_cloud=target_file_class1,
+        pipeline_source=pipeline_read_from_cloud(source_file_class2),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+    )
+
+    # Check if there is data from both input sources
+    counts = compute_count_one_file(output_file, "Classification")
+
+    assert counts == {"1": 6196, "2": 265}
+
+
+def test_replace_area_extra_dims():
+    tmp_extra_dim = os.path.join(TMP_PATH, "test_replace_extra_dims")
+    os.makedirs(tmp_extra_dim)
+
+    # generate source with an extra dim source
+    source_file_extra_dim = os.path.join(tmp_extra_dim, "source_cloud_crop_extra_dim.laz")
+    generate_extra_dim(input=SOURCE_CLOUD, output=source_file_extra_dim, new_dims={"source": "float"})
+
+    source_dims = list_dims(source_file_extra_dim)
+    assert "source" in source_dims, "source should have 'source' dimension"
+    assert "target" not in source_dims, "source should not have 'target' dimension"
+
+    output_file = os.path.join(tmp_extra_dim, "replaced.laz")
+
+    replace_area(
+        target_cloud=TARGET_EXTRA_DIM,
+        pipeline_source=pipeline_read_from_cloud(source_file_extra_dim),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+    )
+
+    replaced_dims = list_dims(output_file)
+
+    assert "target" in replaced_dims  # dimension from target cloud
+    assert "target2" in replaced_dims  # dimension from target cloud
+    assert "source" not in replaced_dims  # dimension from source cloud should not be kept
+
+    # check dimensions dtype
+    las = laspy.read(output_file)
+    assert las["target"].dtype == np.uint16
+    assert las["target2"].dtype == np.uint8
+
+
+def test_replace_area_with_no_point_on_target():
+    output_file = os.path.join(TMP_PATH, "test_replace_area_no_point_on_target", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+
+    replace_area(
+        target_cloud=TARGET_EXTRA_DIM,
+        pipeline_source=pipeline_read_from_cloud(SOURCE_CLOUD),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+        target_pdal_filter="Classification==3",
+    )
+    assert get_nb_points(output_file) == 265
+
+    # check dimensions dtype
+    las = laspy.read(output_file)
+    assert las["target"].dtype == np.uint16
+    assert las["target2"].dtype == np.uint8
+
+
+def test_replace_area_with_no_point_on_source():
+    output_file = os.path.join(TMP_PATH, "test_replace_area_no_point_on_source", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+
+    replace_area(
+        target_cloud=TARGET_EXTRA_DIM,
+        pipeline_source=pipeline_read_from_cloud(SOURCE_CLOUD),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+        source_pdal_filter="Classification==3",
+    )
+    assert get_nb_points(output_file) == 6196
+
+    # check dimensions dtype
+    las = laspy.read(output_file)
+    assert las["target"].dtype == np.uint16
+    assert las["target2"].dtype == np.uint8
+
+
+@pytest.mark.filterwarnings("ignore")
+def test_replace_area_with_no_output_point_base():
+    output_file = os.path.join(TMP_PATH, "test_replace_area_no_point_at_all", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+
+    replace_area(
+        target_cloud=TARGET_CLOUD,
+        pipeline_source=pipeline_read_from_cloud(SOURCE_CLOUD),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+        source_pdal_filter="Classification==3",
+        target_pdal_filter="Classification==3",
+    )
+    assert get_nb_points(output_file) == 0
+
+
+@pytest.mark.xfail(reason="when PDAL write empty LAS, extra dims are not written")
+@pytest.mark.filterwarnings("ignore")
+def test_replace_area_with_no_output_point_with_extra_dims():
+    output_file = os.path.join(TMP_PATH, "test_replace_area_no_point_at_all_with_extra_dims", "replaced.laz")
+    os.makedirs(os.path.dirname(output_file))
+
+    replace_area(
+        target_cloud=TARGET_EXTRA_DIM,
+        pipeline_source=pipeline_read_from_cloud(SOURCE_CLOUD),
+        replacement_area=REPLACE_AREA,
+        output_cloud=output_file,
+        source_pdal_filter="Classification==3",
+        target_pdal_filter="Classification==3",
+    )
+    assert get_nb_points(output_file) == 0
+
+    # check dimensions dtype
+    las = laspy.read(output_file)
+    assert las["target"].dtype == np.uint16
+    assert las["target2"].dtype == np.uint8
+
+
+def test_pipeline_read_from_DSM():
+    cloud_from_DSM = os.path.join(TMP_PATH, "las_from_DSM.laz")
+
+    pipeline = pipeline_read_from_DSM(dsm=SOURCE_DSM, ground_area=SOURCE_GROUND_AREA, classification=SOURCE_CLASSIF)
+    pipeline |= pdal.Writer.las(cloud_from_DSM, forward="all", extra_dims="all")
+    pipeline.execute()
+
+    # we have 27 col of points on 3 lines
+    num_points = get_nb_points(cloud_from_DSM)
+    assert num_points == 27 * 3
+
+    # point are classed in class 68
+    counts = compute_count_one_file(cloud_from_DSM, "Classification")
+    assert counts == {str(SOURCE_CLASSIF): 27 * 3}
+
+    # no_data have been filtered
+    stats_Z = compute_count_one_file(cloud_from_DSM, "Z", type=float)
+    assert stats_Z["-9999.0"] == 0
+
+
+def test_main_from_cloud_base():
+    output_file = os.path.join(TMP_PATH, "main_from_cloud", "output_main_from_cloud.laz")
+    os.makedirs(os.path.dirname(output_file))
+    cmd = f"from_cloud -s {SOURCE_CLOUD} -t {TARGET_CLOUD} -r {REPLACE_AREA} -o {output_file}".split()
+    args = argument_parser().parse_args(cmd)
+    args.func(args)
+
+    # Check that we have the expected number of points in the output
+    assert get_nb_points(output_file) == 6461
+
+
+def test_main_from_cloud_with_filter():
+    output_file = os.path.join(TMP_PATH, "main_from_cloud_with_filter", "output_main_from_cloud.laz")
+    os.makedirs(os.path.dirname(output_file))
+    cmd = (f"from_cloud -s {SOURCE_CLOUD} -t {TARGET_CLOUD} -r {REPLACE_AREA} -o {output_file} " "-f Z>=2550").split()
+
+    args = argument_parser().parse_args(cmd)
+    args.func(args)
+
+    # Check that we have the expected number of points in the output
+    assert get_nb_points(output_file) == 6390
+
+
+def test_main_from_DSM():
+    output_file = os.path.join(TMP_PATH, "output_main_from_cloud.laz")
+    cmd = (
+        f"from_DSM -d {SOURCE_DSM} -g {SOURCE_GROUND_AREA} -c {SOURCE_CLASSIF} -t {TARGET_CLOUD} -r {REPLACE_AREA}"
+        f" -o {output_file}"
+    ).split()
+    args = argument_parser().parse_args(cmd)
+    args.func(args)
+
+    # same result as test_from_DMS
+    counts = compute_count_one_file(output_file, "Classification")
+    assert counts == {"1": 3841, "2": 2355, str(SOURCE_CLASSIF): 45}

ign_pdal_tools-1.14.0/pdaltools/replace_area_in_pointcloud.py

@@ -1,79 +0,0 @@
-import argparse
-
-import pdal
-
-from pdaltools.las_info import get_writer_parameters_from_reader_metadata
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        "Replace points in a pointcloud with points from another pointcloud based on a area"
-    )
-    parser.add_argument("--target_cloud", "-t", type=str, help="filepath of target cloud to be modified")
-    parser.add_argument("--source_cloud", "-s", type=str, help="filepath of source cloud to use for replacement")
-    parser.add_argument("--replacement_area_file", "-r", type=str, help="filepath of file containing areas to replace")
-    parser.add_argument("--filter", "-f", type=str, help="pdal filter expression to apply to target_cloud")
-    parser.add_argument("--outfile", "-o", type=str, help="output file")
-    return parser.parse_args()
-
-
-def get_writer_params(input_file):
-    pipeline = pdal.Pipeline()
-    pipeline |= pdal.Reader.las(filename=input_file)
-    pipeline.execute()
-    params = get_writer_parameters_from_reader_metadata(pipeline.metadata)
-    return params
-
-
-def replace_area(target_cloud, source_cloud, replacement_area_file, outfile, writer_params, filter=""):
-    crops = []
-    pipeline_target = pdal.Pipeline()
-    pipeline_target |= pdal.Reader.las(filename=target_cloud)
-    pipeline_target |= pdal.Filter.ferry(dimensions="=> geometryFid")
-    # Assign -1 to all points because overlay replaces values from 0 and more
-    pipeline_target |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
-    if filter:
-        pipeline_target |= pdal.Filter.expression(expression=filter)
-    pipeline_target |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=replacement_area_file)
-    # Keep only points out of the area
-    pipeline_target |= pdal.Filter.expression(expression="geometryFid==-1", tag="A")
-    pipeline_target.execute()
-
-    input_dimensions = list(pipeline_target.arrays[0].dtype.fields.keys())
-    # do not keep geometryFid
-    output_dimensions = [dim for dim in input_dimensions if dim not in "geometryFid"]
-    target_cloud_pruned = pipeline_target.arrays[0][output_dimensions]
-    crops.append(target_cloud_pruned)
-
-    pipeline_source = pdal.Pipeline()
-    pipeline_source |= pdal.Reader.las(filename=source_cloud)
-    pipeline_source |= pdal.Filter.ferry(dimensions="=> geometryFid")
-    pipeline_source |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
-    pipeline_source |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=replacement_area_file)
-    # Keep only points in the area
-    pipeline_source |= pdal.Filter.expression(expression="geometryFid>=0", tag="B")
-    pipeline_source.execute()
-
-    # delete geometryFid from source_cloud
-    source_cloud_pruned = pipeline_source.arrays[0][output_dimensions]
-    crops.append(source_cloud_pruned)
-
-    # Merge
-    pipeline = pdal.Filter.merge().pipeline(*crops)
-    pipeline |= pdal.Writer.las(filename=outfile, **writer_params)
-    pipeline.execute()
-
-
-def main():
-    args = parse_args()
-
-    writer_parameters = get_writer_params(args.target_cloud)
-    # writer_parameters["extra_dims"] = "" # no extra-dim by default
-
-    replace_area(
-        args.target_cloud, args.source_cloud, args.replacement_area_file, args.outfile, writer_parameters, args.filter
-    )
-
-
-if __name__ == "__main__":
-    main()

ign_pdal_tools-1.14.0/test/test_replace_area_in_pointcloud.py

@@ -1,118 +0,0 @@
-import os
-import shutil
-import test.utils as tu
-
-import laspy
-import pdal
-
-from pdaltools.count_occurences.count_occurences_for_attribute import (
-    compute_count_one_file,
-)
-from pdaltools.replace_area_in_pointcloud import get_writer_params, replace_area
-
-TEST_PATH = os.path.dirname(os.path.abspath(__file__))
-TMP_PATH = os.path.join(TEST_PATH, "tmp/replace_area_in_pointcloud")
-INPUT_DIR = os.path.join(TEST_PATH, "data/replace_area_in_pointcloud")
-TARGET_FILE = os.path.join(INPUT_DIR, "target_cloud_crop.laz")
-SOURCE_FILE = os.path.join(INPUT_DIR, "source_cloud_crop.laz")
-SHAPEFILE = os.path.join(INPUT_DIR, "ground_area.shp")
-WRITER_PARAMS = get_writer_params(TARGET_FILE)
-
-
-def setup_module(module):
-    try:
-        shutil.rmtree(TMP_PATH)
-
-    except FileNotFoundError:
-        pass
-    os.mkdir(TMP_PATH)
-
-
-# Utils functions
-def get_nb_points(path):
-    """Get number of points in a las file"""
-    with laspy.open(path) as f:
-        nb_points = f.header.point_count
-
-    return nb_points
-
-
-def test_replace_area():
-    output_file = os.path.join(TMP_PATH, "test_replace_area", "replaced.laz")
-    os.makedirs(os.path.dirname(output_file))
-    replace_area(TARGET_FILE, SOURCE_FILE, SHAPEFILE, output_file, WRITER_PARAMS)
-    # Check that we have the expected number of points in the output
-    assert get_nb_points(output_file) == 6461
-
-    # Check that there are only points from the target pointcloud outside the replacement geometry
-    output_file_outside_geometry = os.path.join(os.path.dirname(output_file), "replaced_outside_area.laz")
-    pipeline = pdal.Pipeline()
-    pipeline |= pdal.Reader.las(filename=output_file)
-    pipeline |= pdal.Filter.ferry(dimensions="=> geometryFid")
-    pipeline |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
-    pipeline |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=SHAPEFILE)
-    pipeline |= pdal.Filter.expression(expression="geometryFid==-1")
-    pipeline |= pdal.Writer.las(filename=output_file_outside_geometry)
-    pipeline.execute()
-    counts_outside_area = compute_count_one_file(output_file_outside_geometry, "Classification")
-    assert counts_outside_area == {"1": 3841, "2": 2355}
-
-    # Check that there are only points from the source pointcloud inside the replacement geometry
-    output_file_in_area = os.path.join(os.path.dirname(output_file), "replaced_in_area.laz")
-    pipeline = pdal.Pipeline()
-    pipeline |= pdal.Reader.las(filename=output_file)
-    pipeline |= pdal.Filter.ferry(dimensions="=> geometryFid")
-    pipeline |= pdal.Filter.assign(assignment="geometryFid[:]=-1")
-    pipeline |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=SHAPEFILE)
-    pipeline |= pdal.Filter.expression(expression="geometryFid>=0")
-    pipeline |= pdal.Writer.las(filename=output_file_in_area)
-    pipeline.execute()
-    counts_in_area = compute_count_one_file(output_file_in_area, "Classification")
-
-    assert counts_in_area == {"0": 265}
-
-    # Check output dimensions are the same as input dimensions
-    target_dimensions = tu.get_pdal_infos_summary(TARGET_FILE)["summary"]["dimensions"].split(",")
-    output_dimensions = tu.get_pdal_infos_summary(output_file)["summary"]["dimensions"].split(",")
-
-    assert output_dimensions == target_dimensions
-
-
-def test_replace_with_filter():
-    filter = "Classification==2"
-    output_file = os.path.join(TMP_PATH, "test_replace_with_filter", "replaced.laz")
-    os.makedirs(os.path.dirname(output_file))
-    replace_area(TARGET_FILE, SOURCE_FILE, SHAPEFILE, output_file, WRITER_PARAMS, filter)
-    assert get_nb_points(output_file) == 2620
-
-
-def test_replace_two_datasources():
-    target_file_class1 = os.path.join(INPUT_DIR, "target_cloud_crop_class1.laz")  # Classification=2
-    source_file_class2 = os.path.join(INPUT_DIR, "source_cloud_crop_class2.laz")  # Classification=1
-    writer_params = get_writer_params(target_file_class1)
-    output_file = os.path.join(TMP_PATH, "test_replace_two_datasources", "replaced.laz")
-    os.makedirs(os.path.dirname(output_file))
-    replace_area(target_file_class1, source_file_class2, SHAPEFILE, output_file, writer_params)
-
-    # Check if there is data from both input sources
-    counts = compute_count_one_file(output_file, "Classification")
-
-    assert counts == {"1": 6196, "2": 265}
-
-
-def test_replace_extra_dims():
-    target_file_extra_dim = os.path.join(INPUT_DIR, "target_cloud_crop_extra_dim.laz")  # has target extra dimension
-    source_file_extra_dim = os.path.join(INPUT_DIR, "source_cloud_crop_extra_dim.laz")  # has source extra dimension
-    writer_params = get_writer_params(target_file_extra_dim)
-    output_file = os.path.join(TMP_PATH, "test_replace_extra_dims", "replaced.laz")
-    os.makedirs(os.path.dirname(output_file))
-    replace_area(target_file_extra_dim, source_file_extra_dim, SHAPEFILE, output_file, writer_params)
-
-    pipeline = pdal.Pipeline()
-    pipeline |= pdal.Reader.las(filename=output_file)
-    pipeline.execute()
-
-    output_dimensions = list(pipeline.arrays[0].dtype.fields.keys())
-
-    assert "target" in output_dimensions  # dimension from target cloud
-    assert "source" not in output_dimensions  # dimension from source cloud should not be kept