ign-pdal-tools 1.7.11__tar.gz → 1.8.1__tar.gz

{ign_pdal_tools-1.7.11 → ign_pdal_tools-1.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.7.11
+Version: 1.8.1
 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.7.11 → ign_pdal_tools-1.8.1}/README.md

@@ -79,10 +79,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.7.11 → ign_pdal_tools-1.8.1}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.7.11
+Version: 1.8.1
 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.7.11 → ign_pdal_tools-1.8.1}/ign_pdal_tools.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ ign_pdal_tools.egg-info/SOURCES.txt
 ign_pdal_tools.egg-info/dependency_links.txt
 ign_pdal_tools.egg-info/top_level.txt
 pdaltools/_version.py
-pdaltools/add_points_in_las.py
 pdaltools/add_points_in_pointcloud.py
 pdaltools/color.py
 pdaltools/las_add_buffer.py
@@ -18,7 +17,6 @@ pdaltools/pcd_info.py
 pdaltools/replace_attribute_in_las.py
 pdaltools/standardize_format.py
 pdaltools/unlock_file.py
-test/test_add_points_in_las.py
 test/test_add_points_in_pointcloud.py
 test/test_color.py
 test/test_las_add_buffer.py

{ign_pdal_tools-1.7.11 → ign_pdal_tools-1.8.1}/pdaltools/_version.py

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

{ign_pdal_tools-1.7.11 → ign_pdal_tools-1.8.1}/pdaltools/add_points_in_pointcloud.py

@@ -127,6 +127,9 @@ def add_points_to_las(
         crs (str): CRS of the data.
         virtual_points_classes (int): The classification value to assign to those virtual points (default: 66).
     """
+    # Copy data pointcloud
+    copy2(input_las, output_las)
+
     if input_points_with_z.empty:
         print(
             "No points to add. All points of the geojson file are outside the tile. Copying the input file to output"
@@ -141,7 +144,7 @@ def add_points_to_las(
     classes = virtual_points_classes * np.ones(nb_points)
 
     # Open the input LAS file to check and possibly update the header of the output
-    with laspy.open(input_las) as las:
+    with laspy.open(input_las, "r") as las:
         header = las.header
         if not header:
             header = laspy.LasHeader(point_format=8, version="1.4")
@@ -152,11 +155,7 @@ def add_points_to_las(
                 raise ValueError(f"Invalid CRS: {crs}")
             header.add_crs(crs_obj)
 
-    # Copy data pointcloud
-    copy2(input_las, output_las)
-
     # Add the new points with 3D points
-    nb_points = len(x_coords)
     with laspy.open(output_las, mode="a", header=header) as output_las:  # mode `a` for adding points
         # create nb_points points with "0" everywhere
         new_points = laspy.ScaleAwarePointRecord.zeros(nb_points, header=header)  # use header for input_las

{ign_pdal_tools-1.7.11 → ign_pdal_tools-1.8.1}/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,
     )

{ign_pdal_tools-1.7.11 → ign_pdal_tools-1.8.1}/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 → ign_pdal_tools-1.8.1}/test/test_add_points_in_pointcloud.py

@@ -26,6 +26,7 @@ INPUT_LIGNES_2D_GEOJSON = os.path.join(DATA_LIGNES_PATH, "Lignes_2d_0292_6833.ge
 INPUT_LIGNES_3D_GEOJSON = os.path.join(DATA_LIGNES_PATH, "Lignes_3d_0292_6833.geojson")
 INPUT_LIGNES_SHAPE = os.path.join(DATA_LIGNES_PATH, "Lignes_3d_0292_6833.shp")
 OUTPUT_FILE = os.path.join(TMP_PATH, "test_semis_2023_0292_6833_LA93_IGN69.laz")
+INPUT_EMPTY_POINTS_2D = os.path.join(DATA_POINTS_3D_PATH, "Points_virtuels_2d_empty.geojson")
 
 # Cropped las tile used to test adding points that belong to the theorical tile but not to the
 # effective las file extent
@@ -81,19 +82,21 @@ def test_clip_3d_lines_to_tile(input_file, epsg):
 
 
 @pytest.mark.parametrize(
-    "input_file, epsg, expected_nb_points",
+    "input_file, epsg, input_points_2d, expected_nb_points",
     [
-        (INPUT_PCD, "EPSG:2154", 2423),  # should work when providing an epsg value
-        (INPUT_PCD, None, 2423),  # Should also work with no epsg value (get from las file)
-        (INPUT_PCD_CROPPED, None, 2423),
+        (INPUT_PCD, "EPSG:2154", INPUT_POINTS_2D, 2423),  # should work when providing an epsg value
+        (INPUT_PCD, None, INPUT_POINTS_2D, 2423),  # Should also work with no epsg value (get from las file)
+        (INPUT_PCD_CROPPED, None, INPUT_POINTS_2D_FOR_CROPPED_PCD, 451),
+        # Should also work if there is no points (direct copy of the input file)
+        (INPUT_PCD_CROPPED, None, INPUT_EMPTY_POINTS_2D, 0),
     ],
 )
-def test_add_points_to_las(input_file, epsg, expected_nb_points):
+def test_add_points_to_las(input_file, epsg, input_points_2d, expected_nb_points):
     # Ensure the output file doesn't exist before the test
     if Path(OUTPUT_FILE).exists():
         os.remove(OUTPUT_FILE)
 
-    points = gpd.read_file(INPUT_POINTS_2D)
+    points = gpd.read_file(input_points_2d)
     add_points_in_pointcloud.add_points_to_las(points, input_file, OUTPUT_FILE, epsg, 68)
     assert Path(OUTPUT_FILE).exists()  # check output exists
 

ign_pdal_tools-1.8.1/test/test_color.py

@@ -0,0 +1,379 @@
+import math
+import os
+import shutil
+from pathlib import Path
+
+import laspy
+import numpy as np
+import pytest
+import requests
+import requests_mock
+from osgeo import gdal
+
+from pdaltools import color
+
+cwd = os.getcwd()
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+TMPDIR = os.path.join(TEST_PATH, "tmp")
+
+INPUT_PATH = os.path.join(TEST_PATH, "data/test_noepsg_043500_629205_IGN69.laz")
+
+OUTPUT_FILE = os.path.join(TMPDIR, "Semis_2021_0435_6292_LA93_IGN69.colorized.las")
+EPSG = "2154"
+LAYER = "ORTHOIMAGERY.ORTHOPHOTOS"
+MINX = 435000
+MINY = 6291000
+MAXX = 436000
+MAXY = 6292000
+PIXEL_PER_METER = 0.1
+SIZE_MAX_IMAGE_GPF = 500
+
+
+def setup_module(module):
+    try:
+        shutil.rmtree(TMPDIR)
+    except FileNotFoundError:
+        pass
+    os.mkdir(TMPDIR)
+
+
+@pytest.mark.geopf
+def test_epsg_fail():
+    with pytest.raises(
+        RuntimeError,
+        match="EPSG could not be inferred from metadata: No 'srs' key in metadata.",
+    ):
+        color.color(INPUT_PATH, OUTPUT_FILE, "", 0.1, 15)
+
+
+@pytest.mark.geopf
+def test_color_and_keeping_orthoimages():
+    tmp_ortho, tmp_ortho_irc = color.color(INPUT_PATH, OUTPUT_FILE, EPSG, check_images=True)
+    assert Path(tmp_ortho.name).exists()
+    assert Path(tmp_ortho_irc.name).exists()
+
+
+@pytest.mark.parametrize(
+    "mind, maxd, pixel_per_meter, size_max_gpf, expected_nb_pixels, expected_nb_cells, expected_cell_size",
+    [
+        (0, 1000, 1, 500, 1000, 2, 500),  # Easy case, sizes match perfectly
+        (0, 1001, 1, 1000, 1001, 2, 501),  # Image slightly bigger than size_max_gpf
+        (0.1, 999.2, 1, 500, 1000, 2, 500),  # floating value for min/max
+    ],
+)
+def test_compute_cells_size(
+    mind, maxd, pixel_per_meter, size_max_gpf, expected_nb_pixels, expected_nb_cells, expected_cell_size
+):
+    nb_pixels, nb_cells, cell_size = color.compute_cells_size(mind, maxd, pixel_per_meter, size_max_gpf)
+    assert nb_pixels == expected_nb_pixels
+    assert nb_cells == expected_nb_cells
+    assert cell_size == expected_cell_size
+
+
+@pytest.mark.geopf
+def test_download_image_ok():
+    tif_output = os.path.join(TMPDIR, "download_image.tif")
+    color.download_image(
+        EPSG, LAYER, MINX, MINY, MAXX, MAXY, PIXEL_PER_METER, tif_output, 15, True, size_max_gpf=SIZE_MAX_IMAGE_GPF
+    )
+
+    # check there is no noData
+    raster = gdal.Open(tif_output)
+    assert np.any(raster.ReadAsArray())  # Check that the raster array is not empty
+    # TODO: Fix this test: it did not correspond to what was expected:
+    # - GetNoDataValue returns the value of no_data, not the number of occurrences
+    # - it is possible to have occasional no data values if no_data == 255. (white pixels)
+    # for i in range(raster.RasterCount):
+    #     assert raster.GetRasterBand(i + 1).GetNoDataValue() is None
+
+
+@pytest.mark.geopf
+def test_download_image_ok_one_download():
+    tif_output = os.path.join(TMPDIR, "download_image.tif")
+    expected_pixel_size = 100  # (MAXX - MINX) * PIXEL_PER_METER
+    nb_request = color.download_image(
+        EPSG, LAYER, MINX, MINY, MAXX, MAXY, PIXEL_PER_METER, tif_output, 15, True, size_max_gpf=1000
+    )
+    assert nb_request == 1
+
+    # check there is no noData
+    raster = gdal.Open(tif_output)
+    assert raster.ReadAsArray().shape == (3, expected_pixel_size, expected_pixel_size)
+    assert np.any(raster.ReadAsArray())  # Check that the raster array is not empty
+    # TODO: Fix this test: it did not correspond to what was expected:
+    # - GetNoDataValue returns the value of no_data, not the number of occurrences
+    # - it is possible to have occasional no data values if no_data == 255. (white pixels)
+    # for i in range(raster.RasterCount):
+    #     assert raster.GetRasterBand(i + 1).GetNoDataValue() is None
+
+
+@pytest.mark.geopf
+@pytest.mark.parametrize("pixel_per_meter, expected_pixel_size", [(0.5, 501), (1, 1001), (2, 2001)])
+def test_download_image_ok_one_download_with_extra_pixel(pixel_per_meter, expected_pixel_size):
+    # test with 1 extra pixel to compensate the phase difference between raster and lidar
+    tif_output = os.path.join(TMPDIR, "download_image.tif")
+
+    maxx = MAXX + 1 / pixel_per_meter
+    maxy = MAXY + 1 / pixel_per_meter
+    nb_request = color.download_image(
+        EPSG, LAYER, MINX, MINY, maxx, maxy, pixel_per_meter, tif_output, 15, True, size_max_gpf=5000
+    )
+    assert nb_request == 1
+
+    # check there is no noData
+    raster = gdal.Open(tif_output)
+
+    assert raster.ReadAsArray().shape == (3, expected_pixel_size, expected_pixel_size)
+    assert np.any(raster.ReadAsArray())  # Check that the raster array is not empty
+    # TODO: Fix this test: it did not correspond to what was expected:
+    # - GetNoDataValue returns the value of no_data, not the number of occurrences
+    # - it is possible to have occasional no data values if no_data == 255. (white pixels)
+    # for i in range(raster.RasterCount):
+    #     assert raster.GetRasterBand(i + 1).GetNoDataValue() is None
+
+
+@pytest.mark.geopf
+@pytest.mark.parametrize("pixel_per_meter, expected_pixel_size", [(0.5, 500), (1, 1000), (2, 2000), (5, 5000)])
+def test_download_image_ok_more_downloads(pixel_per_meter, expected_pixel_size):
+    tif_output = os.path.join(TMPDIR, f"download_image_resolution_{pixel_per_meter}.tif")
+
+    nb_request = color.download_image(
+        EPSG,
+        LAYER,
+        MINX,
+        MINY,
+        MAXX,
+        MAXY,
+        pixel_per_meter,
+        tif_output,
+        15,
+        True,
+        size_max_gpf=1000,
+    )
+    assert nb_request == max(1, 1 * pixel_per_meter * pixel_per_meter)
+
+    # check there is no noData
+    raster = gdal.Open(tif_output)
+    assert raster.ReadAsArray().shape == (3, expected_pixel_size, expected_pixel_size)
+    assert np.any(raster.ReadAsArray())  # Check that the raster array is not empty
+    # TODO: Fix this test: it did not correspond to what was expected:
+    # - GetNoDataValue returns the value of no_data, not the number of occurrences
+    # - it is possible to have occasional no data values if no_data == 255. (white pixels)
+    # for i in range(raster.RasterCount):
+    #     assert raster.GetRasterBand(i + 1).GetNoDataValue() is None
+
+
+@pytest.mark.geopf
+@pytest.mark.parametrize(
+    "pixel_per_meter, expected_nb_requests, expected_pixel_size",
+    [(0.5, 1, 501), (1, 4, 1001), (2, 9, 2001), (4, 25, 4001)],
+)
+def test_download_image_ok_more_downloads_with_extra_pixel(pixel_per_meter, expected_nb_requests, expected_pixel_size):
+    # test with 1 extra pixel to compensate the phase difference between raster and lidar
+    tif_output = os.path.join(TMPDIR, "download_image.tif")
+    maxx = MAXX + 1 / pixel_per_meter
+    maxy = MAXY + 1 / pixel_per_meter
+    nb_request = color.download_image(
+        EPSG, LAYER, MINX, MINY, maxx, maxy, pixel_per_meter, tif_output, 15, True, size_max_gpf=1000
+    )
+    assert nb_request == expected_nb_requests
+
+    # check there is no noData
+    raster = gdal.Open(tif_output)
+    assert raster.ReadAsArray().shape == (3, expected_pixel_size, expected_pixel_size)
+    assert np.any(raster.ReadAsArray())  # Check that the raster array is not empty
+    # TODO: Fix this test: it did not correspond to what was expected:
+    # - GetNoDataValue returns the value of no_data, not the number of occurrences
+    # - it is possible to have occasional no data values if no_data == 255. (white pixels)
+    # for i in range(raster.RasterCount):
+    #     assert raster.GetRasterBand(i + 1).GetNoDataValue() is None
+
+
+@pytest.mark.geopf
+def test_download_image_download_size_gpf_bigger():
+    tif_output = os.path.join(TMPDIR, "download_image_bigger.tif")
+    color.download_image(EPSG, LAYER, MINX, MINY, MAXX, MAXY, PIXEL_PER_METER, tif_output, 15, True, size_max_gpf=1005)
+
+    # check there is no noData
+    raster = gdal.Open(tif_output)
+    assert np.any(raster.ReadAsArray())  # Check that the raster array is not empty
+    # TODO: Fix this test: it did not correspond to what was expected:
+    # - GetNoDataValue returns the value of no_data, not the number of occurrences
+    # - it is possible to have occasional no data values if no_data == 255. (white pixels)
+    # for i in range(raster.RasterCount):
+    #     assert raster.GetRasterBand(i + 1).GetNoDataValue() is None
+
+
+@pytest.mark.geopf
+def test_download_image_download_size_gpf_size_almost_ok():
+    tif_output = os.path.join(TMPDIR, "download_image_bigger.tif")
+    nb_request = color.download_image(
+        EPSG, LAYER, MINX, MINY, MAXX, MAXY, PIXEL_PER_METER, tif_output, 15, True, size_max_gpf=99
+    )
+    assert nb_request == 4
+
+    # check there is no noData
+    raster = gdal.Open(tif_output)
+    assert np.any(raster.ReadAsArray())  # Check that the raster array is not empty
+    # TODO: Fix this test: it did not correspond to what was expected:
+    # - GetNoDataValue returns the value of no_data, not the number of occurrences
+    # - it is possible to have occasional no data values if no_data == 255. (white pixels)
+    # for i in range(raster.RasterCount):
+    #     assert raster.GetRasterBand(i + 1).GetNoDataValue() is None
+
+
+@pytest.mark.geopf
+@pytest.mark.parametrize("size_block", [100, 50, 25])
+def test_download_image_compare_one_and_block(size_block):
+    tif_output_one = os.path.join(TMPDIR, "download_image_one.tif")
+    nb_request = color.download_image(
+        EPSG, LAYER, MINX, MINY, MAXX, MAXY, PIXEL_PER_METER, tif_output_one, 15, True, 100
+    )
+    assert nb_request == 1
+
+    tif_output_blocks = os.path.join(TMPDIR, "download_image_block.tif")
+    nb_request = color.download_image(
+        EPSG, LAYER, MINX, MINY, MAXX, MAXY, PIXEL_PER_METER, tif_output_blocks, 100, True, size_block
+    )
+    assert nb_request == math.pow(1000 * PIXEL_PER_METER / size_block, 2)
+
+    # due to GeoPlateforme interpolation, images could have small differences
+    # check images are almost the same
+
+    raster_one = gdal.Open(tif_output_one)
+    raster_blocks = gdal.Open(tif_output_blocks)
+
+    r_one = np.array(raster_one.ReadAsArray())
+    r_blocks = np.array(raster_blocks.ReadAsArray())
+    assert r_one.size == r_blocks.size
+    r_diff = r_one - r_blocks
+
+    # images should be same as 5/1000 (tolerance)
+    assert np.count_nonzero(r_diff) < 0.005 * ((MAXX - MINX) * (MAXY - MINY) * math.pow(PIXEL_PER_METER, 2))
+
+    # differences should be 1 or 255 (eq a variation of one on one RVB canal)
+    r_diff_nonzero = np.nonzero(r_diff)
+    for i in range(0, r_diff_nonzero[0].size):
+        diff = r_diff[r_diff_nonzero[0][i], r_diff_nonzero[1][i], r_diff_nonzero[2][i]]
+        assert diff == 1 or diff == 255
+
+
+@pytest.mark.parametrize(
+    "minx, maxx, pixel_per_meter, expected_minx, expected_maxx",
+    [(500, 1000, 5, 499.8, 1000.2), [1.1, 999.9, 5, 1, 1000]],
+)
+def test_match_min_max_with_pixel_size(minx, maxx, pixel_per_meter, expected_minx, expected_maxx):
+    out_minx, out_maxx = color.match_min_max_with_pixel_size(minx, maxx, pixel_per_meter)
+    assert (out_minx, out_maxx) == (expected_minx, expected_maxx)
+
+
+@pytest.mark.geopf
+def test_color_narrow_cloud():
+    input_path = os.path.join(TEST_PATH, "data/test_data_0436_6384_LA93_IGN69_single_point.laz")
+    output_path = os.path.join(TMPDIR, "color_narrow_cloud_test_data_0436_6384_LA93_IGN69_single_point.colorized.laz")
+    # Test that clouds that are smaller in width or height to 20cm are still colorized without an error.
+    color.color(input_path, output_path, EPSG)
+    with laspy.open(output_path, "r") as las:
+        las_data = las.read()
+    # Check all points are colored
+    assert not np.any(las_data.red == 0)
+    assert not np.any(las_data.green == 0)
+    assert not np.any(las_data.blue == 0)
+    assert not np.any(las_data.nir == 0)
+
+
+@pytest.mark.geopf
+def test_color_standard_cloud():
+    input_path = os.path.join(TEST_PATH, "data/test_data_77055_627760_LA93_IGN69.laz")
+    output_path = os.path.join(TMPDIR, "color_standard_cloud_test_data_77055_627760_LA93_IGN69.colorized.laz")
+    # Test that clouds that are smaller in width or height to 20cm are still colorized without an error.
+    color.color(input_path, output_path, EPSG)
+    with laspy.open(output_path, "r") as las:
+        las_data = las.read()
+    # Check all points are colored
+    las_rgb_missing = (las_data.red == 0) & (las_data.green == 0) & (las_data.blue == 0)
+    assert not np.any(las_rgb_missing), f"Should be no missing RGB value, got {np.count_nonzero(las_rgb_missing)} "
+    assert not np.any(las_data.nir == 0)
+
+
+@pytest.mark.geopf
+def test_color_epsg_2975_forced():
+    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
+    output_path = os.path.join(TMPDIR, "color_epsg_2975_forced_sample_lareunion_epsg2975.colorized.laz")
+
+    color.color(input_path, output_path, 2975)
+
+
+def test_is_image_white_true():
+    input_path = os.path.join(TEST_PATH, "data/image/white.tif")
+    assert color.is_image_white(input_path), "This image should be detected as white"
+
+
+def test_is_image_white_false():
+    input_path = os.path.join(TEST_PATH, "data/image/colored.tif")
+    assert not color.is_image_white(input_path), "This image should NOT be detected as white"
+
+
+@pytest.mark.geopf
+def test_color_raise_for_white_image():
+    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
+    output_path = os.path.join(TMPDIR, "sample_lareunion_epsg2975.colorized.white.laz")
+
+    with pytest.raises(ValueError) as excinfo:
+        color.color(input_path, output_path, check_images=True)
+
+    assert "Downloaded image is white" in str(excinfo.value)
+
+
+@pytest.mark.geopf
+def test_color_epsg_2975_detected():
+    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
+    output_path = os.path.join(TMPDIR, "color_epsg_2975_detected_sample_lareunion_epsg2975.colorized.laz")
+    # Test that clouds that are smaller in width or height to 20cm are still clorized without an error.
+    color.color(input_path, output_path)
+
+
+@pytest.mark.geopf
+def test_download_image_raise1():
+    retry_download = color.retry(times=2, delay=5, factor=2)(color.download_image_from_geoplateforme)
+    with pytest.raises(requests.exceptions.HTTPError):
+        retry_download(EPSG, "MAUVAISE_COUCHE", MINX, MINY, MAXX, MAXY, 100, 100, OUTPUT_FILE, 15, True)
+
+
+@pytest.mark.geopf
+def test_download_image_raise2():
+    retry_download = color.retry(times=2, delay=5, factor=2)(color.download_image_from_geoplateforme)
+    with pytest.raises(requests.exceptions.HTTPError):
+        retry_download("9001", LAYER, MINX, MINY, MAXX, MAXY, 100, 100, OUTPUT_FILE, 15, True)
+
+
+def test_retry_on_server_error():
+    with requests_mock.Mocker() as mock:
+        mock.get(requests_mock.ANY, status_code=502, reason="Bad Gateway")
+        with pytest.raises(requests.exceptions.HTTPError):
+            retry_download = color.retry(times=2, delay=1, factor=2)(color.download_image_from_geoplateforme)
+            retry_download(EPSG, LAYER, MINX, MINY, MAXX, MAXY, 100, 100, OUTPUT_FILE, 15, True)
+        history = mock.request_history
+        assert len(history) == 3
+
+
+def test_retry_on_connection_error():
+    with requests_mock.Mocker() as mock:
+        mock.get(requests_mock.ANY, exc=requests.exceptions.ConnectionError)
+        with pytest.raises(requests.exceptions.ConnectionError):
+            retry_download = color.retry(times=2, delay=1, factor=2)(color.download_image_from_geoplateforme)
+            retry_download(EPSG, LAYER, MINX, MINY, MAXX, MAXY, 100, 100, OUTPUT_FILE, 15, True)
+
+        history = mock.request_history
+        assert len(history) == 3
+
+
+def test_retry_param():
+    # Here you can change retry params
+    @color.retry(times=9, delay=5, factor=2, debug=True)
+    def raise_server_error():
+        raise requests.exceptions.HTTPError("Server Error")
+
+    with pytest.raises(requests.exceptions.HTTPError):
+        raise_server_error()

{ign_pdal_tools-1.7.11 → ign_pdal_tools-1.8.1}/test/test_las_remove_dimensions.py

@@ -1,8 +1,9 @@
+import logging
+import os
 import tempfile
-import pdal
+
 import numpy
-import os
-import logging
+import pdal
 import pytest
 
 from pdaltools import las_remove_dimensions
@@ -33,7 +34,6 @@ def append_dimension(input_las: str, output_las: str):
 
 
 def test_remove_all_dimension():
-
     # get initial data
     points_ini = get_points(ini_las)
 
@@ -47,7 +47,6 @@ def test_remove_all_dimension():
 
 
 def test_remove_one_dimension():
-
     # get initial data
     points_ini = get_points(ini_las)
 

ign_pdal_tools-1.7.11/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,
-    )

ign_pdal_tools-1.7.11/test/test_add_points_in_las.py

@@ -1,72 +0,0 @@
-import pytest
-import os
-import random as rand
-import tempfile
-import math
-
-import pdal
-
-import geopandas as gpd
-from shapely.geometry import Point
-
-from pdaltools import add_points_in_las
-
-numeric_precision = 4
-
-TEST_PATH = os.path.dirname(os.path.abspath(__file__))
-INPUT_DIR = os.path.join(TEST_PATH, "data")
-INPUT_LAS = os.path.join(INPUT_DIR, "test_data_77055_627760_LA93_IGN69.laz")
-
-Xmin = 770575
-Ymin = 6277575
-Zmin = 20
-Size = 20
-
-def distance3D(pt_geo, pt_las):
-    return round(
-        math.sqrt((pt_geo.x - pt_las['X']) ** 2 + (pt_geo.y - pt_las['Y']) ** 2 + (pt_geo.z - pt_las['Z']) ** 2),
-        numeric_precision,
-    )
-
-def add_point_in_las(pt_geo, inside_las):
-    geom = [pt_geo]
-    series = gpd.GeoSeries(geom, crs="2154")
-
-    with tempfile.NamedTemporaryFile(suffix="_geom_tmp.las") as out_las_file:
-        with tempfile.NamedTemporaryFile(suffix="_geom_tmp.geojson") as geom_file:
-            series.to_file(geom_file.name)
-
-            added_dimensions = {"Classification":64, "Intensity":1.}
-            add_points_in_las.add_points_in_las(INPUT_LAS, geom_file.name, out_las_file.name, inside_las, added_dimensions)
-
-            pipeline = pdal.Pipeline() | pdal.Reader.las(out_las_file.name)
-            pipeline.execute()
-            points_las = pipeline.arrays[0]
-            points_las = [e for e in points_las if all(e[val] == added_dimensions[val] for val in added_dimensions)]
-            return points_las
-
-def test_add_point_inside_las():
-    X = Xmin + rand.uniform(0, 1) * Size
-    Y = Ymin + rand.uniform(0, 1) * Size
-    Z = Zmin + rand.uniform(0, 1) * 10
-    pt_geo = Point(X, Y, Z)
-    points_las = add_point_in_las(pt_geo=pt_geo, inside_las=True)
-    assert len(points_las) == 1
-    assert distance3D(pt_geo, points_las[0]) < 1 / numeric_precision
-
-def test_add_point_outside_las_no_control():
-    X = Xmin + rand.uniform(2, 3) * Size
-    Y = Ymin + rand.uniform(0, 1) * Size
-    Z = Zmin + rand.uniform(0, 1) * 10
-    pt_geo = Point(X, Y, Z)
-    points_las = add_point_in_las(pt_geo=pt_geo, inside_las=False)
-    assert len(points_las) == 1
-    assert distance3D(pt_geo, points_las[0]) < 1 / numeric_precision
-
-def test_add_point_outside_las_with_control():
-    X = Xmin + rand.uniform(2, 3) * Size
-    Y = Ymin + rand.uniform(2, 3) * Size
-    Z = Zmin + rand.uniform(0, 1) * 10
-    pt_geo = Point(X, Y, Z)
-    points_las = add_point_in_las(pt_geo=pt_geo, inside_las=True)
-    assert len(points_las) == 0

ign_pdal_tools-1.7.11/test/test_color.py

@@ -1,148 +0,0 @@
-import os
-import shutil
-from pathlib import Path
-
-import pytest
-import requests
-import requests_mock
-
-from pdaltools import color
-
-cwd = os.getcwd()
-
-TEST_PATH = os.path.dirname(os.path.abspath(__file__))
-TMPDIR = os.path.join(TEST_PATH, "tmp")
-
-
-def setup_module(module):
-    try:
-        shutil.rmtree(TMPDIR)
-    except FileNotFoundError:
-        pass
-    os.mkdir(TMPDIR)
-
-
-INPUT_PATH = os.path.join(TEST_PATH, "data/test_noepsg_043500_629205_IGN69.laz")
-
-OUTPUT_FILE = os.path.join(TMPDIR, "Semis_2021_0435_6292_LA93_IGN69.colorized.las")
-
-
-@pytest.mark.geopf
-def test_epsg_fail():
-    with pytest.raises(
-        RuntimeError,
-        match="EPSG could not be inferred from metadata: No 'srs' key in metadata.",
-    ):
-        color.color(INPUT_PATH, OUTPUT_FILE, "", 0.1, 15)
-
-
-epsg = "2154"
-layer = "ORTHOIMAGERY.ORTHOPHOTOS"
-minx = 435000
-miny = 6291000
-maxx = 436000
-maxy = 6292000
-pixel_per_meter = 0.1
-
-
-@pytest.mark.geopf
-def test_color_and_keeping_orthoimages():
-    tmp_ortho, tmp_ortho_irc = color.color(INPUT_PATH, OUTPUT_FILE, epsg, check_images=True)
-    assert Path(tmp_ortho.name).exists()
-    assert Path(tmp_ortho_irc.name).exists()
-
-
-@pytest.mark.geopf
-def test_color_narrow_cloud():
-    input_path = os.path.join(TEST_PATH, "data/test_data_0436_6384_LA93_IGN69_single_point.laz")
-    output_path = os.path.join(TMPDIR, "test_data_0436_6384_LA93_IGN69_single_point.colorized.laz")
-    # Test that clouds that are smaller in width or height to 20cm are still clorized without an error.
-    color.color(input_path, output_path, epsg)
-
-
-@pytest.mark.geopf
-def test_download_image_ok():
-    tif_output = os.path.join(TMPDIR, "download_image.tif")
-    color.download_image_from_geoplateforme(epsg, layer, minx, miny, maxx, maxy, pixel_per_meter, tif_output, 15, True)
-
-
-@pytest.mark.geopf
-def test_color_epsg_2975_forced():
-    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
-    output_path = os.path.join(TMPDIR, "sample_lareunion_epsg2975.colorized.laz")
-    # Test that clouds that are smaller in width or height to 20cm are still clorized without an error.
-    color.color(input_path, output_path, 2975)
-
-
-def test_is_image_white_true():
-    input_path = os.path.join(TEST_PATH, "data/image/white.tif")
-    assert color.is_image_white(input_path), "This image should be detected as white"
-
-
-def test_is_image_white_false():
-    input_path = os.path.join(TEST_PATH, "data/image/colored.tif")
-    assert not color.is_image_white(input_path), "This image should NOT be detected as white"
-
-
-@pytest.mark.geopf
-def test_color_raise_for_white_image():
-    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
-    output_path = os.path.join(TMPDIR, "sample_lareunion_epsg2975.colorized.white.laz")
-
-    with pytest.raises(ValueError) as excinfo:
-        color.color(input_path, output_path, check_images=True)
-
-    assert "Downloaded image is white" in str(excinfo.value)
-
-
-@pytest.mark.geopf
-def test_color_epsg_2975_detected():
-    input_path = os.path.join(TEST_PATH, "data/sample_lareunion_epsg2975.laz")
-    output_path = os.path.join(TMPDIR, "sample_lareunion_epsg2975.colorized.laz")
-    # Test that clouds that are smaller in width or height to 20cm are still clorized without an error.
-    color.color(input_path, output_path)
-
-
-@pytest.mark.geopf
-def test_download_image_raise1():
-    retry_download = color.retry(2, 5)(color.download_image_from_geoplateforme)
-    with pytest.raises(requests.exceptions.HTTPError):
-        retry_download(epsg, "MAUVAISE_COUCHE", minx, miny, maxx, maxy, pixel_per_meter, OUTPUT_FILE, 15, True)
-
-
-@pytest.mark.geopf
-def test_download_image_raise2():
-    retry_download = color.retry(2, 5)(color.download_image_from_geoplateforme)
-    with pytest.raises(requests.exceptions.HTTPError):
-        retry_download("9001", layer, minx, miny, maxx, maxy, pixel_per_meter, OUTPUT_FILE, 15, True)
-
-
-def test_retry_on_server_error():
-    with requests_mock.Mocker() as mock:
-        mock.get(requests_mock.ANY, status_code=502, reason="Bad Gateway")
-        with pytest.raises(requests.exceptions.HTTPError):
-            retry_download = color.retry(2, 1, 2)(color.download_image_from_geoplateforme)
-            retry_download(epsg, layer, minx, miny, maxx, maxy, pixel_per_meter, OUTPUT_FILE, 15, True)
-        history = mock.request_history
-        assert len(history) == 3
-
-
-def test_retry_on_connection_error():
-    with requests_mock.Mocker() as mock:
-        mock.get(requests_mock.ANY, exc=requests.exceptions.ConnectionError)
-        with pytest.raises(requests.exceptions.ConnectionError):
-            retry_download = color.retry(2, 1)(color.download_image_from_geoplateforme)
-            retry_download(epsg, layer, minx, miny, maxx, maxy, pixel_per_meter, OUTPUT_FILE, 15, True)
-
-        history = mock.request_history
-        assert len(history) == 3
-
-
-def test_retry_param():
-    # Here you can change retry params
-    @color.retry(times=9, delay=5, factor=2, debug=True)
-    def raise_server_error():
-        raise requests.exceptions.HTTPError("Server Error")
-
-    with pytest.raises(requests.exceptions.HTTPError):
-        raise_server_error()