ign-pdal-tools 1.7.11__py3-none-any.whl → 1.8.0__py3-none-any.whl

{ign_pdal_tools-1.7.11.dist-info → ign_pdal_tools-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.7.11
+Version: 1.8.0
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown
@@ -88,10 +88,15 @@ By default, `xcoord` and `ycoord` are given in kilometers and the shape of the t
 `readers.las: Global encoding WKT flag not set for point format 6 - 10.` which is due to TerraSolid
 malformed LAS output for LAS1.4 files with point format 6 to 10.
 
-## Add points in Las
-
-[add_points_in_las.py](pdaltools/add_points_in_las.py): add points from some vector files (ex: shp, geojson, ...) inside Las. New points will have X,Y and Z coordinates. Other attributes values given by  the initial las file are null (ex: classification at 0). These others attributes could be forced by using the '--dimensions/-d' option in the command line (ex : 'add_points_in_las.py -i myLas.las -g myPoints.json -d classification=64' - points will have their classification set to 64). The dimension should be present in the initial las ; this is not allowed to add new dimension.
+## Add points in pointcloud
 
+[add_points_in_pointcloud.py](pdaltools/add_points_in_pointcloud.py): add points from some vector files (ex: shp, geojson, ...) inside Las/Laz:
+- 2 kinds of geometries are handled:
+  - if the geometries in the vector file are points, they are added directly to the las file
+  - if the geometries are lines, points are added along this line using a `spacing` parameter
+- In case the points are 2D only, Z can be provided as a feature property (parametrized via `altitude_column`)
+- The Classification attribute for these points is parametrized via `virtual_points_classes`
+- All the other attributes are set to 0.
 
 # Dev / Build
 

ign_pdal_tools-1.8.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+ign_pdal_tools-1.8.0.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
+pdaltools/_version.py,sha256=pEplHESmf3mY4hIMzjat2Shw3-14Tac3CBkIZS49uF8,74
+pdaltools/add_points_in_pointcloud.py,sha256=UHdC8tFagsehGggkLJCcmBCi8gknJOL4s99f_2TJjsA,12538
+pdaltools/color.py,sha256=vJgpb8dOvT5rnq5NdVOaMdGc_pKL3damLy4HwGvigJQ,14472
+pdaltools/las_add_buffer.py,sha256=sBpTywlfsHHS8KuCUa-eydB2hylshEvjrMQt5TrqXb8,11275
+pdaltools/las_clip.py,sha256=GvEOYu8RXV68e35kU8i42GwSkbo4P9TvmS6rkrdPmFM,1034
+pdaltools/las_info.py,sha256=lMKxKzsViptDENI1wOlANG4qOvdc19ixyasYKD-N1ck,9512
+pdaltools/las_merge.py,sha256=tcFVueV9X9nNEaoAl5zCduY5DETlBg63MAgP2SuKiNo,4121
+pdaltools/las_remove_dimensions.py,sha256=VX6jQqjF298bsPm6MJQlBH-7ue9fG7XlwhDzdkACZ84,1793
+pdaltools/pcd_info.py,sha256=NIAH5KGikVDQLlbCcw9FuaPqe20UZvRfkHsDZd5kmZA,3210
+pdaltools/replace_attribute_in_las.py,sha256=po1F-fi8s7iilqKWaryW4JRbsmdMOUe0yGvG3AEKxtk,4771
+pdaltools/standardize_format.py,sha256=gqm2GJbtDkT4k4oC_NX2LIPh9R2BLh4sMHLKYgfKrMc,3973
+pdaltools/unlock_file.py,sha256=pIThdWMNkTph0xgJVVRaM1o9aUMQhM6804PscScB3JI,1963
+ign_pdal_tools-1.8.0.dist-info/METADATA,sha256=r8S5uK_1JposFNefYk7ieT8OR4atRWkGERd1XGIcHYg,5777
+ign_pdal_tools-1.8.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+ign_pdal_tools-1.8.0.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
+ign_pdal_tools-1.8.0.dist-info/RECORD,,

{ign_pdal_tools-1.7.11.dist-info → ign_pdal_tools-1.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.11"
+__version__ = "1.8.0"
 
 
 if __name__ == "__main__":

pdaltools/color.py

@@ -1,12 +1,14 @@
 import argparse
 import tempfile
 import time
-from math import ceil
+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_array
+from osgeo import gdal, gdal_array
 
 import pdaltools.las_info as las_info
 from pdaltools.unlock_file import copy_and_hack_decorator
@@ -28,7 +30,7 @@ def pretty_time_delta(seconds):
         return "%s%ds" % (sign_string, seconds)
 
 
-def retry(times, delay, factor=2, debug=False):
+def retry(times, delay, factor, debug=False):
     def decorator(func):
         def newfn(*args, **kwargs):
             attempt = 1
@@ -61,25 +63,28 @@ def is_image_white(filename: str):
 
 
 def download_image_from_geoplateforme(
-    proj, layer, minx, miny, maxx, maxy, pixel_per_meter, outfile, timeout, check_images
+    proj, layer, minx, miny, maxx, maxy, width_pixels, height_pixels, outfile, timeout, check_images
 ):
-    # Force a 1-pixel margin in the east and south borders
-    # to make sure that no point of the pointcloud is on the limit of the last pixel
-    # to prevent interpolation issues
-    maxx = maxx + 1 / pixel_per_meter
-    miny = miny - 1 / pixel_per_meter
+    """
+    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(ceil((maxx - minx) * pixel_per_meter))
-        + "&HEIGHT="
-        + str(ceil((maxy - miny) * pixel_per_meter))
-    )
+    URL_SIZE = "&WIDTH=" + str(width_pixels) + "&HEIGHT=" + str(height_pixels)
 
     URL = URL_GPP + "LAYERS=" + layer + URL_FORMAT + URL_EPSG + URL_BBOX + URL_SIZE
 
@@ -96,7 +101,120 @@ 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
+
+    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
+
+
+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,
@@ -109,10 +227,14 @@ def color(
     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)
 
@@ -120,8 +242,6 @@ def color(
 
     writer_extra_dims = "all"
 
-    download_image_from_geoplateforme_retrying = retry(times=9, delay=5, factor=2)(download_image_from_geoplateforme)
-
     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")
@@ -130,8 +250,18 @@ def color(
     tmp_ortho = None
     if color_rvb_enabled:
         tmp_ortho = tempfile.NamedTemporaryFile(suffix="_rvb.tif")
-        download_image_from_geoplateforme_retrying(
-            proj, stream_RGB, minx, miny, maxx, maxy, pixel_per_meter, tmp_ortho.name, timeout_second, check_images
+        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.
@@ -143,8 +273,18 @@ def color(
     tmp_ortho_irc = None
     if color_ir_enabled:
         tmp_ortho_irc = tempfile.NamedTemporaryFile(suffix="_irc.tif")
-        download_image_from_geoplateforme_retrying(
-            proj, stream_IRC, minx, miny, maxx, maxy, pixel_per_meter, tmp_ortho_irc.name, timeout_second, check_images
+        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.
@@ -195,6 +335,13 @@ for 50 cm resolution rasters, use ORTHOIMAGERY.ORTHOPHOTOS.BDORTHO""",
         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()
 
@@ -213,4 +360,5 @@ if __name__ == "__main__":
         check_images=args.check_images,
         stream_RGB=args.stream_RGB,
         stream_IRC=args.stream_IRC,
+        size_max_gpf=args.size_max_GPF,
     )

pdaltools/las_remove_dimensions.py

@@ -1,6 +1,7 @@
 import argparse
 
 import pdal
+
 from pdaltools.las_info import get_writer_parameters_from_reader_metadata
 
 

ign_pdal_tools-1.7.11.dist-info/RECORD

@@ -1,18 +0,0 @@
-ign_pdal_tools-1.7.11.dist-info/licenses/LICENSE.md,sha256=iVzCFZTUXeiqP8bP474iuWZiWO_kDCD4SPh1Wiw125Y,1120
-pdaltools/_version.py,sha256=lXuB5yCoqB_XdA0YVaGjTGc2J_sFF0RE_IJePTMnyjI,75
-pdaltools/add_points_in_las.py,sha256=TGbt5JUkszjmbQiA2LCUntsjz6A8DHb7QPIXGDuEgWA,3643
-pdaltools/add_points_in_pointcloud.py,sha256=UHdC8tFagsehGggkLJCcmBCi8gknJOL4s99f_2TJjsA,12538
-pdaltools/color.py,sha256=-a0ramyLMkZX4-M3siPq1zIio5u-a0p8UzvgcfoU6zU,8313
-pdaltools/las_add_buffer.py,sha256=sBpTywlfsHHS8KuCUa-eydB2hylshEvjrMQt5TrqXb8,11275
-pdaltools/las_clip.py,sha256=GvEOYu8RXV68e35kU8i42GwSkbo4P9TvmS6rkrdPmFM,1034
-pdaltools/las_info.py,sha256=lMKxKzsViptDENI1wOlANG4qOvdc19ixyasYKD-N1ck,9512
-pdaltools/las_merge.py,sha256=tcFVueV9X9nNEaoAl5zCduY5DETlBg63MAgP2SuKiNo,4121
-pdaltools/las_remove_dimensions.py,sha256=u_3VfkabkN_Y3eDLdJwCLVGpondvIx0f0v0RdFDoAFw,1792
-pdaltools/pcd_info.py,sha256=NIAH5KGikVDQLlbCcw9FuaPqe20UZvRfkHsDZd5kmZA,3210
-pdaltools/replace_attribute_in_las.py,sha256=po1F-fi8s7iilqKWaryW4JRbsmdMOUe0yGvG3AEKxtk,4771
-pdaltools/standardize_format.py,sha256=gqm2GJbtDkT4k4oC_NX2LIPh9R2BLh4sMHLKYgfKrMc,3973
-pdaltools/unlock_file.py,sha256=pIThdWMNkTph0xgJVVRaM1o9aUMQhM6804PscScB3JI,1963
-ign_pdal_tools-1.7.11.dist-info/METADATA,sha256=Bh4cFjnGLLt4DpiPw8GQuknhDTrLQqx3H5EjkFzV1n4,5745
-ign_pdal_tools-1.7.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ign_pdal_tools-1.7.11.dist-info/top_level.txt,sha256=KvGW0ZzqQbhCKzB5_Tp_buWMZyIgiO2M2krWF_ecOZc,10
-ign_pdal_tools-1.7.11.dist-info/RECORD,,

pdaltools/add_points_in_las.py

@@ -1,104 +0,0 @@
-import argparse
-
-import geopandas
-import numpy as np
-import pdal
-
-from pdaltools.las_info import get_writer_parameters_from_reader_metadata, las_info_metadata, get_bounds_from_header_info
-
-
-def extract_points_from_geo(input_geo: str):
-    file = open(input_geo)
-    df = geopandas.read_file(file)
-    return df.get_coordinates(ignore_index=True, include_z=True)
-
-def point_in_bound(bound_minx, bound_maxx, bound_miny, bound_maxy, pt_x, pt_y):
-    return pt_x >= bound_minx and  pt_x <= bound_maxx and pt_y >= bound_miny and  pt_y <= bound_maxy
-
-def add_points_in_las(input_las: str, input_geo: str, output_las: str, inside_las: bool, values_dimensions: {}):
-    points_geo = extract_points_from_geo(input_geo)
-    pipeline = pdal.Pipeline() | pdal.Reader.las(input_las)
-    pipeline.execute()
-    points_las = pipeline.arrays[0]
-    dimensions = list(points_las.dtype.fields.keys())
-
-    if inside_las:
-        mtd = las_info_metadata(input_las)
-        bound_minx, bound_maxx, bound_miny, bound_maxy = get_bounds_from_header_info(mtd)
-
-    for i in points_geo.index:
-        if inside_las :
-            if not point_in_bound(bound_minx, bound_maxx, bound_miny, bound_maxy, points_geo["x"][i], points_geo["y"][i]):
-                continue
-        pt_las = np.empty(1, dtype=points_las.dtype)
-        pt_las[0][dimensions.index("X")] = points_geo["x"][i]
-        pt_las[0][dimensions.index("Y")] = points_geo["y"][i]
-        pt_las[0][dimensions.index("Z")] = points_geo["z"][i]
-        for val in values_dimensions:
-            pt_las[0][dimensions.index(val)] = values_dimensions[val]
-        points_las = np.append(points_las, pt_las, axis=0)
-
-    params = get_writer_parameters_from_reader_metadata(pipeline.metadata)
-    pipeline_end = pdal.Pipeline(arrays=[points_las])
-    pipeline_end |= pdal.Writer.las(output_las, forward="all", **params)
-    pipeline_end.execute()
-
-
-def parse_args():
-    parser = argparse.ArgumentParser("Add points from geometry file in a las/laz file.")
-    parser.add_argument("--input_file", "-i", type=str, help="Las/Laz input file")
-    parser.add_argument("--output_file", "-o", type=str, help="Las/Laz output file.")
-    parser.add_argument("--input_geo_file", "-g", type=str, help="Geometry input file.")
-    parser.add_argument("--inside_las", "-l", type=str, help="Keep points only inside the las boundary.")
-    parser.add_argument(
-        "--dimensions",
-        "-d",
-        metavar="KEY=VALUE",
-        nargs="+",
-        help="Set a number of key-value pairs corresponding to value "
-        "needed in points added in the output las; key should be included in the input las.",
-    )
-    return parser.parse_args()
-
-
-def is_nature(value, nature):
-    if value is None:
-        return False
-    try:
-        nature(value)
-        return True
-    except:
-        return False
-
-
-def parse_var(s):
-    items = s.split("=")
-    key = items[0].strip()
-    if len(items) > 1:
-        value = "=".join(items[1:])
-        if is_nature(value, int):
-            value = int(value)
-        elif is_nature(value, float):
-            value = float(value)
-    return (key, value)
-
-
-def parse_vars(items):
-    d = {}
-    if items:
-        for item in items:
-            key, value = parse_var(item)
-            d[key] = value
-    return d
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    added_dimensions = parse_vars(args.dimensions)
-    add_points_in_las(
-        input_las=args.input_file,
-        input_geo=args.input_geo_file,
-        output_las=args.input_file if args.output_file is None else args.output_file,
-        inside_las=args.inside_las,
-        values_dimensions=added_dimensions,
-    )