ign-pdal-tools 1.15.4__tar.gz → 1.15.6__tar.gz

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.15.4
+Version: 1.15.6
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.15.4
+Version: 1.15.6
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.15.4"
+__version__ = "1.15.6"
 
 
 if __name__ == "__main__":

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/add_points_in_pointcloud.py

@@ -156,7 +156,7 @@ def add_points_to_las(
     new_points.z = z_coords.astype(new_points.z.dtype)
     new_points.classification = classes.astype(new_points.classification.dtype)
 
-    with tempfile.NamedTemporaryFile(suffix="_new_points.las") as tmp:
+    with tempfile.NamedTemporaryFile(suffix="_new_points.las", delete_on_close=False) as tmp:
         with laspy.open(tmp.name, mode="w", header=header) as las_file:
             las_file.write_points(new_points)
 

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/color.py

@@ -101,7 +101,7 @@ def color(
 
     tmp_ortho = None
     if color_rvb_enabled:
-        tmp_ortho = tempfile.NamedTemporaryFile(suffix="_rvb.tif")
+        tmp_ortho = tempfile.NamedTemporaryFile(suffix="_rvb.tif", delete_on_close=False)
         download_image(
             proj,
             stream_RGB,
@@ -124,7 +124,7 @@ def color(
 
     tmp_ortho_irc = None
     if color_ir_enabled:
-        tmp_ortho_irc = tempfile.NamedTemporaryFile(suffix="_irc.tif")
+        tmp_ortho_irc = tempfile.NamedTemporaryFile(suffix="_irc.tif", delete_on_close=False)
         download_image(
             proj,
             stream_IRC,

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/create_random_laz.py

@@ -1,10 +1,11 @@
-import numpy as np
-import laspy
-from pathlib import Path
 import argparse
-from pyproj import CRS
+from pathlib import Path
 from typing import List, Tuple
 
+import laspy
+import numpy as np
+from pyproj import CRS
+
 
 def create_random_laz(
     output_file: str,
@@ -27,7 +28,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. 
+        classifications: Optional list of classification values.
     """
 
     # Create a new point cloud
@@ -103,7 +104,6 @@ def create_random_laz(
 
 
 def test_output_file(result: dict, output_file: str):
-
     # Validate output file path
     output_path = Path(output_file)
     if not output_path.exists():
@@ -126,12 +126,14 @@ def parse_args():
     )
     parser.add_argument("--crs", type=int, default=2154, help="Projection code")
     parser.add_argument(
-        "--center", type=float, nargs=2, default=[650000.0, 6810000.0],
-        help="Center coordinates (x y) of the area to generate points in (space-separated)"
+        "--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)"
+        "--classifications", type=int, nargs="+", help="List of classification values (space-separated)"
     )
     return parser.parse_args()
 
@@ -145,19 +147,13 @@ def main():
 
     # Parse center
     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,
-        classifications
+        args.output_file, args.point_format, args.num_points, args.crs, center, extra_dims, classifications
     )
 
     # Test output file

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/download_image.py

@@ -185,7 +185,7 @@ def download_image(proj, layer, minx, miny, maxx, maxy, pixel_per_meter, outfile
                 tmp_gpg_ortho.append(cells_ortho_paths)
 
         # merge the cells
-        with tempfile.NamedTemporaryFile(suffix="_gpf.vrt") as tmp_vrt:
+        with tempfile.NamedTemporaryFile(suffix="_gpf.vrt", delete_on_close=False) as tmp_vrt:
             gdal.BuildVRT(tmp_vrt.name, tmp_gpg_ortho)
             gdal.Translate(outfile, tmp_vrt.name)
 

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/las_add_buffer.py

@@ -153,7 +153,7 @@ def remove_points_from_buffer(input_file: str, output_file: str):
         input_file (str): path to the input file containing the "is_in_original" dimension
         output_file (str): path to the output_file
     """
-    with tempfile.NamedTemporaryFile(suffix="_with_additional_dim.las") as tmp_las:
+    with tempfile.NamedTemporaryFile(suffix="_with_additional_dim.las", delete_on_close=False) as tmp_las:
         pipeline = pdal.Pipeline() | pdal.Reader.las(input_file)
         pipeline |= pdal.Filter.range(limits=f"{ORIGINAL_TILE_TAG}[1:1]")
         pipeline |= pdal.Writer.las(filename=tmp_las.name, forward="all", extra_dims="all")
@@ -217,8 +217,8 @@ def run_on_buffered_las(
                 )
 
             with (
-                tempfile.NamedTemporaryFile(suffix="_buffered_input.laz", dir=".") as buf_in,
-                tempfile.NamedTemporaryFile(suffix="_buffered_output.laz", dir=".") as buf_out,
+                tempfile.NamedTemporaryFile(suffix="_buffered_input.laz", dir=".", delete_on_close=False) as buf_in,
+                tempfile.NamedTemporaryFile(suffix="_buffered_output.laz", dir=".", delete_on_close=False) as buf_out,
             ):
                 create_las_with_buffer(
                     Path(input_file).parent,

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/las_comparison.py

@@ -1,9 +1,10 @@
-import laspy
-from pathlib import Path
-import numpy as np
 import argparse
+from pathlib import Path
 from typing import Tuple
 
+import laspy
+import numpy as np
+
 
 def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) -> Tuple[bool, int, float]:
     """

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/las_rename_dimension.py

@@ -6,11 +6,13 @@ 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
+
+import pdal
+
 from pdaltools.las_info import las_info_metadata
+from pdaltools.las_remove_dimensions import remove_dimensions_from_points
 
 
 def rename_dimension(input_file: str, output_file: str, old_dims: list[str], new_dims: list[str]):

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/replace_area_in_pointcloud.py

@@ -1,12 +1,22 @@
 import argparse
+import os
+import shutil
+import tempfile
+import time
 import warnings
 
+import geopandas as gpd
 import numpy as np
 import pdal
 from numpy.lib import recfunctions as rfn
 from osgeo import gdal
+from shapely.geometry import box
 
-from pdaltools.las_info import get_writer_parameters_from_reader_metadata
+from pdaltools.las_info import (
+    get_bounds_from_header_info,
+    get_writer_parameters_from_reader_metadata,
+    las_info_metadata,
+)
 
 
 def argument_parser():
@@ -139,6 +149,18 @@ def pipeline_read_from_DSM(dsm, ground_mask, classification):
     return pipeline
 
 
+def clip_area(area_input, area_output, las_file):
+    start = time.time()
+    gdf = gpd.read_file(area_input)
+    minx, maxx, miny, maxy = get_bounds_from_header_info(las_info_metadata(las_file))
+    selection = gdf[gdf.intersects(box(minx, miny, maxx, maxy))]
+    num_polygon = len(selection)
+    selection.to_file(area_output)
+    end = time.time()
+    print(f"Create replacement area cropped: {num_polygon} polygons in {end-start:.2f} seconds")
+    return num_polygon
+
+
 def replace_area(
     target_cloud, pipeline_source, replacement_area, output_cloud, source_pdal_filter="", target_pdal_filter=""
 ):
@@ -147,6 +169,24 @@ def replace_area(
     print("output cloud: ", output_cloud)
     print("source pdal filter: ", source_pdal_filter)
     print("target pdal filter: ", target_pdal_filter)
+
+    start = time.time()
+    tmpdir = tempfile.mkdtemp()
+    replacement_name, ext = os.path.splitext(os.path.basename(replacement_area))
+    las_name, _ = os.path.splitext(os.path.basename(target_cloud))
+    replacement_area_crop = os.path.join(tmpdir, f"{replacement_name}_{las_name}{ext}")
+    print("replacement area crop: ", replacement_area_crop)
+
+    num_polygon = clip_area(replacement_area, replacement_area_crop, target_cloud)
+    if num_polygon == 0:
+        print("No polygon inside target cloud, output file is target cloud. We copy target in output.")
+
+        shutil.copy2(src=target_cloud, dst=output_cloud)
+        end = time.time()
+        print("all steps done in ", f"{end-start:.2f}", " seconds")
+        return
+
+    replacement_area = replacement_area_crop
     crops = []
     # pipeline to read target_cloud and remove points inside the polygon
     pipeline_target = pdal.Pipeline()
@@ -160,7 +200,9 @@ def replace_area(
     # Keep only points out of the area
     pipeline_target |= pdal.Filter.expression(expression="geometryFid==-1", tag="A")
     target_count = pipeline_target.execute()
-    print("Step 1: target count: ", target_count)
+
+    t1 = time.time()
+    print(f"Step 1: target count: {target_count} points in {t1-start:.2f} seconds")
 
     # get input dimensions dtype from target
     if pipeline_target.arrays:
@@ -171,7 +213,10 @@ def replace_area(
         pipeline_target2 |= pdal.Reader.las(filename=target_cloud)
         pipeline_target2.execute()
         input_dim_dtype = pipeline_target2.arrays[0].dtype
+        t1_bis = time.time()
+        print(f"Step 1-bis: re-read to have dimensions: {t1_bis-t1:.2f} seconds")
 
+    t2 = time.time()
     # get input dimensions names
     input_dimensions = list(input_dim_dtype.fields.keys())
 
@@ -179,7 +224,7 @@ def replace_area(
     output_dimensions = [dim for dim in input_dimensions if dim not in "geometryFid"]
 
     # add target to the result after keeping only the expected dimensions
-    if pipeline_target.arrays:
+    if target_count:
         target_cloud_pruned = pipeline_target.arrays[0][output_dimensions]
         crops.append(target_cloud_pruned)
 
@@ -192,7 +237,9 @@ def replace_area(
     # Keep only points in the area
     pipeline_source |= pdal.Filter.expression(expression="geometryFid>=0", tag="B")
     source_count = pipeline_source.execute()
-    print("Step 2: source count: ", source_count)
+
+    t3 = time.time()
+    print(f"Step 2: source count: {source_count} points in {t3-t2:.2f} seconds")
 
     # add source to the result
     if source_count:
@@ -221,7 +268,11 @@ def replace_area(
 
     writer_params = get_writer_params(target_cloud)
     pipeline |= pdal.Writer.las(filename=output_cloud, **writer_params)
-    pipeline.execute()
+    points = pipeline.execute()
+
+    end = time.time()
+    print(f"Step 3: merge: {points}, points in {end-t3:.2f} seconds")
+    print("all steps done in ", f"{end-start:.2f}", " seconds")
 
 
 if __name__ == "__main__":

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/standardize_format.py

@@ -9,13 +9,14 @@
 """
 
 import argparse
+import os
 import tempfile
 from typing import Dict, List
 
 import pdal
 
-from pdaltools.unlock_file import copy_and_hack_decorator
 from pdaltools.las_rename_dimension import rename_dimension
+from pdaltools.unlock_file import copy_and_hack_decorator
 
 # Standard parameters to pass to the pdal writer
 STANDARD_PARAMETERS = dict(
@@ -76,34 +77,50 @@ def get_writer_parameters(new_parameters: Dict) -> Dict:
     params = STANDARD_PARAMETERS | new_parameters
     return params
 
+
 @copy_and_hack_decorator
 def standardize(
-    input_file: str, output_file: str, params_from_parser: Dict, classes_to_remove: List = [], rename_dims: List = []
+    input_file: str, 
+    output_file: str, 
+    params_from_parser: Dict, 
+    classes_to_remove: List = [], 
+    rename_dims: List = []
 ) -> None:
+    """
+    Standardize a LAS/LAZ file with improved error handling and resource management.
+    
+    Args:
+        input_file: Input file path
+        output_file: Output file path
+        params_from_parser: Parameters for the PDAL writer
+        classes_to_remove: List of classification classes to remove
+        rename_dims: List of dimension names to rename (pairs of old_name, new_name)
+    """
     params = get_writer_parameters(params_from_parser)
-
-    # Create temporary file for dimension renaming if needed
-    if rename_dims:
-        with tempfile.NamedTemporaryFile(suffix=".laz", delete=False) as tmp_file:
-            tmp_file_name = tmp_file.name
-
-            # Rename dimensions
-            old_dims = rename_dims[::2]
-            new_dims = rename_dims[1::2]
-            rename_dimension(input_file, tmp_file_name, old_dims, new_dims)
-
-            # Use renamed file as input
-            input_file = tmp_file_name
-    else:
-        tmp_file_name = input_file
-
-    pipeline = pdal.Pipeline()
-    pipeline |= pdal.Reader.las(tmp_file_name)
-    if classes_to_remove:
-        expression = "&&".join([f"Classification != {c}" for c in classes_to_remove])
-        pipeline |= pdal.Filter.expression(expression=expression)
-    pipeline |= pdal.Writer(filename=output_file, forward="all", **params)
-    pipeline.execute()
+    tmp_file_name = None
+
+    try:
+        # Create temporary file for dimension renaming if needed
+        if rename_dims:
+            with tempfile.NamedTemporaryFile(suffix=".laz", delete=False) as tmp_file:
+                tmp_file_name = tmp_file.name
+                old_dims = rename_dims[::2]
+                new_dims = rename_dims[1::2]
+                rename_dimension(input_file, tmp_file_name, old_dims, new_dims)
+                input_file = tmp_file_name
+
+        pipeline = pdal.Pipeline()
+        pipeline |= pdal.Reader.las(input_file)
+        if classes_to_remove:
+            expression = "&&".join([f"Classification != {c}" for c in classes_to_remove])
+            pipeline |= pdal.Filter.expression(expression=expression)
+        pipeline |= pdal.Writer(filename=output_file, forward="all", **params)
+        pipeline.execute()
+
+    finally:
+        # Clean up temporary file
+        if tmp_file_name and os.path.exists(tmp_file_name):
+            os.remove(tmp_file_name)
 
 
 def main():

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/pdaltools/unlock_file.py

@@ -39,10 +39,9 @@ def copy_and_hack_decorator(func):
             if "readers.las: Global encoding WKT flag not set for point format 6 - 10." in str(e):
                 args = list(args)
                 in_file = args[0]
-                with tempfile.NamedTemporaryFile(suffix=os.path.splitext(in_file)[-1]) as tmp:
+                with tempfile.NamedTemporaryFile(suffix=os.path.splitext(in_file)[-1], delete_on_close=False) as tmp:
                     copy_and_hack_input_file(in_file, tmp.name)
                     args[0] = tmp.name
-
                     return func(*args, **kwargs)
 
             else:

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_add_points_in_pointcloud.py

@@ -1,10 +1,12 @@
 import inspect
 import os
+import tempfile
 from pathlib import Path
 
 import geopandas as gpd
 import laspy
 import numpy as np
+import pdal
 import pytest
 from shapely.geometry import LineString, MultiPoint, Point
 
@@ -424,3 +426,49 @@ def test_parse_args():
     parsed_args_keys = args.__dict__.keys()
     main_parameters = inspect.signature(add_points_in_pointcloud.add_points_from_geometry_to_las).parameters.keys()
     assert set(parsed_args_keys) == set(main_parameters)
+
+
+def test_namedtemporaryfile_delete_on_close_false():
+    """Test that NamedTemporaryFile could be used on windows in the context with delete_on_close=False"""
+    temp_file_path = None
+
+    with tempfile.NamedTemporaryFile(suffix="_test.las", delete_on_close=False) as tmp:
+        temp_file_path = tmp.name
+        # Verify that the file exists during the context
+        assert os.path.exists(temp_file_path)
+
+        # Write some data to the temporary file
+        with open(temp_file_path, "w") as f:
+            f.write("test data")
+        f.close()
+
+    # Verify that the file still exists after exiting the context
+    assert not os.path.exists(
+        temp_file_path
+    ), f"Temporary file {temp_file_path} should not exist oustside the context with delete_on_close=False"
+
+
+def test_namedtemporaryfile_delete_false_with_pdal():
+    """Test that NamedTemporaryFile could be used on windows in the context
+    with delete_on_close=False and some pdal operations"""
+
+    def read_las(input_las, tmp):
+        pipeline = pdal.Pipeline()
+        pipeline |= pdal.Reader.las(filename=input_las)
+        pipeline |= pdal.Writer.las(filename=tmp.name, forward="all", extra_dims="all")
+        pipeline.execute()
+
+    input_las = os.path.join(TEST_PATH, "data/crop_duplicate.laz")
+    temp_file_path = None
+    with tempfile.NamedTemporaryFile(suffix="_test.las", delete_on_close=False) as tmp:
+        temp_file_path = tmp.name
+        read_las(input_las, tmp)
+        pipeline = pdal.Pipeline()
+        pipeline |= pdal.Reader.las(filename=tmp.name)
+        pipeline.execute()
+        assert os.path.exists(tmp.name)
+
+    # Verify that the file still exists after exiting the context
+    assert not os.path.exists(
+        temp_file_path
+    ), f"Temporary file {temp_file_path} should not exist oustside the context with delete_on_close=False"

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_create_random_laz.py

@@ -1,9 +1,10 @@
 import os
-import pytest
-import numpy as np
-import laspy
 import sys
 
+import laspy
+import numpy as np
+import pytest
+
 from pdaltools.create_random_laz import create_random_laz, main
 
 TEST_PATH = os.path.dirname(os.path.abspath(__file__))
@@ -138,13 +139,14 @@ def test_create_random_laz_data_ranges():
         assert np.all(las.uint_dim >= 0)
         assert np.all(las.uint_dim <= 100)
 
+
 @pytest.mark.parametrize(
     "classifications",
     [
         [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
         [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-        [1, 2, 3, 66, 68]
-    ]
+        [1, 2, 3, 66, 68],
+    ],
 )
 def test_create_random_laz_classifications(classifications):
     """Test that generated data is within expected ranges for different types"""
@@ -158,18 +160,18 @@ def test_create_random_laz_classifications(classifications):
 
     with laspy.open(output_file) as las_file:
         las = las_file.read()
-        
+
         # Convert to set for faster lookups
         valid_classifications = set(classifications)
-        
+
         # Check that all classification values are in the provided list
         unique_classes = set(np.unique(las.classification))
-        assert unique_classes.issubset(valid_classifications), \
-            f"Found unexpected classification values: {unique_classes - valid_classifications}"
-            
+        assert unique_classes.issubset(
+            valid_classifications
+        ), f"Found unexpected classification values: {unique_classes - valid_classifications}"
+
         # Also check that we have the expected number of points
-        assert len(las.classification) == 1000, \
-            f"Expected 1000 points, got {len(las.classification)}"
+        assert len(las.classification) == 1000, f"Expected 1000 points, got {len(las.classification)}"
 
 
 def test_main():
@@ -191,11 +193,21 @@ def test_main():
             "--crs",
             "2154",
             "--center",
-            "650000", "6810000",
+            "650000",
+            "6810000",
             "--extra_dims",
             "height:float32",
             "--classifications",
-            "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9",
+            "10",
         ]
 
         # Run main function
@@ -209,12 +221,13 @@ def test_main():
             las = las_file.read()
             assert len(las.points) == 50
             assert "height" in las.point_format.dimension_names
-            
+
             # Verify classifications are within the provided range
             unique_classes = set(np.unique(las.classification))
             expected_classes = set(range(1, 11))  # 1-10
-            assert unique_classes.issubset(expected_classes), \
-                f"Found unexpected classification values: {unique_classes - expected_classes}"
+            assert unique_classes.issubset(
+                expected_classes
+            ), f"Found unexpected classification values: {unique_classes - expected_classes}"
 
     finally:
         # Restore original sys.argv

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_las_comparison.py

@@ -1,10 +1,12 @@
-import pytest
 import tempfile
-import numpy as np
 from pathlib import Path
+from typing import Tuple
+
 import laspy
+import numpy as np
+import pytest
+
 from pdaltools.las_comparison import compare_las_dimensions, main
-from typing import Tuple
 
 
 def create_test_las_file(x: np.ndarray, y: np.ndarray, z: np.ndarray, dimensions: dict = None) -> Path:
@@ -236,8 +238,8 @@ def test_single_point():
 def test_main_function():
     """Test the main function with direct sys.argv"""
     import sys
-    from io import StringIO
     from contextlib import redirect_stdout
+    from io import StringIO
 
     # Test with identical files
     points = 100

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_las_remove_dimensions.py

@@ -37,9 +37,9 @@ def test_remove_all_dimension():
     # get initial data
     points_ini = get_points(ini_las)
 
-    with tempfile.NamedTemporaryFile(suffix="_add.las") as tmp_las:
+    with tempfile.NamedTemporaryFile(suffix="_add.las", delete_on_close=False) as tmp_las:
         append_dimension(ini_las, tmp_las.name)
-        with tempfile.NamedTemporaryFile(suffix="_rm.las") as tmp_las_rm:
+        with tempfile.NamedTemporaryFile(suffix="_rm.las", delete_on_close=False) as tmp_las_rm:
             # remove all dimensions
             las_remove_dimensions.remove_dimensions_from_las(tmp_las.name, added_dimensions, tmp_las_rm.name)
             points_end = get_points(tmp_las_rm.name)
@@ -50,9 +50,9 @@ def test_remove_one_dimension():
     # get initial data
     points_ini = get_points(ini_las)
 
-    with tempfile.NamedTemporaryFile(suffix="_add.las") as tmp_las:
+    with tempfile.NamedTemporaryFile(suffix="_add.las", delete_on_close=False) as tmp_las:
         append_dimension(ini_las, tmp_las.name)
-        with tempfile.NamedTemporaryFile(suffix="_rm.las") as tmp_las_rm:
+        with tempfile.NamedTemporaryFile(suffix="_rm.las", delete_on_close=False) as tmp_las_rm:
             # remove one dimension
             las_remove_dimensions.remove_dimensions_from_las(tmp_las.name, ["DIM_1"], tmp_las_rm.name)
             points_end = get_points(tmp_las_rm.name)

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_las_rename_dimension.py

@@ -1,13 +1,15 @@
+import logging
 import os
-import pytest
+import sys
 import tempfile
-import numpy as np
+
 import laspy
-import sys
-import logging
-from pdaltools.las_rename_dimension import rename_dimension, main
+import numpy as np
+import pytest
 from pyproj import CRS
 
+from pdaltools.las_rename_dimension import main, rename_dimension
+
 
 def create_test_las_file():
     """Create a temporary LAS file with test data."""
@@ -72,24 +74,24 @@ def test_rename_dimension():
 def test_rename_nonexistent_dimension(caplog):
     """Test attempting to rename a dimension that doesn't exist."""
     input_file = create_test_las_file()
-    
+
     with tempfile.NamedTemporaryFile(suffix=".las", delete=False) as tmp_file:
         output_file = tmp_file.name
-    
-        try:
-            # Clear any existing log records
-            caplog.clear()
-        
-            # Set the logging level to capture WARNING
-            with caplog.at_level(logging.WARNING):
-                rename_dimension(input_file, output_file, ["nonexistent_dim"], ["new_dim"])
-                
-                # Check that the warning was logged
-                assert len(caplog.records) == 1
-                assert "Dimension nonexistent_dim not found in input file" in caplog.records[0].message
-        finally:
-            os.unlink(input_file)
-            os.unlink(output_file)
+
+    try:
+         # Clear any existing log records
+        caplog.clear()
+
+        # Set the logging level to capture WARNING
+        with caplog.at_level(logging.WARNING):
+            rename_dimension(input_file, output_file, ["nonexistent_dim"], ["new_dim"])
+
+            # Check that the warning was logged
+            assert len(caplog.records) == 1
+            assert "Dimension nonexistent_dim not found in input file" in caplog.records[0].message
+    finally:
+        os.unlink(input_file)
+        os.unlink(output_file)
 
 
 def test_rename_to_existing_dimension():
@@ -113,22 +115,21 @@ def test_rename_dimension_case_sensitive(caplog):
 
     with tempfile.NamedTemporaryFile(suffix=".las", delete=False) as tmp_file:
         output_file = tmp_file.name
-    
-        try:
-            # Clear any existing log records
-            caplog.clear()
-        
-            # Set the logging level to capture WARNING
-            with caplog.at_level(logging.WARNING):
-                rename_dimension(input_file, output_file, ["TEST_DIM"], ["new_dim"])
-                
-                # Check that the warning was logged
-                assert len(caplog.records) == 1
-                assert "Dimension TEST_DIM not found in input file" in caplog.records[0].message
-        finally:
-            os.unlink(input_file)
-            os.unlink(output_file)
 
+    try:
+        # Clear any existing log records
+        caplog.clear()
+
+        # Set the logging level to capture WARNING
+        with caplog.at_level(logging.WARNING):
+            rename_dimension(input_file, output_file, ["TEST_DIM"], ["new_dim"])
+
+            # Check that the warning was logged
+            assert len(caplog.records) == 1
+            assert "Dimension TEST_DIM not found in input file" in caplog.records[0].message
+    finally:
+        os.unlink(input_file)
+        os.unlink(output_file)
 
 
 def test_rename_dimension_main():

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_pdal.py

@@ -1,15 +1,15 @@
 import os
 
 import pdal
-import pytest
 
 TEST_PATH = os.path.dirname(os.path.abspath(__file__))
 
-#this test files concatenate somes tests on PDAL features
-#it allows us to test the PDAL version used in the library is modern enough
+# this test files concatenate somes tests on PDAL features
+# it allows us to test the PDAL version used in the library is modern enough
+
 
 def test_pdal_read_severals_extra_dims():
-# test that we can read a las file with several extra dims
+    # test that we can read a las file with several extra dims
     test_file = os.path.join(TEST_PATH, "data/las_with_several_extra_byte_bloc.laz")
 
     pipeline = pdal.Reader.las(filename=test_file).pipeline()

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_replace_area_in_pointcloud.py

@@ -325,7 +325,7 @@ def test_main_from_cloud_with_filter():
     assert get_nb_points(output_file) == 6390
 
 
-def test_main_from_DSM():
+def test_main_from_DSM_light():
     output_file = os.path.join(TMP_PATH, "main_from_DSM", "output_main_from_DSM.laz")
     os.makedirs(os.path.dirname(output_file))
     cmd = (
@@ -338,3 +338,21 @@ def test_main_from_DSM():
     # same result as test_from_DMS
     counts = compute_count_one_file(output_file, "Classification")
     assert counts == {"1": 3841, "2": 2355, str(SOURCE_CLASSIF): 45}
+
+
+def test_main_from_DSM_light_replace_all():
+    output_file = os.path.join(TMP_PATH, "main_from_DSM_replace_around", "output_main_from_DSM.laz")
+    os.makedirs(os.path.dirname(output_file))
+
+    # use replacement area bigger than the tile
+    REPLACE_AREA_2 = os.path.join(INPUT_DIR, "replace_area_2.geojson")
+    cmd = (
+        f"from_DSM -d {SOURCE_DSM} -g {SOURCE_GROUND_MASK} -c {SOURCE_CLASSIF} -t {TARGET_CLOUD} -r {REPLACE_AREA_2}"
+        f" -o {output_file}"
+    ).split()
+    args = argument_parser().parse_args(cmd)
+    args.func(args)
+
+    # only have points from source
+    counts = compute_count_one_file(output_file, "Classification")
+    assert counts == {str(SOURCE_CLASSIF): 81}

{ign_pdal_tools-1.15.4 → ign_pdal_tools-1.15.6}/test/test_standardize_format.py

@@ -3,17 +3,18 @@ import os
 import platform
 import shutil
 import subprocess as sp
+import sys
 from test.utils import EXPECTED_DIMS_BY_DATAFORMAT, get_pdal_infos_summary
+
 import laspy
 import pdal
 import pytest
-import sys
 
 from pdaltools.count_occurences.count_occurences_for_attribute import (
     compute_count_one_file,
 )
-from pdaltools.standardize_format import standardize, main
 from pdaltools.las_comparison import compare_las_dimensions
+from pdaltools.standardize_format import main, standardize
 
 TEST_PATH = os.path.dirname(os.path.abspath(__file__))
 TMP_PATH = os.path.join(TEST_PATH, "tmp")
@@ -277,7 +278,7 @@ def test_standardize_with_extra_dims_origin_and_dxm_marker():
 
     # check output file is same as input file for origin and dxm_marker
     result, _, _ = compare_las_dimensions(input_file, output_file, ["origin", "dsm_marker", "dtm_marker"])
-    assert result == True
+    assert result is True
 
 
 def test_main_with_rename_dimensions():