ign-pdal-tools 1.13.0__tar.gz → 1.15.0__tar.gz

{ign_pdal_tools-1.13.0/ign_pdal_tools.egg-info → ign_pdal_tools-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.13.0
+Version: 1.15.0
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown
@@ -68,6 +68,7 @@ pcd_infos.get_pointcloud_origin_from_tile_width(points, tile_width=1000)
 * [las_clip.py](pdaltools/las_clip.py): crop a LAS file using 2d bounding box
 * [las_merge.py](pdaltools/las_merge.py): merge a LAS file with its neighbors according to their filenames
 * [las_add_buffer.py](pdaltools/las_add_buffer.py): add points to a LAS file from a buffer (border) from its neighbors (using filenames to locate neighbors)
+* [replace_area_in_pointcloud.py](pdaltools/replace_area_in_pointcloud.py): replace the points from a LAS file by the points of another LAS file inside areas defined in a vector file (geojson, shapefile)
 
 **WARNING**: In `las_merge.py` and `las_add_buffer.py`, filenames are used to get the LAS files extents
 and to find neighbors.
@@ -127,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.13.0/PKG-INFO → ign_pdal_tools-1.15.0/README.md

@@ -1,12 +1,3 @@
-Metadata-Version: 2.4
-Name: ign-pdal-tools
-Version: 1.13.0
-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
 
 This repo contains various python tools based on [PDAL](https://pdal.io/) that are used to work on
@@ -68,6 +59,7 @@ pcd_infos.get_pointcloud_origin_from_tile_width(points, tile_width=1000)
 * [las_clip.py](pdaltools/las_clip.py): crop a LAS file using 2d bounding box
 * [las_merge.py](pdaltools/las_merge.py): merge a LAS file with its neighbors according to their filenames
 * [las_add_buffer.py](pdaltools/las_add_buffer.py): add points to a LAS file from a buffer (border) from its neighbors (using filenames to locate neighbors)
+* [replace_area_in_pointcloud.py](pdaltools/replace_area_in_pointcloud.py): replace the points from a LAS file by the points of another LAS file inside areas defined in a vector file (geojson, shapefile)
 
 **WARNING**: In `las_merge.py` and `las_add_buffer.py`, filenames are used to get the LAS files extents
 and to find neighbors.
@@ -127,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.13.0/README.md → ign_pdal_tools-1.15.0/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,3 +1,12 @@
+Metadata-Version: 2.4
+Name: ign-pdal-tools
+Version: 1.15.0
+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
 
 This repo contains various python tools based on [PDAL](https://pdal.io/) that are used to work on
@@ -59,6 +68,7 @@ pcd_infos.get_pointcloud_origin_from_tile_width(points, tile_width=1000)
 * [las_clip.py](pdaltools/las_clip.py): crop a LAS file using 2d bounding box
 * [las_merge.py](pdaltools/las_merge.py): merge a LAS file with its neighbors according to their filenames
 * [las_add_buffer.py](pdaltools/las_add_buffer.py): add points to a LAS file from a buffer (border) from its neighbors (using filenames to locate neighbors)
+* [replace_area_in_pointcloud.py](pdaltools/replace_area_in_pointcloud.py): replace the points from a LAS file by the points of another LAS file inside areas defined in a vector file (geojson, shapefile)
 
 **WARNING**: In `las_merge.py` and `las_add_buffer.py`, filenames are used to get the LAS files extents
 and to find neighbors.
@@ -118,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.13.0 → ign_pdal_tools-1.15.0}/ign_pdal_tools.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ pdaltools/_version.py
 pdaltools/add_points_in_pointcloud.py
 pdaltools/color.py
 pdaltools/create_random_laz.py
+pdaltools/download_image.py
 pdaltools/las_add_buffer.py
 pdaltools/las_clip.py
 pdaltools/las_comparison.py
@@ -17,12 +18,14 @@ pdaltools/las_merge.py
 pdaltools/las_remove_dimensions.py
 pdaltools/las_rename_dimension.py
 pdaltools/pcd_info.py
+pdaltools/replace_area_in_pointcloud.py
 pdaltools/replace_attribute_in_las.py
 pdaltools/standardize_format.py
 pdaltools/unlock_file.py
 test/test_add_points_in_pointcloud.py
 test/test_color.py
 test/test_create_random_laz.py
+test/test_download_image.py
 test/test_las_add_buffer.py
 test/test_las_clip.py
 test/test_las_comparison.py
@@ -31,7 +34,8 @@ 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
 test/test_unlock.py

{ign_pdal_tools-1.13.0 → ign_pdal_tools-1.15.0}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.13.0"
+__version__ = "1.15.0"
 
 
 if __name__ == "__main__":

ign_pdal_tools-1.15.0/pdaltools/color.py

@@ -0,0 +1,223 @@
+import argparse
+import tempfile
+from math import ceil, floor
+from typing import Tuple
+
+import pdal
+
+import pdaltools.las_info as las_info
+from pdaltools.download_image import download_image
+
+
+def match_min_max_with_pixel_size(min_d: float, max_d: float, pixel_per_meter: float) -> Tuple[float, float]:
+    """Round min/max values along one dimension to the closest multiple of 1 / pixel_per_meter
+    It should prevent having to interpolate during a request to the geoplateforme
+    in case we use a native resolution.
+
+    Args:
+        min_d (float): minimum value along the dimension, in meters
+        max_d (float): maximum value along the dimension, in meters
+        pixel_per_meter (float): resolution (in number of pixels per meter)
+
+    Returns:
+        Tuple[float, float]: adapted min / max value
+    """
+    # Use ceil - 1 instead of ceil  to make sure that
+    # no point of the pointcloud is on the limit of the first pixel
+    min_d = (ceil(min_d * pixel_per_meter) - 1) / pixel_per_meter
+    # Use floor + 1 instead of ceil to make sure that no point of the pointcloud is on the limit of the last pixel
+    max_d = (floor(max_d * pixel_per_meter) + 1) / pixel_per_meter
+
+    return min_d, max_d
+
+
+def color(
+    input_file: str,
+    output_file: str,
+    proj="",
+    pixel_per_meter=5,
+    timeout_second=300,
+    color_rvb_enabled=True,
+    color_ir_enabled=True,
+    veget_index_file="",
+    vegetation_dim="Deviation",
+    check_images=False,
+    stream_RGB="ORTHOIMAGERY.ORTHOPHOTOS",
+    stream_IRC="ORTHOIMAGERY.ORTHOPHOTOS.IRC",
+    size_max_gpf=5000,
+):
+    """Colorize a las file with any of the following methods:
+    - R, G, B values from an image retrieved from ign geoplateform via the "stream_RGB" data feed name
+    - Infrared from another image retrieved from ign geoplateform via the "stream_IRC" data feed name
+    - any field "vegetation_dim" from another image stored locally at "veget_index_file"
+
+
+    Args:
+        input_file (str): Path to the las file to colorize
+        output_file (str): Path to the output colorized file
+        proj (str, optional): EPSG value of the SRS to apply to the output file (if not provided, use the one from
+        the input file). Eg. "2154" to use "EPSG:2154". Defaults to "".
+        pixel_per_meter (int, optional): Stream image resolution (for RGB and IRC) in pixels per meter. Defaults to 5.
+        timeout_second (int, optional): Timeout for the geoplateform request. Defaults to 300.
+        color_rvb_enabled (bool, optional): If true, apply R, G, B dimensions colorization. Defaults to True.
+        color_ir_enabled (bool, optional): If true, apply Infrared dimension colorization. Defaults to True.
+        veget_index_file (str, optional): Path to the tiff tile to use for "vegetation_dim" colorization.
+        Defaults to "".
+        vegetation_dim (str, optional): Name of the dimension to use to store the values of "veget_index_file".
+        Defaults to "Deviation".
+        check_images (bool, optional): If true, check if images from the geoplateform data feed are white
+        (and raise and error in this case). Defaults to False.
+        stream_RGB (str, optional): WMS raster stream for RGB colorization:
+        Default stream (ORTHOIMAGERY.ORTHOPHOTOS) let the server choose the resolution
+        for 20cm resolution rasters, use HR.ORTHOIMAGERY.ORTHOPHOTOS
+        for 50 cm resolution rasters, use ORTHOIMAGERY.ORTHOPHOTOS.BDORTHO
+        Defaults to ORTHOIMAGERY.ORTHOPHOTOS
+        stream_IRC (str, optional):WMS raster stream for IRC colorization.
+        Documentation about possible stream : https://geoservices.ign.fr/services-web-experts-ortho.
+        Defaults to "ORTHOIMAGERY.ORTHOPHOTOS.IRC".
+        size_max_gpf (int, optional): Maximum edge size (in pixels) of downloaded images. If input file needs more,
+        several images are downloaded and merged. Defaults to 5000.
+
+    Returns:
+        Paths to the temporary files that store the streamed images (tmp_ortho, tmp_ortho_irc)
+    """
+    metadata = las_info.las_info_metadata(input_file)
+    minx, maxx, miny, maxy = las_info.get_bounds_from_header_info(metadata)
+
+    minx, maxx = match_min_max_with_pixel_size(minx, maxx, pixel_per_meter)
+    miny, maxy = match_min_max_with_pixel_size(miny, maxy, pixel_per_meter)
+
+    if proj == "":
+        proj = las_info.get_epsg_from_header_info(metadata)
+
+    pipeline = pdal.Reader.las(filename=input_file)
+
+    writer_extra_dims = "all"
+
+    if veget_index_file and veget_index_file != "":
+        print(f"Remplissage du champ {vegetation_dim} à partir du fichier {veget_index_file}")
+        pipeline |= pdal.Filter.colorization(raster=veget_index_file, dimensions=f"{vegetation_dim}:1:256.0")
+        writer_extra_dims = [f"{vegetation_dim}=ushort"]
+
+    tmp_ortho = None
+    if color_rvb_enabled:
+        tmp_ortho = tempfile.NamedTemporaryFile(suffix="_rvb.tif")
+        download_image(
+            proj,
+            stream_RGB,
+            minx,
+            miny,
+            maxx,
+            maxy,
+            pixel_per_meter,
+            tmp_ortho.name,
+            timeout_second,
+            check_images,
+            size_max_gpf,
+        )
+        # Warning: the initial color is multiplied by 256 despite its initial 8-bits encoding
+        # which turns it to a 0 to 255*256 range.
+        # It is kept this way because of other dependencies that have been tuned to fit this range
+        pipeline |= pdal.Filter.colorization(
+            raster=tmp_ortho.name, dimensions="Red:1:256.0, Green:2:256.0, Blue:3:256.0"
+        )
+
+    tmp_ortho_irc = None
+    if color_ir_enabled:
+        tmp_ortho_irc = tempfile.NamedTemporaryFile(suffix="_irc.tif")
+        download_image(
+            proj,
+            stream_IRC,
+            minx,
+            miny,
+            maxx,
+            maxy,
+            pixel_per_meter,
+            tmp_ortho_irc.name,
+            timeout_second,
+            check_images,
+            size_max_gpf,
+        )
+        # Warning: the initial color is multiplied by 256 despite its initial 8-bits encoding
+        # which turns it to a 0 to 255*256 range.
+        # It is kept this way because of other dependencies that have been tuned to fit this range
+        pipeline |= pdal.Filter.colorization(raster=tmp_ortho_irc.name, dimensions="Infrared:1:256.0")
+
+    pipeline |= pdal.Writer.las(
+        filename=output_file, extra_dims=writer_extra_dims, minor_version="4", dataformat_id="8", forward="all"
+    )
+
+    print("Traitement du nuage de point")
+    pipeline.execute()
+
+    # The orthoimages files will be deleted only when their reference are lost.
+    # To keep them, make a copy (with e.g. shutil.copy(...))
+    # See: https://docs.python.org/2/library/tempfile.html#tempfile.TemporaryFile
+    return tmp_ortho, tmp_ortho_irc
+
+
+def parse_args():
+    parser = argparse.ArgumentParser("Colorize tool", formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument("--input", "-i", type=str, required=True, help="Input file")
+    parser.add_argument("--output", "-o", type=str, default="", help="Output file")
+    parser.add_argument(
+        "--proj", "-p", type=str, default="", help="Projection, default will use projection from metadata input"
+    )
+    parser.add_argument("--resolution", "-r", type=float, default=5, help="Resolution, in pixel per meter")
+    parser.add_argument("--timeout", "-t", type=int, default=300, help="Timeout, in seconds")
+    parser.add_argument("--rvb", action="store_true", help="Colorize RVB")
+    parser.add_argument("--ir", action="store_true", help="Colorize IR")
+    parser.add_argument(
+        "--vegetation",
+        type=str,
+        default="",
+        help="Vegetation file (raster), value will be stored in 'vegetation_dim' field",
+    )
+    parser.add_argument(
+        "--vegetation_dim", type=str, default="Deviation", help="name of the extra_dim uses for the vegetation value"
+    )
+    parser.add_argument("--check-images", "-c", action="store_true", help="Check that downloaded image is not white")
+    parser.add_argument(
+        "--stream-RGB",
+        type=str,
+        default="ORTHOIMAGERY.ORTHOPHOTOS",
+        help="""WMS raster stream for RGB colorization:
+default stream (ORTHOIMAGERY.ORTHOPHOTOS) let the server choose the resolution
+for 20cm resolution rasters, use HR.ORTHOIMAGERY.ORTHOPHOTOS
+for 50 cm resolution rasters, use ORTHOIMAGERY.ORTHOPHOTOS.BDORTHO""",
+    )
+    parser.add_argument(
+        "--stream-IRC",
+        type=str,
+        default="ORTHOIMAGERY.ORTHOPHOTOS.IRC",
+        help="""WMS raster stream for IRC colorization. Default to ORTHOIMAGERY.ORTHOPHOTOS.IRC
+Documentation about possible stream : https://geoservices.ign.fr/services-web-experts-ortho""",
+    )
+    parser.add_argument(
+        "--size-max-GPF",
+        type=int,
+        default=5000,
+        help="Maximum edge size (in pixels) of downloaded images."
+        " If input file needs more, several images are downloaded and merged.",
+    )
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    color(
+        input_file=args.input,
+        output_file=args.output,
+        proj=args.proj,
+        pixel_per_meter=args.resolution,
+        timeout_second=args.timeout,
+        color_rvb_enabled=args.rvb,
+        color_ir_enabled=args.ir,
+        veget_index_file=args.vegetation,
+        vegetation_dim=args.vegetation_dim,
+        check_images=args.check_images,
+        stream_RGB=args.stream_RGB,
+        stream_IRC=args.stream_IRC,
+        size_max_gpf=args.size_max_GPF,
+    )

ign_pdal_tools-1.13.0/pdaltools/color.py → ign_pdal_tools-1.15.0/pdaltools/download_image.py

@@ -1,59 +1,36 @@
-import argparse
+"""Tool to download an image from IGN geoplateform: https://geoservices.ign.fr/"""
+
 import tempfile
 import time
-from math import ceil, floor
+from math import ceil
 from pathlib import Path
 from typing import Tuple
 
 import numpy as np
-import pdal
 import requests
 from osgeo import gdal, gdal_array
 
-import pdaltools.las_info as las_info
 from pdaltools.unlock_file import copy_and_hack_decorator
 
 
-def pretty_time_delta(seconds):
-    sign_string = "-" if seconds < 0 else ""
-    seconds = abs(int(seconds))
-    days, seconds = divmod(seconds, 86400)
-    hours, seconds = divmod(seconds, 3600)
-    minutes, seconds = divmod(seconds, 60)
-    if days > 0:
-        return "%s%dd%dh%dm%ds" % (sign_string, days, hours, minutes, seconds)
-    elif hours > 0:
-        return "%s%dh%dm%ds" % (sign_string, hours, minutes, seconds)
-    elif minutes > 0:
-        return "%s%dm%ds" % (sign_string, minutes, seconds)
-    else:
-        return "%s%ds" % (sign_string, seconds)
-
-
-def retry(times, delay, factor, debug=False):
-    def decorator(func):
-        def newfn(*args, **kwargs):
-            attempt = 1
-            new_delay = delay
-            while attempt <= times:
-                need_retry = False
-                try:
-                    return func(*args, **kwargs)
-                except requests.exceptions.RequestException as err:
-                    print("Connection Error:", err)
-                    need_retry = True
-                if need_retry:
-                    print(f"{attempt}/{times} Nouvel essai après une pause de {pretty_time_delta(new_delay)} .. ")
-                    if not debug:
-                        time.sleep(new_delay)
-                    new_delay = new_delay * factor
-                    attempt += 1
+def compute_cells_size(mind: float, maxd: float, pixel_per_meter: float, size_max_gpf: int) -> Tuple[int, int, int]:
+    """Compute cell size to have cells of almost equal size, but phased the same way as
+    if there had been no paving by forcing cell_size (in pixels) to be an integer
 
-            return func(*args, **kwargs)
+    Args:
+        mind (float): minimum value along the dimension, in meters
+        maxd (float): maximum value along the dimension, in meters
+        pixel_per_meter (float): resolution (in number of pixels per meter)
+        size_max_gpf (int): maximum image size in pixels
 
-        return newfn
+    Returns:
+        Tuple[int, int, int]: number of pixels in total, number of cells along the dimension, cell size in pixels
+    """
+    nb_pixels = ceil((maxd - mind) * pixel_per_meter)
+    nb_cells = ceil(nb_pixels / size_max_gpf)
+    cell_size_pixels = ceil(nb_pixels / nb_cells)  # Force cell size to be an integer
 
-    return decorator
+    return nb_pixels, nb_cells, cell_size_pixels
 
 
 def is_image_white(filename: str):
@@ -101,24 +78,46 @@ def download_image_from_geoplateforme(
         raise ValueError(f"Downloaded image is white, with stream: {layer}")
 
 
-def compute_cells_size(mind: float, maxd: float, pixel_per_meter: float, size_max_gpf: int) -> Tuple[int, int, int]:
-    """Compute cell size to have cells of almost equal size, but phased the same way as
-    if there had been no paving by forcing cell_size (in pixels) to be an integer
+def pretty_time_delta(seconds):
+    sign_string = "-" if seconds < 0 else ""
+    seconds = abs(int(seconds))
+    days, seconds = divmod(seconds, 86400)
+    hours, seconds = divmod(seconds, 3600)
+    minutes, seconds = divmod(seconds, 60)
+    if days > 0:
+        return "%s%dd%dh%dm%ds" % (sign_string, days, hours, minutes, seconds)
+    elif hours > 0:
+        return "%s%dh%dm%ds" % (sign_string, hours, minutes, seconds)
+    elif minutes > 0:
+        return "%s%dm%ds" % (sign_string, minutes, seconds)
+    else:
+        return "%s%ds" % (sign_string, seconds)
 
-    Args:
-        mind (float): minimum value along the dimension, in meters
-        maxd (float): maximum value along the dimension, in meters
-        pixel_per_meter (float): resolution (in number of pixels per meter)
-        size_max_gpf (int): maximum image size in pixels
 
-    Returns:
-        Tuple[int, int, int]: number of pixels in total, number of cells along the dimension, cell size in pixels
-    """
-    nb_pixels = ceil((maxd - mind) * pixel_per_meter)
-    nb_cells = ceil(nb_pixels / size_max_gpf)
-    cell_size_pixels = ceil(nb_pixels / nb_cells)  # Force cell size to be an integer
+def retry(times, delay, factor, debug=False):
+    def decorator(func):
+        def newfn(*args, **kwargs):
+            attempt = 1
+            new_delay = delay
+            while attempt <= times:
+                need_retry = False
+                try:
+                    return func(*args, **kwargs)
+                except requests.exceptions.RequestException as err:
+                    print("Connection Error:", err)
+                    need_retry = True
+                if need_retry:
+                    print(f"{attempt}/{times} Nouvel essai après une pause de {pretty_time_delta(new_delay)} .. ")
+                    if not debug:
+                        time.sleep(new_delay)
+                    new_delay = new_delay * factor
+                    attempt += 1
 
-    return nb_pixels, nb_cells, cell_size_pixels
+            return func(*args, **kwargs)
+
+        return newfn
+
+    return decorator
 
 
 @copy_and_hack_decorator
@@ -191,174 +190,3 @@ def download_image(proj, layer, minx, miny, maxx, maxy, pixel_per_meter, outfile
             gdal.Translate(outfile, tmp_vrt.name)
 
     return nb_cells_x * nb_cells_y
-
-
-def match_min_max_with_pixel_size(min_d: float, max_d: float, pixel_per_meter: float) -> Tuple[float, float]:
-    """Round min/max values along one dimension to the closest multiple of 1 / pixel_per_meter
-    It should prevent having to interpolate during a request to the geoplateforme
-    in case we use a native resolution.
-
-    Args:
-        min_d (float): minimum value along the dimension, in meters
-        max_d (float): maximum value along the dimension, in meters
-        pixel_per_meter (float): resolution (in number of pixels per meter)
-
-    Returns:
-        Tuple[float, float]: adapted min / max value
-    """
-    # Use ceil - 1 instead of ceil  to make sure that
-    # no point of the pointcloud is on the limit of the first pixel
-    min_d = (ceil(min_d * pixel_per_meter) - 1) / pixel_per_meter
-    # Use floor + 1 instead of ceil to make sure that no point of the pointcloud is on the limit of the last pixel
-    max_d = (floor(max_d * pixel_per_meter) + 1) / pixel_per_meter
-
-    return min_d, max_d
-
-
-def color(
-    input_file: str,
-    output_file: str,
-    proj="",
-    pixel_per_meter=5,
-    timeout_second=300,
-    color_rvb_enabled=True,
-    color_ir_enabled=True,
-    veget_index_file="",
-    check_images=False,
-    stream_RGB="ORTHOIMAGERY.ORTHOPHOTOS",
-    stream_IRC="ORTHOIMAGERY.ORTHOPHOTOS.IRC",
-    size_max_gpf=5000,
-):
-    metadata = las_info.las_info_metadata(input_file)
-    minx, maxx, miny, maxy = las_info.get_bounds_from_header_info(metadata)
-
-    minx, maxx = match_min_max_with_pixel_size(minx, maxx, pixel_per_meter)
-    miny, maxy = match_min_max_with_pixel_size(miny, maxy, pixel_per_meter)
-
-    if proj == "":
-        proj = las_info.get_epsg_from_header_info(metadata)
-
-    pipeline = pdal.Reader.las(filename=input_file)
-
-    writer_extra_dims = "all"
-
-    if veget_index_file and veget_index_file != "":
-        print(f"Remplissage du champ Deviation à partir du fichier {veget_index_file}")
-        pipeline |= pdal.Filter.colorization(raster=veget_index_file, dimensions="Deviation:1:256.0")
-        writer_extra_dims = ["Deviation=ushort"]
-
-    tmp_ortho = None
-    if color_rvb_enabled:
-        tmp_ortho = tempfile.NamedTemporaryFile(suffix="_rvb.tif")
-        download_image(
-            proj,
-            stream_RGB,
-            minx,
-            miny,
-            maxx,
-            maxy,
-            pixel_per_meter,
-            tmp_ortho.name,
-            timeout_second,
-            check_images,
-            size_max_gpf,
-        )
-        # Warning: the initial color is multiplied by 256 despite its initial 8-bits encoding
-        # which turns it to a 0 to 255*256 range.
-        # It is kept this way because of other dependencies that have been tuned to fit this range
-        pipeline |= pdal.Filter.colorization(
-            raster=tmp_ortho.name, dimensions="Red:1:256.0, Green:2:256.0, Blue:3:256.0"
-        )
-
-    tmp_ortho_irc = None
-    if color_ir_enabled:
-        tmp_ortho_irc = tempfile.NamedTemporaryFile(suffix="_irc.tif")
-        download_image(
-            proj,
-            stream_IRC,
-            minx,
-            miny,
-            maxx,
-            maxy,
-            pixel_per_meter,
-            tmp_ortho_irc.name,
-            timeout_second,
-            check_images,
-            size_max_gpf,
-        )
-        # Warning: the initial color is multiplied by 256 despite its initial 8-bits encoding
-        # which turns it to a 0 to 255*256 range.
-        # It is kept this way because of other dependencies that have been tuned to fit this range
-        pipeline |= pdal.Filter.colorization(raster=tmp_ortho_irc.name, dimensions="Infrared:1:256.0")
-
-    pipeline |= pdal.Writer.las(
-        filename=output_file, extra_dims=writer_extra_dims, minor_version="4", dataformat_id="8", forward="all"
-    )
-
-    print("Traitement du nuage de point")
-    pipeline.execute()
-
-    # The orthoimages files will be deleted only when their reference are lost.
-    # To keep them, make a copy (with e.g. shutil.copy(...))
-    # See: https://docs.python.org/2/library/tempfile.html#tempfile.TemporaryFile
-    return tmp_ortho, tmp_ortho_irc
-
-
-def parse_args():
-    parser = argparse.ArgumentParser("Colorize tool", formatter_class=argparse.RawTextHelpFormatter)
-    parser.add_argument("--input", "-i", type=str, required=True, help="Input file")
-    parser.add_argument("--output", "-o", type=str, default="", help="Output file")
-    parser.add_argument(
-        "--proj", "-p", type=str, default="", help="Projection, default will use projection from metadata input"
-    )
-    parser.add_argument("--resolution", "-r", type=float, default=5, help="Resolution, in pixel per meter")
-    parser.add_argument("--timeout", "-t", type=int, default=300, help="Timeout, in seconds")
-    parser.add_argument("--rvb", action="store_true", help="Colorize RVB")
-    parser.add_argument("--ir", action="store_true", help="Colorize IR")
-    parser.add_argument(
-        "--vegetation", type=str, default="", help="Vegetation file, value will be stored in Deviation field"
-    )
-    parser.add_argument("--check-images", "-c", action="store_true", help="Check that downloaded image is not white")
-    parser.add_argument(
-        "--stream-RGB",
-        type=str,
-        default="ORTHOIMAGERY.ORTHOPHOTOS",
-        help="""WMS raster stream for RGB colorization:
-default stream (ORTHOIMAGERY.ORTHOPHOTOS) let the server choose the resolution
-for 20cm resolution rasters, use HR.ORTHOIMAGERY.ORTHOPHOTOS
-for 50 cm resolution rasters, use ORTHOIMAGERY.ORTHOPHOTOS.BDORTHO""",
-    )
-    parser.add_argument(
-        "--stream-IRC",
-        type=str,
-        default="ORTHOIMAGERY.ORTHOPHOTOS.IRC",
-        help="""WMS raster stream for IRC colorization. Default to ORTHOIMAGERY.ORTHOPHOTOS.IRC
-Documentation about possible stream : https://geoservices.ign.fr/services-web-experts-ortho""",
-    )
-    parser.add_argument(
-        "--size-max-GPF",
-        type=int,
-        default=5000,
-        help="Maximum edge size (in pixels) of downloaded images."
-        " If input file needs more, several images are downloaded and merged.",
-    )
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    color(
-        input_file=args.input,
-        output_file=args.output,
-        proj=args.proj,
-        pixel_per_meter=args.resolution,
-        timeout_second=args.timeout,
-        color_rvb_enabled=args.rvb,
-        color_ir_enabled=args.ir,
-        veget_index_file=args.vegetation,
-        check_images=args.check_images,
-        stream_RGB=args.stream_RGB,
-        stream_IRC=args.stream_IRC,
-        size_max_gpf=args.size_max_GPF,
-    )

{ign_pdal_tools-1.13.0 → ign_pdal_tools-1.15.0}/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())