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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.12.3
+Version: 1.14.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.

{ign_pdal_tools-1.12.3.dist-info → ign_pdal_tools-1.14.0.dist-info}/RECORD

@@ -1,20 +1,22 @@
-ign_pdal_tools-1.12.3.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
-pdaltools/_version.py,sha256=imnrJGefuTNyDbmr09xOFtEVybYZhC7mSJkI2WzqG1Y,75
-pdaltools/add_points_in_pointcloud.py,sha256=Q8rCgLi81IsGRUf77tsVb1WJIF-IGLdFk-rC5NA0itE,12679
-pdaltools/color.py,sha256=vJgpb8dOvT5rnq5NdVOaMdGc_pKL3damLy4HwGvigJQ,14472
-pdaltools/create_random_laz.py,sha256=kFe5iHeHlkgKWRIKjK5l1AD65OG4qLYwAZdO1Wcvuos,5255
+ign_pdal_tools-1.14.0.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
+pdaltools/_version.py,sha256=eHT0NBFMCS431k6M3stEzwiZkw_EO8ROqR0MO0r5LM4,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
+pdaltools/download_image.py,sha256=DG9PunQsjw7Uyyf4YMVp8LMH0G3Uo4cahx5EZbdi3so,7846
 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_merge.py,sha256=tcFVueV9X9nNEaoAl5zCduY5DETlBg63MAgP2SuKiNo,4121
 pdaltools/las_remove_dimensions.py,sha256=f8imGhN6LNTuQ1GMJQRzIIV3Wab_oRPOyEnKi1CgfiM,2318
-pdaltools/las_rename_dimension.py,sha256=zXEKHyx1uQ3U0oZYo_BTnqbTHGSq5TIZHqZn_EPqNKQ,2576
+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_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.12.3.dist-info/METADATA,sha256=inI_jvR-SofWol9ZIbQS10hQtDPp173eXjOq8Rj1aLk,5778
-ign_pdal_tools-1.12.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ign_pdal_tools-1.12.3.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
-ign_pdal_tools-1.12.3.dist-info/RECORD,,
+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,,

pdaltools/_version.py

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

pdaltools/add_points_in_pointcloud.py

@@ -169,7 +169,7 @@ def add_points_to_las(
         pipeline |= pdal.Reader.las(filename=input_las)
         pipeline |= pdal.Reader.las(filename=tmp.name)
         pipeline |= pdal.Filter.merge()
-        pipeline |= pdal.Writer.las(filename=output_las, forward="all", a_srs=a_srs)
+        pipeline |= pdal.Writer.las(filename=output_las, forward="all", extra_dims="all", a_srs=a_srs)
         pipeline.execute()
 
 

pdaltools/color.py

@@ -1,196 +1,12 @@
 import argparse
 import tempfile
-import time
 from math import ceil, floor
-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
-
-            return func(*args, **kwargs)
-
-        return newfn
-
-    return decorator
-
-
-def is_image_white(filename: str):
-    raster_array = gdal_array.LoadFile(filename)
-    band_is_white = [np.all(band == 255) for band in raster_array]
-    return np.all(band_is_white)
-
-
-def download_image_from_geoplateforme(
-    proj, layer, minx, miny, maxx, maxy, width_pixels, height_pixels, outfile, timeout, check_images
-):
-    """
-    Download image using a wms request to geoplateforme.
-
-    Args:
-      proj (int): epsg code for the projection of the downloaded image.
-      layer: which kind of image is downloaded (ORTHOIMAGERY.ORTHOPHOTOS, ORTHOIMAGERY.ORTHOPHOTOS.IRC, ...).
-      minx, miny, maxx, maxy: box of the downloaded image.
-      width_pixels:  width in pixels of the downloaded image.
-      height_pixels:  height in pixels of the downloaded image.
-      outfile: file name of the downloaded file
-      timeout: delay after which the request is canceled (in seconds)
-      check_images (bool): enable checking if the output image is not a white image
-    """
-
-    # for layer in layers:
-    URL_GPP = "https://data.geopf.fr/wms-r/wms?"
-    URL_FORMAT = "&EXCEPTIONS=text/xml&FORMAT=image/geotiff&SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&STYLES="
-    URL_EPSG = "&CRS=EPSG:" + str(proj)
-    URL_BBOX = "&BBOX=" + str(minx) + "," + str(miny) + "," + str(maxx) + "," + str(maxy)
-    URL_SIZE = "&WIDTH=" + str(width_pixels) + "&HEIGHT=" + str(height_pixels)
-
-    URL = URL_GPP + "LAYERS=" + layer + URL_FORMAT + URL_EPSG + URL_BBOX + URL_SIZE
-
-    print(URL)
-    if timeout < 10:
-        print(f"Mode debug avec un timeout à {timeout} secondes")
-
-    req = requests.get(URL, allow_redirects=True, timeout=timeout)
-    req.raise_for_status()
-    print(f"Ecriture du fichier: {outfile}")
-    open(outfile, "wb").write(req.content)
-
-    if check_images and is_image_white(outfile):
-        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
-
-    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
-
-    return nb_pixels, nb_cells, cell_size_pixels
-
-
-@copy_and_hack_decorator
-def download_image(proj, layer, minx, miny, maxx, maxy, pixel_per_meter, outfile, timeout, check_images, size_max_gpf):
-    """
-    Download image using a wms request to geoplateforme with call of download_image_from_geoplateforme() :
-    image are downloaded in blocks then merged, in order to limit the size of geoplateforme requests.
-
-    Args:
-      proj: projection of the downloaded image.
-      layer: which kind of image is downloaed (ORTHOIMAGERY.ORTHOPHOTOS, ORTHOIMAGERY.ORTHOPHOTOS.IRC, ...).
-      minx, miny, maxx, maxy: box of the downloaded image.
-      pixel_per_meter: resolution of the downloaded image.
-      outfile: file name of the downloaed file
-      timeout: time after the request is canceled
-      check_images: check if images is not a white image
-      size_max_gpf: block size of downloaded images. (in pixels)
-
-    return the number of effective requests
-    """
-
-    download_image_from_geoplateforme_retrying = retry(times=9, delay=5, factor=2)(download_image_from_geoplateforme)
-
-    size_x_p, nb_cells_x, cell_size_x = compute_cells_size(minx, maxx, pixel_per_meter, size_max_gpf)
-    size_y_p, nb_cells_y, cell_size_y = compute_cells_size(minx, maxx, pixel_per_meter, size_max_gpf)
-
-    # the image size is under SIZE_MAX_IMAGE_GPF
-    if (size_x_p <= size_max_gpf) and (size_y_p <= size_max_gpf):
-        download_image_from_geoplateforme_retrying(
-            proj, layer, minx, miny, maxx, maxy, cell_size_x, cell_size_y, outfile, timeout, check_images
-        )
-        return 1
-
-    # the image is bigger than the SIZE_MAX_IMAGE_GPF
-    # it's preferable to compute it by paving
-    with tempfile.TemporaryDirectory() as tmp_dir:
-        tmp_gpg_ortho = []
-        for line in range(0, nb_cells_y):
-            for col in range(0, nb_cells_x):
-                # Cope for last line/col that can be slightly smaller than other cells
-                remaining_pixels_x = size_x_p - col * cell_size_x
-                remaining_pixels_y = size_y_p - line * cell_size_y
-                cell_size_x_local = min(cell_size_x, remaining_pixels_x)
-                cell_size_y_local = min(cell_size_y, remaining_pixels_y)
-
-                minx_cell = minx + col * cell_size_x / pixel_per_meter
-                maxx_cell = minx_cell + cell_size_x_local / pixel_per_meter
-                miny_cell = miny + line * cell_size_y / pixel_per_meter
-                maxy_cell = miny_cell + cell_size_y_local / pixel_per_meter
-
-                cells_ortho_paths = str(Path(tmp_dir)) + f"cell_{col}_{line}.tif"
-                download_image_from_geoplateforme_retrying(
-                    proj,
-                    layer,
-                    minx_cell,
-                    miny_cell,
-                    maxx_cell,
-                    maxy_cell,
-                    cell_size_x_local,
-                    cell_size_y_local,
-                    cells_ortho_paths,
-                    timeout,
-                    check_images,
-                )
-                tmp_gpg_ortho.append(cells_ortho_paths)
-
-        # merge the cells
-        with tempfile.NamedTemporaryFile(suffix="_gpf.vrt") as tmp_vrt:
-            gdal.BuildVRT(tmp_vrt.name, tmp_gpg_ortho)
-            gdal.Translate(outfile, tmp_vrt.name)
-
-    return nb_cells_x * nb_cells_y
+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]:
@@ -224,11 +40,47 @@ def color(
     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)
 
@@ -243,9 +95,9 @@ def color(
     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"]
+        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:
@@ -316,7 +168,13 @@ def parse_args():
     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"
+        "--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(
@@ -357,6 +215,7 @@ if __name__ == "__main__":
         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,

pdaltools/create_random_laz.py

@@ -8,11 +8,12 @@ from typing import List, Tuple
 
 def create_random_laz(
     output_file: str,
-    point_format: int = 3,
+    point_format: int = 6,
     num_points: int = 100,
     crs: int = 2154,
     center: Tuple[float, float] = (650000, 6810000),
     extra_dims: List[Tuple[str, str]] = [],
+    classifications: List[int] = None,
 ):
     """
     Create a test LAZ file with EPSG code and additional dimensions.
@@ -26,6 +27,7 @@ def create_random_laz(
                 (default: (650000, 6810000) ; around Paris)
         extra_dims: List of tuples (dimension_name, dimension_type) where type can be:
                    'float32', 'float64', 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64'
+        classifications: Optional list of classification values. 
     """
 
     # Create a new point cloud
@@ -52,7 +54,7 @@ def create_random_laz(
         numpy_type = type_mapping[dim_type]
         header.add_extra_dim(laspy.ExtraBytesParams(name=dim_name, type=numpy_type))
 
-        # Create point cloud
+    # Create point cloud
     las = laspy.LasData(header)
     las.header.add_crs(CRS.from_string(f"epsg:{crs}"))
 
@@ -64,14 +66,19 @@ def create_random_laz(
     # Generate random intensity values
     las.intensity = np.random.randint(0, 255, num_points)
 
-    # Generate random classification values
-    # 66 is the max value for classification of IGN LidarHD
-    # cf. https://geoservices.ign.fr/sites/default/files/2022-05/DT_LiDAR_HD_1-0.pdf
-    if point_format > 3:
-        num_classifications = 66
+    # Set classification values
+    if classifications:
+        # Randomly select from the provided classification values
+        las.classification = np.random.choice(classifications, size=num_points, replace=True).astype(np.uint8)
     else:
-        num_classifications = 10
-    las.classification = np.random.randint(0, num_classifications, num_points)
+        # Generate random classification values if not provided
+        # 66 is the max value for classification of IGN LidarHD
+        # cf. https://geoservices.ign.fr/sites/default/files/2022-05/DT_LiDAR_HD_1-0.pdf
+        if point_format >= 6:
+            num_classifications = 66
+        else:
+            num_classifications = 10
+        las.classification = np.random.randint(0, num_classifications, num_points, dtype=np.uint8)
 
     # Generate random values for each extra dimension
     for dim_name, dim_type in extra_dims:
@@ -112,20 +119,24 @@ def parse_args():
     # Parse arguments (assuming argparse is used)
     parser = argparse.ArgumentParser(description="Create a random LAZ file.")
     parser.add_argument("--output_file", type=str, help="Path to save the LAZ file")
-    parser.add_argument("--point_format", type=int, default=3, help="Point format of the LAZ file")
+    parser.add_argument("--point_format", type=int, default=6, help="Point format of the LAZ file")
     parser.add_argument("--num_points", type=int, default=100, help="Number of points to generate")
     parser.add_argument(
         "--extra_dims", type=str, nargs="*", default=[], help="Extra dimensions in the format name:type"
     )
     parser.add_argument("--crs", type=int, default=2154, help="Projection code")
     parser.add_argument(
-        "--center", type=str, default="650000,6810000", help="Center of the area to generate points in"
+        "--center", type=float, nargs=2, default=[650000.0, 6810000.0],
+        help="Center coordinates (x y) of the area to generate points in (space-separated)"
+    )
+    parser.add_argument(
+        "--classifications", type=int, nargs='+',
+        help="List of classification values (space-separated)"
     )
     return parser.parse_args()
 
 
 def main():
-
     # Parse arguments
     args = parse_args()
 
@@ -133,10 +144,21 @@ def main():
     extra_dims = [tuple(dim.split(":")) for dim in args.extra_dims]
 
     # Parse center
-    center = tuple(map(float, args.center.split(",")))
+    center = tuple(args.center[:2])  # Only take first 2 values if more are provided
+    
+    # Parse classifications if provided
+    classifications = args.classifications
 
     # Call create_random_laz
-    result = create_random_laz(args.output_file, args.point_format, args.num_points, args.crs, center, extra_dims)
+    result = create_random_laz(
+        args.output_file, 
+        args.point_format, 
+        args.num_points, 
+        args.crs, 
+        center, 
+        extra_dims,
+        classifications
+    )
 
     # Test output file
     test_output_file(result, args.output_file)

pdaltools/download_image.py

@@ -0,0 +1,192 @@
+"""Tool to download an image from IGN geoplateform: https://geoservices.ign.fr/"""
+
+import tempfile
+import time
+from math import ceil
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+import requests
+from osgeo import gdal, gdal_array
+
+from pdaltools.unlock_file import copy_and_hack_decorator
+
+
+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
+
+    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
+
+    return nb_pixels, nb_cells, cell_size_pixels
+
+
+def is_image_white(filename: str):
+    raster_array = gdal_array.LoadFile(filename)
+    band_is_white = [np.all(band == 255) for band in raster_array]
+    return np.all(band_is_white)
+
+
+def download_image_from_geoplateforme(
+    proj, layer, minx, miny, maxx, maxy, width_pixels, height_pixels, outfile, timeout, check_images
+):
+    """
+    Download image using a wms request to geoplateforme.
+
+    Args:
+      proj (int): epsg code for the projection of the downloaded image.
+      layer: which kind of image is downloaded (ORTHOIMAGERY.ORTHOPHOTOS, ORTHOIMAGERY.ORTHOPHOTOS.IRC, ...).
+      minx, miny, maxx, maxy: box of the downloaded image.
+      width_pixels:  width in pixels of the downloaded image.
+      height_pixels:  height in pixels of the downloaded image.
+      outfile: file name of the downloaded file
+      timeout: delay after which the request is canceled (in seconds)
+      check_images (bool): enable checking if the output image is not a white image
+    """
+
+    # for layer in layers:
+    URL_GPP = "https://data.geopf.fr/wms-r/wms?"
+    URL_FORMAT = "&EXCEPTIONS=text/xml&FORMAT=image/geotiff&SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&STYLES="
+    URL_EPSG = "&CRS=EPSG:" + str(proj)
+    URL_BBOX = "&BBOX=" + str(minx) + "," + str(miny) + "," + str(maxx) + "," + str(maxy)
+    URL_SIZE = "&WIDTH=" + str(width_pixels) + "&HEIGHT=" + str(height_pixels)
+
+    URL = URL_GPP + "LAYERS=" + layer + URL_FORMAT + URL_EPSG + URL_BBOX + URL_SIZE
+
+    print(URL)
+    if timeout < 10:
+        print(f"Mode debug avec un timeout à {timeout} secondes")
+
+    req = requests.get(URL, allow_redirects=True, timeout=timeout)
+    req.raise_for_status()
+    print(f"Ecriture du fichier: {outfile}")
+    open(outfile, "wb").write(req.content)
+
+    if check_images and is_image_white(outfile):
+        raise ValueError(f"Downloaded image is white, with stream: {layer}")
+
+
+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
+
+            return func(*args, **kwargs)
+
+        return newfn
+
+    return decorator
+
+
+@copy_and_hack_decorator
+def download_image(proj, layer, minx, miny, maxx, maxy, pixel_per_meter, outfile, timeout, check_images, size_max_gpf):
+    """
+    Download image using a wms request to geoplateforme with call of download_image_from_geoplateforme() :
+    image are downloaded in blocks then merged, in order to limit the size of geoplateforme requests.
+
+    Args:
+      proj: projection of the downloaded image.
+      layer: which kind of image is downloaed (ORTHOIMAGERY.ORTHOPHOTOS, ORTHOIMAGERY.ORTHOPHOTOS.IRC, ...).
+      minx, miny, maxx, maxy: box of the downloaded image.
+      pixel_per_meter: resolution of the downloaded image.
+      outfile: file name of the downloaed file
+      timeout: time after the request is canceled
+      check_images: check if images is not a white image
+      size_max_gpf: block size of downloaded images. (in pixels)
+
+    return the number of effective requests
+    """
+
+    download_image_from_geoplateforme_retrying = retry(times=9, delay=5, factor=2)(download_image_from_geoplateforme)
+
+    size_x_p, nb_cells_x, cell_size_x = compute_cells_size(minx, maxx, pixel_per_meter, size_max_gpf)
+    size_y_p, nb_cells_y, cell_size_y = compute_cells_size(minx, maxx, pixel_per_meter, size_max_gpf)
+
+    # the image size is under SIZE_MAX_IMAGE_GPF
+    if (size_x_p <= size_max_gpf) and (size_y_p <= size_max_gpf):
+        download_image_from_geoplateforme_retrying(
+            proj, layer, minx, miny, maxx, maxy, cell_size_x, cell_size_y, outfile, timeout, check_images
+        )
+        return 1
+
+    # the image is bigger than the SIZE_MAX_IMAGE_GPF
+    # it's preferable to compute it by paving
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_gpg_ortho = []
+        for line in range(0, nb_cells_y):
+            for col in range(0, nb_cells_x):
+                # Cope for last line/col that can be slightly smaller than other cells
+                remaining_pixels_x = size_x_p - col * cell_size_x
+                remaining_pixels_y = size_y_p - line * cell_size_y
+                cell_size_x_local = min(cell_size_x, remaining_pixels_x)
+                cell_size_y_local = min(cell_size_y, remaining_pixels_y)
+
+                minx_cell = minx + col * cell_size_x / pixel_per_meter
+                maxx_cell = minx_cell + cell_size_x_local / pixel_per_meter
+                miny_cell = miny + line * cell_size_y / pixel_per_meter
+                maxy_cell = miny_cell + cell_size_y_local / pixel_per_meter
+
+                cells_ortho_paths = str(Path(tmp_dir)) + f"cell_{col}_{line}.tif"
+                download_image_from_geoplateforme_retrying(
+                    proj,
+                    layer,
+                    minx_cell,
+                    miny_cell,
+                    maxx_cell,
+                    maxy_cell,
+                    cell_size_x_local,
+                    cell_size_y_local,
+                    cells_ortho_paths,
+                    timeout,
+                    check_images,
+                )
+                tmp_gpg_ortho.append(cells_ortho_paths)
+
+        # merge the cells
+        with tempfile.NamedTemporaryFile(suffix="_gpf.vrt") as tmp_vrt:
+            gdal.BuildVRT(tmp_vrt.name, tmp_gpg_ortho)
+            gdal.Translate(outfile, tmp_vrt.name)
+
+    return nb_cells_x * nb_cells_y

pdaltools/las_rename_dimension.py

@@ -5,10 +5,12 @@ This script allows renaming dimensions in a LAS file while preserving all other
 """
 
 import argparse
+import logging
 import pdal
 import sys
 from pathlib import Path
 from pdaltools.las_remove_dimensions import remove_dimensions_from_points
+from pdaltools.las_info import las_info_metadata
 
 
 def rename_dimension(input_file: str, output_file: str, old_dims: list[str], new_dims: list[str]):
@@ -31,8 +33,14 @@ def rename_dimension(input_file: str, output_file: str, old_dims: list[str], new
         if dim in mandatory_dimensions:
             raise ValueError(f"New dimension {dim} cannot be a mandatory dimension (X,Y,Z,x,y,z)")
 
+    metadata = las_info_metadata(input_file)
+    input_dimensions = metadata["dimensions"]
+
     pipeline = pdal.Pipeline() | pdal.Reader.las(input_file)
     for old, new in zip(old_dims, new_dims):
+        if old not in input_dimensions:
+            logging.warning(f"Dimension {old} not found in input file : we cannot rename it")
+            continue
         pipeline |= pdal.Filter.ferry(dimensions=f"{old} => {new}")
     pipeline |= pdal.Writer.las(output_file)
     pipeline.execute()

pdaltools/replace_area_in_pointcloud.py

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