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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.15.6
+Version: 1.15.8
 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.6 → ign_pdal_tools-1.15.8}/ign_pdal_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ign-pdal-tools
-Version: 1.15.6
+Version: 1.15.8
 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.6 → ign_pdal_tools-1.15.8}/pdaltools/_version.py

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

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

@@ -31,7 +31,7 @@ def match_min_max_with_pixel_size(min_d: float, max_d: float, pixel_per_meter: f
     return min_d, max_d
 
 
-def color(
+def color_from_stream(
     input_file: str,
     output_file: str,
     proj="",
@@ -156,28 +156,58 @@ def color(
     return tmp_ortho, tmp_ortho_irc
 
 
-def parse_args():
-    parser = argparse.ArgumentParser("Colorize tool", formatter_class=argparse.RawTextHelpFormatter)
-    parser.add_argument("--input", "-i", type=str, required=True, help="Input file")
-    parser.add_argument("--output", "-o", type=str, default="", help="Output file")
-    parser.add_argument(
-        "--proj", "-p", type=str, default="", help="Projection, default will use projection from metadata input"
+def color_from_files(
+    input_file: str,
+    output_file: str,
+    rgb_image: str,
+    irc_image: str,
+    color_rvb_enabled=True,
+    color_ir_enabled=True,
+    veget_index_file="",
+    vegetation_dim="Deviation",
+):
+    pipeline = pdal.Reader.las(filename=input_file)
+
+    writer_extra_dims = "all"
+
+    if veget_index_file and veget_index_file != "":
+        print(f"Remplissage du champ {vegetation_dim} à partir du fichier {veget_index_file}")
+        pipeline |= pdal.Filter.colorization(raster=veget_index_file, dimensions=f"{vegetation_dim}:1:256.0")
+        writer_extra_dims = [f"{vegetation_dim}=ushort"]
+
+    # 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
+    if color_rvb_enabled:
+        pipeline |= pdal.Filter.colorization(raster=rgb_image, dimensions="Red:1:256.0, Green:2:256.0, Blue:3:256.0")
+    if color_ir_enabled:
+        pipeline |= pdal.Filter.colorization(raster=irc_image, dimensions="Infrared:1:256.0")
+
+    pipeline |= pdal.Writer.las(
+        filename=output_file, extra_dims=writer_extra_dims, minor_version="4", dataformat_id="8", forward="all"
     )
-    parser.add_argument("--resolution", "-r", type=float, default=5, help="Resolution, in pixel per meter")
-    parser.add_argument("--timeout", "-t", type=int, default=300, help="Timeout, in seconds")
-    parser.add_argument("--rvb", action="store_true", help="Colorize RVB")
-    parser.add_argument("--ir", action="store_true", help="Colorize IR")
-    parser.add_argument(
-        "--vegetation",
-        type=str,
-        default="",
-        help="Vegetation file (raster), value will be stored in 'vegetation_dim' field",
+
+    print("Traitement du nuage de point")
+    pipeline.execute()
+
+
+def argument_parser():
+    parser = argparse.ArgumentParser("Colorize tool")
+    subparsers = parser.add_subparsers(required=True)
+
+    # first command is 'from_stream'
+    from_stream = subparsers.add_parser("from_stream", help="Images are downloaded from streams")
+    from_stream.add_argument(
+        "--proj", "-p", type=str, default="", help="Projection, default will use projection from metadata input"
     )
-    parser.add_argument(
-        "--vegetation_dim", type=str, default="Deviation", help="name of the extra_dim uses for the vegetation value"
+    from_stream.add_argument("--timeout", "-t", type=int, default=300, help="Timeout, in seconds")
+    from_stream.add_argument("--rvb", action="store_true", help="Colorize RVB")
+    from_stream.add_argument("--ir", action="store_true", help="Colorize IR")
+    from_stream.add_argument("--resolution", "-r", type=float, default=5, help="Resolution, in pixel per meter")
+    from_stream.add_argument(
+        "--check-images", "-c", action="store_true", help="Check that downloaded image is not white"
     )
-    parser.add_argument("--check-images", "-c", action="store_true", help="Check that downloaded image is not white")
-    parser.add_argument(
+    from_stream.add_argument(
         "--stream-RGB",
         type=str,
         default="ORTHOIMAGERY.ORTHOPHOTOS",
@@ -186,27 +216,49 @@ default stream (ORTHOIMAGERY.ORTHOPHOTOS) let the server choose the resolution
 for 20cm resolution rasters, use HR.ORTHOIMAGERY.ORTHOPHOTOS
 for 50 cm resolution rasters, use ORTHOIMAGERY.ORTHOPHOTOS.BDORTHO""",
     )
-    parser.add_argument(
+    from_stream.add_argument(
         "--stream-IRC",
         type=str,
         default="ORTHOIMAGERY.ORTHOPHOTOS.IRC",
         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(
+    from_stream.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.",
     )
+    add_common_options(from_stream)
+    from_stream.set_defaults(func=from_stream_func)
 
-    return parser.parse_args()
+    # second command is 'from_files'
+    from_files = subparsers.add_parser("from_files", help="Images are in directories from RGB/IRC")
+    from_files.add_argument("--image_RGB", type=str, required=True, help="RGB image filepath")
+    from_files.add_argument("--image_IRC", type=str, required=True, help="IRC image filepath")
+    add_common_options(from_files)
+    from_files.set_defaults(func=from_files_func)
 
+    return parser
 
-if __name__ == "__main__":
-    args = parse_args()
-    color(
+
+def add_common_options(parser):
+    parser.add_argument("--input", "-i", type=str, required=True, help="Input file")
+    parser.add_argument("--output", "-o", type=str, default="", help="Output file")
+    parser.add_argument(
+        "--vegetation",
+        type=str,
+        default="",
+        help="Vegetation file (raster), value will be stored in 'vegetation_dim' field",
+    )
+    parser.add_argument(
+        "--vegetation_dim", type=str, default="Deviation", help="name of the extra_dim uses for the vegetation value"
+    )
+
+
+def from_stream_func(args):
+    color_from_stream(
         input_file=args.input,
         output_file=args.output,
         proj=args.proj,
@@ -221,3 +273,33 @@ if __name__ == "__main__":
         stream_IRC=args.stream_IRC,
         size_max_gpf=args.size_max_GPF,
     )
+
+
+def from_files_func(args):
+    if args.image_RGB and args.image_RGB != "":
+        color_rvb_enabled = True
+    else:
+        color_rvb_enabled = False
+    if args.image_IRC and args.image_IRC != "":
+        color_irc_enabled = True
+    else:
+        color_irc_enabled = False
+
+    if not color_rvb_enabled and not color_irc_enabled:
+        raise ValueError("At least one of --rvb or --ir must be provided")
+
+    color_from_files(
+        input_file=args.input,
+        output_file=args.output,
+        rgb_image=args.image_RGB,
+        irc_image=args.image_IRC,
+        color_rvb_enabled=color_rvb_enabled,
+        color_ir_enabled=color_irc_enabled,
+        veget_index_file=args.vegetation,
+        vegetation_dim=args.vegetation_dim,
+    )
+
+
+if __name__ == "__main__":
+    args = argument_parser.parse_args()
+    args.func(args)

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

@@ -1,12 +1,13 @@
 import argparse
-from pathlib import Path
-from typing import Tuple
+from typing import Tuple, Dict, Optional
 
 import laspy
 import numpy as np
 
+from pathlib import Path
+
 
-def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) -> Tuple[bool, int, float]:
+def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None, precision: Optional[Dict[str, float]] = None) -> Tuple[bool, int, float]:
     """
     Compare specified dimensions between two LAS files.
     If no dimensions are specified, compares all available dimensions.
@@ -16,6 +17,8 @@ def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) ->
         file1: Path to the first LAS file
         file2: Path to the second LAS file
         dimensions: List of dimension names to compare (optional)
+        precision: Dictionary mapping dimension names to tolerance values for float comparison.
+                   If None or dimension not in dict, uses exact comparison (default: None)
 
     Returns:
         bool: True if all specified dimensions are identical, False otherwise
@@ -59,20 +62,42 @@ def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) ->
         # Compare each dimension
         for dim in dimensions:
             try:
+                
                 # Get sorted dimension arrays
                 dim1 = np.array(las1[dim])[sort_idx1]
                 dim2 = np.array(las2[dim])[sort_idx2]
 
+                # Get precision for this dimension (if specified)
+                dim_precision = None
+                if precision is not None and dim in precision:
+                    dim_precision = precision[dim]
+
                 # Compare dimensions
-                if not np.array_equal(dim1, dim2):
-                    # Find differences
-                    diff_indices = np.where(dim1 != dim2)[0]
-                    print(f"Found {len(diff_indices)} points with different {dim}:")
-                    for idx in diff_indices[:10]:  # Show first 10 differences
-                        print(f"Point {idx}: file1={dim1[idx]}, file2={dim2[idx]}")
-                    if len(diff_indices) > 10:
-                        print(f"... and {len(diff_indices) - 10} more differences")
-                    return False, len(diff_indices), 100 * len(diff_indices) / len(las1)
+                if dim_precision is not None:
+                    # Use tolerance-based comparison for floats
+                    are_equal = np.allclose(dim1, dim2, rtol=0, atol=dim_precision)
+                    if not are_equal:
+                        # Find differences
+                        diff_mask = ~np.isclose(dim1, dim2, rtol=0, atol=dim_precision)
+                        diff_indices = np.where(diff_mask)[0]
+                        print(f"Found {len(diff_indices)} points with different {dim} (tolerance={dim_precision}):")
+                        for idx in diff_indices[:10]:  # Show first 10 differences
+                            diff_value = abs(dim1[idx] - dim2[idx])
+                            print(f"Point {idx}: file1={dim1[idx]}, file2={dim2[idx]}, diff={diff_value}")
+                        if len(diff_indices) > 10:
+                            print(f"... and {len(diff_indices) - 10} more differences")
+                        return False, len(diff_indices), 100 * len(diff_indices) / len(las1)
+                else:
+                    # Exact comparison
+                    if not np.array_equal(dim1, dim2):
+                        # Find differences
+                        diff_indices = np.where(dim1 != dim2)[0]
+                        print(f"Found {len(diff_indices)} points with different {dim}:")
+                        for idx in diff_indices[:10]:  # Show first 10 differences
+                            print(f"Point {idx}: file1={dim1[idx]}, file2={dim2[idx]}")
+                        if len(diff_indices) > 10:
+                            print(f"... and {len(diff_indices) - 10} more differences")
+                        return False, len(diff_indices), 100 * len(diff_indices) / len(las1)
 
             except KeyError:
                 print(f"Dimension '{dim}' not found in one or both files")
@@ -93,12 +118,32 @@ def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) ->
 
 # Update main function to use the new compare function
 def main():
-    parser = argparse.ArgumentParser(description="Compare dimensions between two LAS files")
+    parser = argparse.ArgumentParser(
+        description="Compare dimensions between two LAS files",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Compare all dimensions with exact match
+  python las_comparison.py file1.las file2.las
+
+  # Compare specific dimensions with precision per dimension
+  python las_comparison.py file1.las file2.las --dimensions X Y Z --precision X=0.001 Y=0.001 Z=0.0001
+
+  # Compare all dimensions with precision for specific ones
+  python las_comparison.py file1.las file2.las --precision X=0.001 Y=0.001
+        """
+    )
     parser.add_argument("file1", type=str, help="Path to first LAS file")
     parser.add_argument("file2", type=str, help="Path to second LAS file")
     parser.add_argument(
         "--dimensions", nargs="*", help="List of dimensions to compare. If not specified, compares all dimensions."
     )
+    parser.add_argument(
+        "--precision", nargs="*", metavar="DIM=VAL",
+        help="Tolerance for float comparison per dimension (format: DIMENSION=PRECISION). "
+             "Example: --precision X=0.001 Y=0.001 Z=0.0001. "
+             "Dimensions not specified will use exact comparison."
+    )
 
     args = parser.parse_args()
 
@@ -109,7 +154,18 @@ def main():
         print("Error: One or both files do not exist")
         exit(1)
 
-    result = compare_las_dimensions(file1, file2, args.dimensions)
+    # Parse precision dictionary from command line arguments
+    precision_dict = None
+    if args.precision:
+        precision_dict = {}
+        for prec_spec in args.precision:
+            try:
+                dim_name, prec_value = prec_spec.split('=', 1)
+                precision_dict[dim_name] = float(prec_value)
+            except ValueError:
+                parser.error(f"Invalid precision format: '{prec_spec}'. Expected format: DIMENSION=PRECISION (e.g., X=0.001)")
+
+    result = compare_las_dimensions(file1, file2, args.dimensions, precision_dict)
     print(f"Dimensions comparison result: {'identical' if result[0] else 'different'}")
     return result
 

ign_pdal_tools-1.15.8/pdaltools/las_merge.py

@@ -0,0 +1,144 @@
+import logging
+import os
+
+import pdal
+
+from pdaltools.las_info import parse_filename
+
+
+def create_filenames_suffixes(file: str, tile_width: int = 1000, tile_coord_scale: int = 1000):
+    """Generate the name of the tiles around the input LIDAR tile
+    It supposes that the file names are formatted as {prefix1}_{prefix2}_{coordx}_{coordy}_{suffix}
+    with coordx and coordy having at least 4 digits
+
+    For example Semis_2021_0000_1111_LA93_IGN69.las
+
+    Generates only the suffix part of the filename, for example, for file like above, it will generate:
+    _0000_1112_LA93_IGN69.las
+    _0001_1112_LA93_IGN69.las
+    ...
+
+    Args:
+        file(str): name of LIDAR file
+        tile width (int): width of tiles in meters (usually 1000m)
+        tile_coord_scale (int) : scale used in the filename to describe coordinates in meters
+                (usually 1000m)
+    Returns:
+        list_input(list): List of LIDAR's filename suffix.
+    """
+
+    # Create name of LIDAR tiles who cercle the tile
+    # # Parameters
+    _prefix, coord_x, coord_y, _suffix = parse_filename(file)
+    offset = int(tile_width / tile_coord_scale)
+    # On left
+    _tile_hl = f"_{(coord_x - offset):04d}_{(coord_y + offset):04d}_{_suffix}"
+    _tile_ml = f"_{(coord_x - offset):04d}_{coord_y:04d}_{_suffix}"
+    _tile_bl = f"_{(coord_x - offset):04d}_{(coord_y - offset):04d}_{_suffix}"
+    # On Right
+    _tile_hr = f"_{(coord_x + offset):04d}_{(coord_y + offset):04d}_{_suffix}"
+    _tile_mr = f"_{(coord_x + offset):04d}_{coord_y:04d}_{_suffix}"
+    _tile_br = f"_{(coord_x + offset):04d}_{(coord_y - offset):04d}_{_suffix}"
+    # Above
+    _tile_a = f"_{coord_x:04d}_{(coord_y + offset):04d}_{_suffix}"
+    # Below
+    _tile_b = f"_{coord_x:04d}_{(coord_y - offset):04d}_{_suffix}"
+    # Return the severals tile's names
+    return _tile_hl, _tile_ml, _tile_bl, _tile_a, _tile_b, _tile_hr, _tile_mr, _tile_br
+
+
+def match_suffix_with_filenames(suffix_list: list, all_files: list, las_dir: str):
+    """Match suffix list with real filenames
+    Args:
+        suffix_list (list): List of suffix patterns to match
+        all_files (list): List of all files in las_dir
+        las_dir (str): Directory of pointclouds
+
+    Returns:
+        las_list(List): List of matched files
+    """
+    las_list = []
+    for suffix in suffix_list:
+        matches = [filename for filename in all_files if filename.endswith(suffix)]
+        if len(matches) == 0:
+            logging.info(f"NOK : {suffix}")
+        else:
+            # in case of multiple matches, select the most recent year (ex: Semis_2021_ before Semis_2020_ )
+            matches.sort(reverse=True)
+            selected = matches[0]
+            if len(matches) > 1:
+                logging.warning(f"Multiple matches for {suffix} : {matches} ; taking {selected}")
+
+            # Append full path
+            las_list.append(os.path.join(las_dir, selected))
+    return las_list
+
+
+def create_tiles_list(all_files, las_dir, input_file, tile_width=1000, tile_coord_scale=1000):
+    """Return the paths of 8 tiles around the tile + the input tile
+    Args:
+        all_files (list): list of all files in las_dir
+        las_dir (str): directory of pointclouds
+        input_file (str): path to queried LIDAR tile
+        tile_width (int): Width of a tile(in the reference unit: 1m)
+        tile_coord_scale (int): Scale used in filename to describe coordinates (usually kilometers)
+        1000 * 1m (with 1m being the reference)
+
+    Returns:
+        list_files: list of tiles
+    """
+
+    # Return list 8 tiles around the tile, but only the suffix part of the name.
+    suffix_list = create_filenames_suffixes(os.path.basename(input_file), tile_width, tile_coord_scale)
+
+    # Match suffix patterns with real files
+    list_files = match_suffix_with_filenames(suffix_list, all_files, las_dir)
+
+    # Appending queried tile to list
+    list_files.append(input_file)
+
+    return list_files
+
+
+def create_list(las_dir, input_file, tile_width=1000, tile_coord_scale=1000):
+    """Return the paths of 8 tiles around the tile + the input tile
+    Args:
+        las_dir (str): directory of pointclouds
+        input_file (str): path to queried LIDAR tile
+        tile_width (int): Width of a tile(in the reference unit: 1m)
+        tile_coord_scale (int): Scale used in filename to describe coordinates (usually kilometers)
+        1000 * 1m (with 1m being the reference)
+
+    Returns:
+        list_files: list of tiles
+    """
+
+    # list files on the disk
+    all_files = os.listdir(las_dir)
+
+    # call the function with the list of files
+    return create_tiles_list(all_files, las_dir, input_file, tile_width, tile_coord_scale)
+
+
+def las_merge(las_dir, input_file, merge_file, tile_width=1000, tile_coord_scale=1000):
+    """Merge LIDAR tiles around input_file tile
+    Args:
+        las_dir (str): directory of pointclouds (to look for neigboprs)
+        input_file (str): name of query LIDAR file (with extension)
+        output_file (str): path to output
+        tile_width (int): Width of a tile(in the reference unit: 1m)
+        tile_coord_scale (int): Scale used in filename to describe coordinates (usually kilometers)
+        1000 * 1m (with 1m being the reference)
+    """
+    # List files to merge
+    files = create_list(las_dir, input_file, tile_width, tile_coord_scale)
+    if len(files) > 0:
+        # Merge
+        pipeline = pdal.Pipeline()
+        for f in files:
+            pipeline |= pdal.Reader.las(filename=f)
+        pipeline |= pdal.Filter.merge()
+        pipeline |= pdal.Writer.las(filename=merge_file, forward="all")
+        pipeline.execute()
+    else:
+        raise ValueError("List of valid tiles is empty : stop processing")

{ign_pdal_tools-1.15.6 → ign_pdal_tools-1.15.8}/test/test_color.py

@@ -7,6 +7,7 @@ import numpy as np
 import pytest
 
 from pdaltools import color
+from pdaltools.color import argument_parser
 
 cwd = os.getcwd()
 
@@ -14,6 +15,11 @@ TEST_PATH = os.path.dirname(os.path.abspath(__file__))
 TMPDIR = os.path.join(TEST_PATH, "tmp", "color")
 
 INPUT_PATH = os.path.join(TEST_PATH, "data/test_noepsg_043500_629205_IGN69.laz")
+INPUT_PATH_TILE = os.path.join(TEST_PATH, "data/test_data_77055_627760_LA93_IGN69.laz")
+
+RGB_IMAGE = os.path.join(TEST_PATH, "data/color/test_data_rgb.tif")
+IRC_IMAGE = os.path.join(TEST_PATH, "data/color/test_data_irc.tif")
+
 
 OUTPUT_FILE = os.path.join(TMPDIR, "Semis_2021_0435_6292_LA93_IGN69.colorized.las")
 EPSG = "2154"
@@ -33,12 +39,12 @@ def test_epsg_fail():
         RuntimeError,
         match="EPSG could not be inferred from metadata: No 'srs' key in metadata.",
     ):
-        color.color(INPUT_PATH, OUTPUT_FILE, "", 0.1, 15)
+        color.color_from_stream(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)
+    tmp_ortho, tmp_ortho_irc = color.color_from_stream(INPUT_PATH, OUTPUT_FILE, EPSG, check_images=True)
     assert Path(tmp_ortho.name).exists()
     assert Path(tmp_ortho_irc.name).exists()
 
@@ -63,7 +69,7 @@ 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)
+    color.color_from_stream(input_path, output_path, EPSG)
     with laspy.open(output_path, "r") as las:
         las_data = las.read()
     # Check all points are colored
@@ -75,10 +81,9 @@ def test_color_narrow_cloud():
 
 @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)
+    color.color_from_stream(INPUT_PATH_TILE, output_path, EPSG)
     with laspy.open(output_path, "r") as las:
         las_data = las.read()
     # Check all points are colored
@@ -92,7 +97,7 @@ 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)
+    color.color_from_stream(input_path, output_path, 2975)
 
 
 # the test is not working, the image is not detected as white
@@ -104,7 +109,7 @@ def test_color_epsg_2975_forced():
 #    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)
+#        color.color_from_stream(input_path, output_path, check_images=True)
 
 #    assert "Downloaded image is white" in str(excinfo.value)
 
@@ -114,18 +119,17 @@ 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)
+    color.color_from_stream(input_path, output_path)
 
 
 def test_color_vegetation_only():
-    """Test the color() function with only vegetation"""
-    input_path = os.path.join(TEST_PATH, "data/test_data_77055_627760_LA93_IGN69.laz")
+    """Test the color_from_stream() function with only vegetation"""
     output_path = os.path.join(TMPDIR, "test_color_vegetation.colorized.las")
     vegetation_path = os.path.join(TEST_PATH, "data/mock_vegetation.tif")
 
     # Test with all parameters explicitly defined
-    color.color(
-        input_file=input_path,
+    color.color_from_stream(
+        input_file=INPUT_PATH_TILE,
         output_file=output_path,
         proj="2154",  # EPSG:2154 (Lambert 93)
         color_rvb_enabled=False,  # RGB enabled
@@ -153,14 +157,13 @@ def test_color_vegetation_only():
 
 @pytest.mark.geopf
 def test_color_with_all_parameters():
-    """Test the color() function with all parameters specified"""
-    input_path = os.path.join(TEST_PATH, "data/test_data_77055_627760_LA93_IGN69.laz")
+    """Test the color_from_stream() function with all parameters specified"""
     output_path = os.path.join(TMPDIR, "test_color_all_params.colorized.las")
     vegetation_path = os.path.join(TEST_PATH, "data/mock_vegetation.tif")
 
     # Test with all parameters explicitly defined
-    tmp_ortho, tmp_ortho_irc = color.color(
-        input_file=input_path,
+    tmp_ortho, tmp_ortho_irc = color.color_from_stream(
+        input_file=INPUT_PATH_TILE,
         output_file=output_path,
         proj="2154",  # EPSG:2154 (Lambert 93)
         pixel_per_meter=2.0,  # custom resolution
@@ -196,3 +199,56 @@ def test_color_with_all_parameters():
     # Verify that the vegetation dimension is present
     assert "vegetation_dim" in las_data.point_format.dimension_names, "Vegetation dimension should be present"
     assert not np.all(las_data.vegetation_dim == 0), "Vegetation dimension should not be empty"
+
+
+def test_color_from_files():
+    output_path = os.path.join(TMPDIR, "color_standard_cloud_files_test_data_77055_627760_LA93_IGN69.colorized.laz")
+
+    color.color_from_files(INPUT_PATH_TILE, output_path, RGB_IMAGE, IRC_IMAGE)
+
+    assert os.path.exists(output_path)
+
+    with laspy.open(output_path, "r") as las:
+        las_data = las.read()
+
+    # Verify that all points have been colorized (no 0 values)
+    las_rgb_missing = (las_data.red == 0) & (las_data.green == 0) & (las_data.blue == 0)
+    assert not np.any(las_rgb_missing), f"No point should have missing RGB, found {np.count_nonzero(las_rgb_missing)}"
+    assert not np.any(las_data.nir == 0), "No point should have missing NIR"
+
+
+@pytest.mark.geopf
+def test_main_from_stream():
+    output_file = os.path.join(TMPDIR, "main_from_stream", "output_main_from_stream.laz")
+    os.makedirs(os.path.dirname(output_file))
+    cmd = f"from_stream -i {INPUT_PATH_TILE} -o {output_file} -p {EPSG} --rvb --ir".split()
+    args = argument_parser().parse_args(cmd)
+    args.func(args)
+
+    assert os.path.exists(output_file)
+
+    with laspy.open(output_file, "r") as las:
+        las_data = las.read()
+
+    # Verify that all points have been colorized (no 0 values)
+    las_rgb_missing = (las_data.red == 0) & (las_data.green == 0) & (las_data.blue == 0)
+    assert not np.any(las_rgb_missing), f"No point should have missing RGB, found {np.count_nonzero(las_rgb_missing)}"
+    assert not np.any(las_data.nir == 0), "No point should have missing NIR"
+
+
+def test_main_from_files():
+    output_file = os.path.join(TMPDIR, "main_from_files", "output_main_from_files.laz")
+    os.makedirs(os.path.dirname(output_file))
+    cmd = f"from_files -i {INPUT_PATH_TILE} -o {output_file} --image_RGB {RGB_IMAGE} --image_IRC {IRC_IMAGE}".split()
+    args = argument_parser().parse_args(cmd)
+    args.func(args)
+
+    assert os.path.exists(output_file)
+
+    with laspy.open(output_file, "r") as las:
+        las_data = las.read()
+
+    # Verify that all points have been colorized (no 0 values)
+    las_rgb_missing = (las_data.red == 0) & (las_data.green == 0) & (las_data.blue == 0)
+    assert not np.any(las_rgb_missing), f"No point should have missing RGB, found {np.count_nonzero(las_rgb_missing)}"
+    assert not np.any(las_data.nir == 0), "No point should have missing NIR"