ign-pdal-tools 1.14.0__py3-none-any.whl → 1.15.1__py3-none-any.whl

{ign_pdal_tools-1.14.0.dist-info → ign_pdal_tools-1.15.1.dist-info}/METADATA

@@ -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.dist-info → ign_pdal_tools-1.15.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-ign_pdal_tools-1.14.0.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
-pdaltools/_version.py,sha256=eHT0NBFMCS431k6M3stEzwiZkw_EO8ROqR0MO0r5LM4,75
+ign_pdal_tools-1.15.1.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
+pdaltools/_version.py,sha256=Ifg5508wmTI_52FvVJqD1IBETM-8iJe8gIBnxxVL1UI,75
 pdaltools/add_points_in_pointcloud.py,sha256=VM2HW2b1Ul_I8jtXaOpTsmyGjiEFgoSi8AmCLuj6gH8,12697
 pdaltools/color.py,sha256=s-_rmLK6fIK3UwkUzHVZPEkm6r1LliG5ftGr-jkqyjM,9549
 pdaltools/create_random_laz.py,sha256=XuHH4G8Nrs8DB-F8bkcIeto7JtmrlrNGF_R66oxGCbQ,6069
@@ -7,16 +7,16 @@ pdaltools/download_image.py,sha256=DG9PunQsjw7Uyyf4YMVp8LMH0G3Uo4cahx5EZbdi3so,7
 pdaltools/las_add_buffer.py,sha256=rnFExAfi0KqlQpL4hDMh2aC08AcYdSHSB6WPG5RyFIc,11274
 pdaltools/las_clip.py,sha256=GvEOYu8RXV68e35kU8i42GwSkbo4P9TvmS6rkrdPmFM,1034
 pdaltools/las_comparison.py,sha256=B9hFGbmD0x4JEN4oHbiQFNbd0T-9P3mnAN67Czu0pZk,4505
-pdaltools/las_info.py,sha256=lMKxKzsViptDENI1wOlANG4qOvdc19ixyasYKD-N1ck,9512
+pdaltools/las_info.py,sha256=xZlTsdLS3I9_xeqGJyOOpJNJrqF82JBhlMhtYabOuw0,9845
 pdaltools/las_merge.py,sha256=tcFVueV9X9nNEaoAl5zCduY5DETlBg63MAgP2SuKiNo,4121
 pdaltools/las_remove_dimensions.py,sha256=f8imGhN6LNTuQ1GMJQRzIIV3Wab_oRPOyEnKi1CgfiM,2318
 pdaltools/las_rename_dimension.py,sha256=FEWIcq0ZZiv9xWbCLDRE9Hzb5K0YYfoi3Z8IZFEs-uU,2887
 pdaltools/pcd_info.py,sha256=NIAH5KGikVDQLlbCcw9FuaPqe20UZvRfkHsDZd5kmZA,3210
-pdaltools/replace_area_in_pointcloud.py,sha256=SaF5NXjtMOVyU4XUfO0REZGBZoRp32zjmrb1ZodfEow,3319
+pdaltools/replace_area_in_pointcloud.py,sha256=VyLMDItP-FU4muRV01vbetf5ySgdKeOpc55YESicJ7U,8008
 pdaltools/replace_attribute_in_las.py,sha256=MHpIizSupgWtbizteoRH8FKDE049hrAh4v_OhmRmSPU,4318
 pdaltools/standardize_format.py,sha256=I2oNiwhSMtr4e5ZK9qbB_yKmy3twOoO6QLiSFu4_AaI,3905
 pdaltools/unlock_file.py,sha256=G2odk0cpp_X9r49Y90oK88v3qlihaMfg6acwmWqblik,1958
-ign_pdal_tools-1.14.0.dist-info/METADATA,sha256=QIzL7Suc-iA8MNeYrwzmJX6mT3pOXlfcLx07UhvmPVA,5982
-ign_pdal_tools-1.14.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ign_pdal_tools-1.14.0.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
-ign_pdal_tools-1.14.0.dist-info/RECORD,,
+ign_pdal_tools-1.15.1.dist-info/METADATA,sha256=3mwPLGrnvNs6FuL_f6iSbFq1Zb5mlVnTjdGidcs8SLI,6146
+ign_pdal_tools-1.15.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ign_pdal_tools-1.15.1.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
+ign_pdal_tools-1.15.1.dist-info/RECORD,,

pdaltools/_version.py

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

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())

pdaltools/replace_area_in_pointcloud.py

@@ -1,20 +1,95 @@
 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 parse_args():
+def argument_parser():
     parser = argparse.ArgumentParser(
-        "Replace points in a pointcloud with points from another pointcloud based on a area"
+        "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,
     )
-    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):
@@ -25,55 +100,114 @@ def get_writer_params(input_file):
     return params
 
 
-def replace_area(target_cloud, source_cloud, replacement_area_file, outfile, writer_params, filter=""):
+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 filter:
-        pipeline_target |= pdal.Filter.expression(expression=filter)
-    pipeline_target |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=replacement_area_file)
+    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()
 
-    input_dimensions = list(pipeline_target.arrays[0].dtype.fields.keys())
+    # 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"]
-    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)
+    # 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")
-    pipeline_source |= pdal.Filter.overlay(column="fid", dimension="geometryFid", datasource=replacement_area_file)
+    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()
 
-    # delete geometryFid from source_cloud
-    source_cloud_pruned = pipeline_source.arrays[0][output_dimensions]
-    crops.append(source_cloud_pruned)
+    # 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
-    pipeline = pdal.Filter.merge().pipeline(*crops)
-    pipeline |= pdal.Writer.las(filename=outfile, **writer_params)
-    pipeline.execute()
-
-
-def main():
-    args = parse_args()
+    if not crops:
+        warnings.warn("WARNING: Empty LAS, extra dims are lost")
 
-    writer_parameters = get_writer_params(args.target_cloud)
-    # writer_parameters["extra_dims"] = "" # no extra-dim by default
+    pipeline = pdal.Filter.merge().pipeline(*crops)
 
-    replace_area(
-        args.target_cloud, args.source_cloud, args.replacement_area_file, args.outfile, writer_parameters, args.filter
-    )
+    writer_params = get_writer_params(target_cloud)
+    pipeline |= pdal.Writer.las(filename=output_cloud, **writer_params)
+    pipeline.execute()
 
 
 if __name__ == "__main__":
-    main()
+    args = argument_parser().parse_args()
+    args.func(args)