ign-pdal-tools 1.7.3__tar.gz → 1.7.5__tar.gz

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ign-pdal-tools
-Version: 1.7.3
+Version: 1.7.5
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown
@@ -87,6 +87,11 @@ 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.
+
+
 # Dev / Build
 
 ## Contribute

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/README.md

@@ -79,6 +79,11 @@ 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.
+
+
 # Dev / Build
 
 ## Contribute

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ign-pdal-tools
-Version: 1.7.3
+Version: 1.7.5
 Summary: Library for common LAS files manipulation with PDAL
 Author-email: Guillaume Liegard <guillaume.liegard@ign.fr>
 Description-Content-Type: text/markdown
@@ -87,6 +87,11 @@ 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.
+
+
 # Dev / Build
 
 ## Contribute

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/ign_pdal_tools.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ 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/color.py
 pdaltools/las_add_buffer.py
 pdaltools/las_clip.py
@@ -16,6 +17,7 @@ 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_color.py
 test/test_las_add_buffer.py
 test/test_las_clip.py

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.3"
+__version__ = "1.7.5"
 
 
 if __name__ == "__main__":

ign_pdal_tools-1.7.5/pdaltools/add_points_in_las.py

@@ -0,0 +1,104 @@
+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.3 → ign_pdal_tools-1.7.5}/pdaltools/color.py

@@ -69,11 +69,11 @@ def is_image_white(filename: str):
 def download_image_from_geoplateforme(
     proj, layer, minx, miny, maxx, maxy, pixel_per_meter, outfile, timeout, check_images
 ):
-    # Give single-point clouds a width/height of at least one pixel to have valid BBOX and SIZE
-    if minx == maxx:
-        maxx = minx + 1 / pixel_per_meter
-    if miny == maxy:
-        maxy = miny + 1 / pixel_per_meter
+    # 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
 
     # for layer in layers:
     URL_GPP = "https://data.geopf.fr/wms-r/wms?"
@@ -136,22 +136,26 @@ def color(
 
     tmp_ortho = None
     if color_rvb_enabled:
-        tmp_ortho = tempfile.NamedTemporaryFile()
+        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
         )
-
+        # Warning: the initial color is multiplied by 256 despite its initial 8-bits encoding
+        # which turns it to a 0 to 255*256 range.
+        # It is kept this way because of other dependencies that have been tuned to fit this range
         pipeline |= pdal.Filter.colorization(
             raster=tmp_ortho.name, dimensions="Red:1:256.0, Green:2:256.0, Blue:3:256.0"
         )
 
     tmp_ortho_irc = None
     if color_ir_enabled:
-        tmp_ortho_irc = tempfile.NamedTemporaryFile()
+        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
         )
-
+        # Warning: the initial color is multiplied by 256 despite its initial 8-bits encoding
+        # which turns it to a 0 to 255*256 range.
+        # It is kept this way because of other dependencies that have been tuned to fit this range
         pipeline |= pdal.Filter.colorization(raster=tmp_ortho_irc.name, dimensions="Infrared:1:256.0")
 
     pipeline |= pdal.Writer.las(

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/pdaltools/las_info.py

@@ -6,6 +6,8 @@ from typing import Dict, Tuple
 import osgeo.osr as osr
 import pdal
 
+from pdaltools.pcd_info import infer_tile_origin
+
 osr.UseExceptions()
 
 
@@ -17,13 +19,37 @@ def las_info_metadata(filename: str):
     return metadata
 
 
-def get_bounds_from_header_info(metadata):
+def get_bounds_from_header_info(metadata: Dict) -> Tuple[float, float, float, float]:
+    """Get bounds from metadata that has been extracted previously from the header of a las file
+
+    Args:
+        metadata (str): Dictonary containing metadata from a las file (as extracted with pipeline.quickinfo)
+
+    Returns:
+        Tuple[float, float, float, float]: minx, maxx, miny, maxy
+    """
     bounds = metadata["bounds"]
     minx, maxx, miny, maxy = bounds["minx"], bounds["maxx"], bounds["miny"], bounds["maxy"]
 
     return minx, maxx, miny, maxy
 
 
+def get_tile_origin_using_header_info(filename: str, tile_width: int = 1000) -> Tuple[int, int]:
+    """ "Get las file theoretical origin (xmin, ymax) for a data that originates from a square tesselation/tiling
+    using the tesselation tile width only, directly from its path
+    Args:
+        filename (str): path to the las file
+        tile_width (int, optional): Tesselation tile width (in meters). Defaults to 1000.
+
+    Returns:
+        Tuple[int, int]: (origin_x, origin_y) tile origin coordinates = theoretical (xmin, ymax)
+    """
+    metadata = las_info_metadata(filename)
+    minx, maxx, miny, maxy = get_bounds_from_header_info(metadata)
+
+    return infer_tile_origin(minx, maxx, miny, maxy, tile_width)
+
+
 def get_epsg_from_header_info(metadata):
     if "srs" not in metadata.keys():
         raise RuntimeError("EPSG could not be inferred from metadata: No 'srs' key in metadata.")

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/pdaltools/las_remove_dimensions.py

@@ -1,9 +1,9 @@
 import argparse
-import os
 
 import pdal
 from pdaltools.las_info import get_writer_parameters_from_reader_metadata
 
+
 def remove_dimensions_from_las(input_las: str, dimensions: [str], output_las: str):
     """
     export new las without some dimensions
@@ -43,7 +43,7 @@ def parse_args():
         required=True,
         nargs="+",
         help="The dimension we would like to remove from the point cloud file ; be aware to not remove mandatory "
-             "dimensions of las"
+        "dimensions of las",
     )
 
     return parser.parse_args()

ign_pdal_tools-1.7.5/pdaltools/pcd_info.py

@@ -0,0 +1,76 @@
+"""Tools to get information from a point cloud (points as a numpy array)"""
+
+from typing import Tuple
+
+import numpy as np
+
+
+def infer_tile_origin(minx: float, maxx: float, miny: float, maxy: float, tile_width: int) -> Tuple[int, int]:
+    """Get point cloud theoretical origin (xmin, ymax) for a data that originates from a square tesselation/tiling
+    using the tesselation tile width only, based on the min/max values
+
+    Edge values are supposed to be included in the tile
+
+    Args:
+        minx (float): point cloud min x value
+        maxx (float): point cloud max x value
+        miny (float): point cloud min y value
+        maxy (float): point cloud max y value
+        tile_width (int): tile width in meters
+
+    Raises:
+        ValueError: In case the min and max values do not belong to the same tile
+
+    Returns:
+        Tuple[int, int]: (origin_x, origin_y) tile origin coordinates = theoretical (xmin, ymax)
+    """
+
+    minx_tile_index = np.floor(minx / tile_width)
+    maxx_tile_index = np.floor(maxx / tile_width) if maxx % tile_width != 0 else np.floor(maxx / tile_width) - 1
+    miny_tile_index = np.ceil(miny / tile_width) if miny % tile_width != 0 else np.floor(miny / tile_width) + 1
+    maxy_tile_index = np.ceil(maxy / tile_width)
+
+    if maxx_tile_index == minx_tile_index and maxy_tile_index == miny_tile_index:
+        origin_x = minx_tile_index * tile_width
+        origin_y = maxy_tile_index * tile_width
+        return origin_x, origin_y
+    else:
+        raise ValueError(
+            f"Min values (x={minx} and y={miny}) do not belong to the same theoretical tile as"
+            f"max values (x={maxx} and y={maxy})."
+        )
+
+
+def get_pointcloud_origin_from_tile_width(
+    points: np.ndarray, tile_width: int = 1000, buffer_size: float = 0
+) -> Tuple[int, int]:
+    """Get point cloud theoretical origin (xmin, ymax) for a data that originates from a square tesselation/tiling
+    using the tesselation tile width only, based on the point cloud as a np.ndarray
+
+    Edge values are supposed to be included in the tile
+
+    In case buffer_size is provided, the origin will be calculated on an "original" tile, supposing that
+    there has been a buffer added to the input tile.
+
+    Args:
+        points (np.ndarray): numpy array with the tile points
+        tile_width (int, optional): Edge size of the square used for tiling. Defaults to 1000.
+        buffer_size (float, optional): Optional buffer around the tile. Defaults to 0.
+
+    Raises:
+        ValueError: Raise an error when the initial tile is smaller than the buffer (in this case, we cannot find the
+        origin (it can be either in the buffer or in the tile))
+
+    Returns:
+        Tuple[int, int]: (origin_x, origin_y) origin coordinates
+    """
+    # Extract coordinates xmin, xmax, ymin and ymax of the original tile without buffer
+    minx, miny = np.min(points[:, :2], axis=0) + buffer_size
+    maxx, maxy = np.max(points[:, :2], axis=0) - buffer_size
+
+    if maxx < minx or maxy < miny:
+        raise ValueError(
+            "Cannot find pointcloud origin as the pointcloud width or height is smaller than buffer width"
+        )
+
+    return infer_tile_origin(minx, maxx, miny, maxy, tile_width)

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/pdaltools/standardize_format.py

@@ -10,14 +10,16 @@
 
 import argparse
 import os
+import platform
 import subprocess as sp
 import tempfile
-from typing import Dict
+from typing import Dict, List
 
 import pdal
 
 from pdaltools.unlock_file import copy_and_hack_decorator
 
+# Standard parameters to pass to the pdal writer
 STANDARD_PARAMETERS = dict(
     major_version="1",
     minor_version="4",  # Laz format version (pdal always write in 1.x format)
@@ -43,6 +45,13 @@ def parse_args():
         "--record_format", choices=[6, 8], type=int, help="Record format: 6 (no color) or 8 (4 color channels)"
     )
     parser.add_argument("--projection", default="EPSG:2154", type=str, help="Projection, eg. EPSG:2154")
+    parser.add_argument(
+        "--class_points_removed",
+        default=[],
+        nargs="*",
+        type=str,
+        help="List of classes number. Points of this classes will be removed from the file",
+    )
     parser.add_argument(
         "--extra_dims",
         default=[],
@@ -51,7 +60,6 @@ def parse_args():
         help="List of extra dims to keep in the output (default=[], use 'all' to keep all extra dims), "
         "extra_dims must be specified with their type (see pdal.writers.las documentation, eg 'dim1=double')",
     )
-
     return parser.parse_args()
 
 
@@ -61,20 +69,28 @@ def get_writer_parameters(new_parameters: Dict) -> Dict:
     override the standard ones
     """
     params = STANDARD_PARAMETERS | new_parameters
-
     return params
 
 
-def rewrite_with_pdal(input_file: str, output_file: str, params_from_parser: Dict) -> None:
-    # Update parameters with command line values
+def rewrite_with_pdal(
+    input_file: str, output_file: str, params_from_parser: Dict, classes_to_remove: List = []
+) -> None:
     params = get_writer_parameters(params_from_parser)
-    pipeline = pdal.Reader.las(input_file)
+    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()
 
 
 def exec_las2las(input_file: str, output_file: str):
-    r = sp.run(["las2las", "-i", input_file, "-o", output_file], stderr=sp.PIPE, stdout=sp.PIPE)
+    if platform.processor() == "arm" and platform.architecture()[0] == "64bit":
+        las2las = "las2las64"
+    else:
+        las2las = "las2las"
+    r = sp.run([las2las, "-i", input_file, "-o", output_file], stderr=sp.PIPE, stdout=sp.PIPE)
     if r.returncode == 1:
         msg = r.stderr.decode()
         print(msg)
@@ -86,14 +102,18 @@ def exec_las2las(input_file: str, output_file: str):
 
 
 @copy_and_hack_decorator
-def standardize(input_file: str, output_file: str, params_from_parser: Dict) -> None:
+def standardize(input_file: str, output_file: str, params_from_parser: Dict, class_points_removed: []) -> None:
     filename = os.path.basename(output_file)
     with tempfile.NamedTemporaryFile(suffix=filename) as tmp:
-        rewrite_with_pdal(input_file, tmp.name, params_from_parser)
+        rewrite_with_pdal(input_file, tmp.name, params_from_parser, class_points_removed)
         exec_las2las(tmp.name, output_file)
 
 
 if __name__ == "__main__":
     args = parse_args()
-    params_from_parser = dict(dataformat_id=args.record_format, a_srs=args.projection, extra_dims=args.extra_dims)
-    standardize(args.input_file, args.output_file, params_from_parser)
+    params_from_parser = dict(
+        dataformat_id=args.record_format,
+        a_srs=args.projection,
+        extra_dims=args.extra_dims,
+    )
+    standardize(args.input_file, args.output_file, params_from_parser, args.class_points_removed)

ign_pdal_tools-1.7.5/test/test_add_points_in_las.py

@@ -0,0 +1,72 @@
+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.3 → ign_pdal_tools-1.7.5}/test/test_las_info.py

@@ -40,6 +40,11 @@ def test_get_bounds_from_quickinfo_metadata():
     assert bounds == (INPUT_MINS[0], INPUT_MAXS[0], INPUT_MINS[1], INPUT_MAXS[1])
 
 
+def test_get_tile_origin_using_header_info():
+    origin_x, origin_y = las_info.get_tile_origin_using_header_info(INPUT_FILE, tile_width=TILE_WIDTH)
+    assert (origin_x, origin_y) == (COORD_X * TILE_COORD_SCALE, COORD_Y * TILE_COORD_SCALE)
+
+
 def test_get_epsg_from_quickinfo_metadata_ok():
     metadata = las_info.las_info_metadata(INPUT_FILE)
     assert las_info.get_epsg_from_header_info(metadata) == "2154"

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/test/test_las_remove_dimensions.py

@@ -13,16 +13,22 @@ INPUT_DIR = os.path.join(TEST_PATH, "data")
 ini_las = os.path.join(INPUT_DIR, "test_data_77055_627760_LA93_IGN69.laz")
 added_dimensions = ["DIM_1", "DIM_2"]
 
-def get_points(input_las : str):
+
+def get_points(input_las: str):
     pipeline_read_ini = pdal.Pipeline() | pdal.Reader.las(input_las)
     pipeline_read_ini.execute()
     return pipeline_read_ini.arrays[0]
 
-def append_dimension(input_las : str, output_las : str):
+
+def append_dimension(input_las: str, output_las: str):
     pipeline = pdal.Pipeline()
     pipeline |= pdal.Reader.las(input_las)
     pipeline |= pdal.Filter.ferry(dimensions="=>" + ", =>".join(added_dimensions))
-    pipeline |= pdal.Writer.las(output_las, extra_dims="all", forward="all", )
+    pipeline |= pdal.Writer.las(
+        output_las,
+        extra_dims="all",
+        forward="all",
+    )
     pipeline.execute()
 
 
@@ -52,10 +58,9 @@ def test_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)
 
-            assert list(points_end.dtype.fields.keys()).index("DIM_2") >= 0# should still contains DIM_2
+            assert list(points_end.dtype.fields.keys()).index("DIM_2") >= 0  # should still contains DIM_2
 
-            with pytest.raises(ValueError):
-                list(points_end.dtype.fields.keys()).index("DIM_1") # should not have DIM_1
+            assert "DIM_1" not in points_end.dtype.fields.keys(), "LAS should not have dimension DIM_1"
 
             with pytest.raises(TypeError):
                 numpy.array_equal(points_ini, points_end)  # output data should not be the same

ign_pdal_tools-1.7.5/test/test_pcd_info.py

@@ -0,0 +1,87 @@
+import os
+
+import laspy
+import numpy as np
+import pytest
+
+from pdaltools import pcd_info
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+TMP_PATH = os.path.join(TEST_PATH, "tmp")
+DATA_PATH = os.path.join(TEST_PATH, "data")
+
+
+@pytest.mark.parametrize(
+    "minx, maxx, miny, maxy, expected_origin",
+    [
+        (501, 999, 501, 999, (0, 1000)),  # points in the second half
+        (1, 400, 1, 400, (0, 1000)),  # points in the first half
+        (500, 1000, 500, 500, (0, 1000)),  # xmax on edge and xmin in the tile
+        (0, 20, 500, 500, (0, 1000)),  # xmin on edge and xmax in the tile
+        (950, 1000, 500, 500, (0, 1000)),  # xmax on edge and xmin in the tile
+        (500, 500, 980, 1000, (0, 1000)),  # ymax on edge and ymin in the tile
+        (500, 500, 0, 20, (0, 1000)),  # ymin on edge and ymax in the tile
+        (0, 1000, 0, 1000, (0, 1000)),  # points at each corner
+    ],
+)
+def test_infer_tile_origin_edge_cases(minx, maxx, miny, maxy, expected_origin):
+    origin_x, origin_y = pcd_info.infer_tile_origin(minx, maxx, miny, maxy, tile_width=1000)
+    assert (origin_x, origin_y) == expected_origin
+
+
+@pytest.mark.parametrize(
+    "minx, maxx, miny, maxy",
+    [
+        (0, 20, -1, 20),  # ymin slightly outside the tile
+        (-1, 20, 0, 20),  # xmin slightly outside the tile
+        (280, 1000, 980, 1001),  # ymax slightly outside the tile
+        (980, 1001, 980, 1000),  # xmax slightly outside the tile
+        (-1, 1000, 0, 1000),  # xmax on edge but xmin outside the tile
+        (0, 1000, 0, 1001),  # ymin on edge but ymax outside the tile
+        (0, 1001, 0, 1000),  # xmin on edge but xmax outside the tile
+        (0, 1000, -1, 1000),  # ymax on edge but ymin outside the tile
+    ],
+)
+def test_infer_tile_origin_edge_cases_fail(minx, maxx, miny, maxy):
+    with pytest.raises(ValueError):
+        pcd_info.infer_tile_origin(minx, maxx, miny, maxy, tile_width=1000)
+
+
+@pytest.mark.parametrize(
+    "input_points",
+    [
+        (np.array([[0, -1, 0], [20, 20, 0]])),  # ymin slightly outside the tile
+        (np.array([[-1, 0, 0], [20, 20, 0]])),  # xmin slightly outside the tile
+        (np.array([[980, 980, 0], [1000, 1001, 0]])),  # ymax slightly outside the tile
+        (np.array([[980, 980, 0], [1001, 1000, 0]])),  # xmax slightly outside the tile
+        (np.array([[-1, 0, 0], [1000, 1000, 0]])),  # xmax on edge but xmin outside the tile
+        (np.array([[0, 0, 0], [1000, 1001, 0]])),  # ymin on edge but ymax outside the tile
+        (np.array([[0, 0, 0], [1001, 1000, 0]])),  # xmin on edge but xmax outside the tile
+        (np.array([[0, -1, 0], [1000, 1000, 0]])),  # ymax on edge but ymin outside the tile
+    ],
+)
+def test_get_pointcloud_origin_edge_cases_fail(input_points):
+    with pytest.raises(ValueError):
+        pcd_info.get_pointcloud_origin_from_tile_width(points=input_points, tile_width=1000)
+
+
+def test_get_pointcloud_origin_on_file():
+    input_las = os.path.join(DATA_PATH, "test_data_77055_627760_LA93_IGN69.laz")
+    expected_origin = (770550, 6277600)
+    LAS = laspy.read(input_las)
+    INPUT_POINTS = np.vstack((LAS.x, LAS.y, LAS.z)).transpose()
+
+    origin_x, origin_y = pcd_info.get_pointcloud_origin_from_tile_width(points=INPUT_POINTS, tile_width=50)
+    assert (origin_x, origin_y) == expected_origin
+    origin_x_2, origin_y_2 = pcd_info.get_pointcloud_origin_from_tile_width(
+        points=INPUT_POINTS, tile_width=10, buffer_size=20
+    )
+    assert (origin_x_2, origin_y_2) == (expected_origin[0] + 20, expected_origin[1] - 20)
+
+
+def test_get_pointcloud_origin_fail_on_buffersize():
+    with pytest.raises(ValueError):
+        # Case when buffer size is bigger than the tile extremities (case not handled)
+        points = np.array([[0, 0, 0], [20, 20, 0]])
+        buffer_size = 30
+        pcd_info.get_pointcloud_origin_from_tile_width(points=points, tile_width=1000, buffer_size=buffer_size)

{ign_pdal_tools-1.7.3 → ign_pdal_tools-1.7.5}/test/test_standardize_format.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import platform
 import shutil
 import subprocess as sp
 from test.utils import EXPECTED_DIMS_BY_DATAFORMAT, get_pdal_infos_summary
@@ -7,14 +8,19 @@ from test.utils import EXPECTED_DIMS_BY_DATAFORMAT, get_pdal_infos_summary
 import pdal
 import pytest
 
+from pdaltools.count_occurences.count_occurences_for_attribute import (
+    compute_count_one_file,
+)
 from pdaltools.standardize_format import exec_las2las, rewrite_with_pdal, standardize
 
 TEST_PATH = os.path.dirname(os.path.abspath(__file__))
 TMP_PATH = os.path.join(TEST_PATH, "tmp")
 INPUT_DIR = os.path.join(TEST_PATH, "data")
 
+DEFAULT_PARAMS = {"dataformat_id": 6, "a_srs": "EPSG:2154", "extra_dims": []}
+
 MUTLIPLE_PARAMS = [
-    {"dataformat_id": 6, "a_srs": "EPSG:2154", "extra_dims": []},
+    DEFAULT_PARAMS,
     {"dataformat_id": 8, "a_srs": "EPSG:4326", "extra_dims": []},
     {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": ["dtm_marker=double", "dsm_marker=double"]},
     {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": "all"},
@@ -30,8 +36,19 @@ def setup_module(module):
     os.mkdir(TMP_PATH)
 
 
-def _test_standardize_format_one_params_set(input_file, output_file, params):
-    rewrite_with_pdal(input_file, output_file, params)
+@pytest.mark.parametrize(
+    "params",
+    [
+        DEFAULT_PARAMS,
+        {"dataformat_id": 8, "a_srs": "EPSG:4326", "extra_dims": []},
+        {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": ["dtm_marker=double", "dsm_marker=double"]},
+        {"dataformat_id": 8, "a_srs": "EPSG:2154", "extra_dims": "all"},
+    ],
+)
+def test_standardize_format(params):
+    input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
+    output_file = os.path.join(TMP_PATH, "formatted.laz")
+    rewrite_with_pdal(input_file, output_file, params, [])
     # check file exists
     assert os.path.isfile(output_file)
     # check values from metadata
@@ -54,19 +71,43 @@ def _test_standardize_format_one_params_set(input_file, output_file, params):
         extra_dims_names = [dim.split("=")[0] for dim in params["extra_dims"]]
         assert dimensions == EXPECTED_DIMS_BY_DATAFORMAT[params["dataformat_id"]].union(extra_dims_names)
 
+    # Check that there is the expected number of points for each class
+    expected_points_counts = compute_count_one_file(input_file)
+
+    output_points_counts = compute_count_one_file(output_file)
+    assert output_points_counts == expected_points_counts
+
     # TODO: Check srs
     # TODO: check precision
 
 
-def test_standardize_format():
+@pytest.mark.parametrize(
+    "classes_to_remove",
+    [
+        [],
+        [2, 3],
+        [1, 2, 3, 4, 5, 6, 64],  # remove all classes
+    ],
+)
+def test_standardize_classes(classes_to_remove):
     input_file = os.path.join(INPUT_DIR, "test_data_77055_627755_LA93_IGN69_extra_dims.laz")
     output_file = os.path.join(TMP_PATH, "formatted.laz")
-    for params in MUTLIPLE_PARAMS:
-        _test_standardize_format_one_params_set(input_file, output_file, params)
+    rewrite_with_pdal(input_file, output_file, DEFAULT_PARAMS, classes_to_remove)
+    # Check that there is the expected number of points for each class
+    expected_points_counts = compute_count_one_file(input_file)
+    for cl in classes_to_remove:
+        expected_points_counts.pop(str(cl))
+
+    output_points_counts = compute_count_one_file(output_file)
+    assert output_points_counts == expected_points_counts
 
 
 def exec_lasinfo(input_file: str):
-    r = sp.run(["lasinfo", "-stdout", input_file], stderr=sp.PIPE, stdout=sp.PIPE)
+    if platform.processor() == "arm" and platform.architecture()[0] == "64bit":
+        lasinfo = "lasinfo64"
+    else:
+        lasinfo = "lasinfo"
+    r = sp.run([lasinfo, "-stdout", input_file], stderr=sp.PIPE, stdout=sp.PIPE)
     if r.returncode == 1:
         msg = r.stderr.decode()
         print(msg)
@@ -102,14 +143,14 @@ def test_standardize_does_NOT_produce_any_warning_with_Lasinfo():
     # if you want to see input_file warnings
     # assert_lasinfo_no_warning(input_file)
 
-    standardize(input_file, output_file, MUTLIPLE_PARAMS[0])
+    standardize(input_file, output_file, DEFAULT_PARAMS, [])
     assert_lasinfo_no_warning(output_file)
 
 
 def test_standardize_malformed_laz():
     input_file = os.path.join(TEST_PATH, "data/test_pdalfail_0643_6319_LA93_IGN69.laz")
     output_file = os.path.join(TMP_PATH, "standardize_pdalfail_0643_6319_LA93_IGN69.laz")
-    standardize(input_file, output_file, MUTLIPLE_PARAMS[0])
+    standardize(input_file, output_file, DEFAULT_PARAMS, [])
     assert os.path.isfile(output_file)
 
 

ign_pdal_tools-1.7.3/pdaltools/pcd_info.py

@@ -1,46 +0,0 @@
-"""Tools to get information from a point cloud (points as a numpy array)"""
-
-from typing import Tuple
-
-import numpy as np
-
-
-def get_pointcloud_origin_from_tile_width(
-    points: np.ndarray, tile_width: int = 1000, buffer_size: float = 0
-) -> Tuple[int, int]:
-    """Get point cloud theoretical origin (xmin, ymax) for a data that originates from a square tesselation/tiling
-    using the tesselation tile width only.
-
-    Edge values are supposed to be included in the tile
-
-
-    Args:
-        points (np.ndarray): numpy array with the tile points
-        tile_width (int, optional): Edge size of the square used for tiling. Defaults to 1000.
-        buffer_size (float, optional): Optional buffer around the tile. Defaults to 0.
-
-    Raises:
-        ValueError: Raise an error when the bounding box of the tile is not included in a tile
-
-    Returns:
-        Tuple[int, int]: (origin_x, origin_y) origin coordinates
-    """
-    # Extract coordinates xmin, xmax, ymin and ymax of the original tile without buffer
-    x_min, y_min = np.min(points[:, :2], axis=0) + buffer_size
-    x_max, y_max = np.max(points[:, :2], axis=0) - buffer_size
-
-    # Calculate the tiles to which x, y bounds belong
-    tile_x_min = np.floor(x_min / tile_width)
-    tile_x_max = np.floor(x_max / tile_width) if x_max % tile_width != 0 else np.floor(x_max / tile_width) - 1
-    tile_y_min = np.ceil(y_min / tile_width) if y_min % tile_width != 0 else np.floor(y_min / tile_width) + 1
-    tile_y_max = np.ceil(y_max / tile_width)
-
-    if not (tile_x_max - tile_x_min) and not (tile_y_max - tile_y_min):
-        origin_x = tile_x_min * tile_width
-        origin_y = tile_y_max * tile_width
-        return origin_x, origin_y
-    else:
-        raise ValueError(
-            f"Min values (x={x_min} and y={y_min}) do not belong to the same theoretical tile as"
-            f"max values (x={x_max} and y={y_max})."
-        )

ign_pdal_tools-1.7.3/test/test_pcd_info.py

@@ -1,61 +0,0 @@
-import os
-
-import laspy
-import numpy as np
-import pytest
-
-from pdaltools import pcd_info
-
-TEST_PATH = os.path.dirname(os.path.abspath(__file__))
-TMP_PATH = os.path.join(TEST_PATH, "tmp")
-DATA_PATH = os.path.join(TEST_PATH, "data")
-
-
-@pytest.mark.parametrize(
-    "input_points, expected_origin",
-    [
-        (np.array([[501, 501, 0], [999, 999, 0]]), (0, 1000)),  # points in the second half
-        (np.array([[1, 1, 0], [400, 400, 0]]), (0, 1000)),  # points in the frist half
-        (np.array([[500, 500, 0], [1000, 500, 0]]), (0, 1000)),  # xmax on edge and xmin in the tile
-        (np.array([[0, 500, 0], [20, 500, 0]]), (0, 1000)),  # xmin on edge and xmax in the tile
-        (np.array([[950, 500, 0], [1000, 500, 0]]), (0, 1000)),  # xmax on edge and xmin in the tile
-        (np.array([[500, 980, 0], [500, 1000, 0]]), (0, 1000)),  # ymax on edge and ymin in the tile
-        (np.array([[500, 0, 0], [500, 20, 0]]), (0, 1000)),  # ymin on edge and ymax in the tile
-        (np.array([[0, 0, 0], [1000, 1000, 0]]), (0, 1000)),  # points at each corner
-    ],
-)
-def test_get_pointcloud_origin_edge_cases(input_points, expected_origin):
-    origin_x, origin_y = pcd_info.get_pointcloud_origin_from_tile_width(points=input_points, tile_width=1000)
-    assert (origin_x, origin_y) == expected_origin
-
-
-@pytest.mark.parametrize(
-    "input_points",
-    [
-        (np.array([[0, -1, 0], [20, 20, 0]])),  # ymin slightly outside the tile
-        (np.array([[-1, 0, 0], [20, 20, 0]])),  # xmin slightly outside the tile
-        (np.array([[980, 980, 0], [1000, 1001, 0]])),  # ymax slightly outside the tile
-        (np.array([[980, 980, 0], [1001, 1000, 0]])),  # xmax slightly outside the tile
-        (np.array([[-1, 0, 0], [1000, 1000, 0]])),  # xmax on edge but xmin outside the tile
-        (np.array([[0, 0, 0], [1000, 1001, 0]])),  # ymin on edge but ymax outside the tile
-        (np.array([[0, 0, 0], [1001, 1000, 0]])),  # xmin on edge but xmax outside the tile
-        (np.array([[0, -1, 0], [1000, 1000, 0]])),  # ymax on edge but ymin outside the tile
-    ],
-)
-def test_get_pointcloud_origin_edge_cases_fail(input_points):
-    with pytest.raises(ValueError):
-        pcd_info.get_pointcloud_origin_from_tile_width(points=input_points, tile_width=1000)
-
-
-def test_get_pointcloud_origin_on_file():
-    input_las = os.path.join(DATA_PATH, "test_data_77055_627760_LA93_IGN69.laz")
-    expected_origin = (770550, 6277600)
-    LAS = laspy.read(input_las)
-    INPUT_POINTS = np.vstack((LAS.x, LAS.y, LAS.z)).transpose()
-
-    origin_x, origin_y = pcd_info.get_pointcloud_origin_from_tile_width(points=INPUT_POINTS, tile_width=50)
-    assert (origin_x, origin_y) == expected_origin
-    origin_x_2, origin_y_2 = pcd_info.get_pointcloud_origin_from_tile_width(
-        points=INPUT_POINTS, tile_width=10, buffer_size=20
-    )
-    assert (origin_x_2, origin_y_2) == (expected_origin[0] + 20, expected_origin[1] - 20)