ign-pdal-tools 1.11.1__tar.gz → 1.12.0__tar.gz

{ign_pdal_tools-1.11.1 → ign_pdal_tools-1.12.0}/PKG-INFO

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

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

@@ -8,8 +8,10 @@ ign_pdal_tools.egg-info/top_level.txt
 pdaltools/_version.py
 pdaltools/add_points_in_pointcloud.py
 pdaltools/color.py
+pdaltools/create_random_laz.py
 pdaltools/las_add_buffer.py
 pdaltools/las_clip.py
+pdaltools/las_comparison.py
 pdaltools/las_info.py
 pdaltools/las_merge.py
 pdaltools/las_remove_dimensions.py
@@ -20,8 +22,10 @@ pdaltools/standardize_format.py
 pdaltools/unlock_file.py
 test/test_add_points_in_pointcloud.py
 test/test_color.py
+test/test_create_random_laz.py
 test/test_las_add_buffer.py
 test/test_las_clip.py
+test/test_las_comparison.py
 test/test_las_info.py
 test/test_las_merge.py
 test/test_las_remove_dimensions.py

{ign_pdal_tools-1.11.1 → ign_pdal_tools-1.12.0}/pdaltools/_version.py

@@ -1,4 +1,4 @@
-__version__ = "1.11.1"
+__version__ = "1.12.0"
 
 
 if __name__ == "__main__":

{ign_pdal_tools-1.11.1 → ign_pdal_tools-1.12.0}/pdaltools/add_points_in_pointcloud.py

@@ -1,18 +1,15 @@
 import argparse
-from shutil import copy2
 import tempfile
+from shutil import copy2
 
 import geopandas as gpd
 import laspy
 import numpy as np
-from pyproj import CRS
-from pyproj.exceptions import CRSError
+import pdal
 from shapely.geometry import MultiPoint, Point, box
 
 from pdaltools.las_info import get_epsg_from_las, get_tile_bbox
 
-import pdal
-
 
 def parse_args(argv=None):
     parser = argparse.ArgumentParser("Add points from GeoJSON in LIDAR tile")
@@ -223,6 +220,9 @@ def generate_3d_points_from_lines(
                     and Z coordinates are not available in the geometry.
     """
     # Check if altitude_column is provided and exists in the GeoDataFrame
+    if lines_gdf.empty:
+        return lines_gdf
+
     if altitude_column and (altitude_column not in lines_gdf.columns):
         raise ValueError("altitude_column must exist in the GeoDataFrame if provided.")
 

ign_pdal_tools-1.12.0/pdaltools/create_random_laz.py

@@ -0,0 +1,146 @@
+import numpy as np
+import laspy
+from pathlib import Path
+import sys
+import argparse
+import pdal
+from pyproj import CRS
+from typing import List, Tuple, Union
+
+def create_random_laz(output_file: str, point_format: int = 3, num_points: int = 100, crs: int = 2154,
+                      center: Tuple[float, float] = (650000, 6810000),
+                       extra_dims: List[Tuple[str, str]] = [],
+                       ):
+    """
+    Create a test LAZ file with EPSG code and additional dimensions.
+    
+    Args:
+        output_file: Path to save the LAZ file
+        point_format: Point format of the LAZ file (default: 3)
+        num_points: Number of points to generate
+        crs: EPSG code of the CRS (default: 2154)
+        center: Tuple of floats (x, y) of the center of the area to generate points in (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'
+    """
+    
+    # Create a new point cloud
+    header = laspy.LasHeader(point_format=point_format, version="1.4")
+        
+    # Map string types to numpy types
+    type_mapping = {
+        'float32': np.float32,
+        'float64': np.float64,
+        'int8': np.int8,
+        'int16': np.int16,
+        'int32': np.int32,
+        'int64': np.int64,
+        'uint8': np.uint8,
+        'uint16': np.uint16,
+        'uint32': np.uint32,
+        'uint64': np.uint64,
+    }
+        
+    for dim_name, dim_type in extra_dims:
+        if dim_type not in type_mapping:
+            raise ValueError(f"Unsupported dimension type: {dim_type}. Supported types: {list(type_mapping.keys())}")
+        
+        numpy_type = type_mapping[dim_type]
+        header.add_extra_dim(laspy.ExtraBytesParams(name=dim_name, type=numpy_type))
+                
+        # Create point cloud
+    las = laspy.LasData(header)
+    las.header.add_crs(CRS.from_string(f"epsg:{crs}"))
+    
+    # Generate random points in a small area
+    las.x = np.random.uniform(center[0] - 1000, center[0] + 1000, num_points)
+    las.y = np.random.uniform(center[1] - 1000, center[1] + 1000, num_points)
+    las.z = np.random.uniform(0, 200, num_points)
+        
+    # Generate random intensity values
+    las.intensity = np.random.randint(0, 255, num_points)
+    
+    # Generate random classification values
+    # 66 is the max value for classification of IGN LidarHD 
+    # cf. https://geoservices.ign.fr/sites/default/files/2022-05/DT_LiDAR_HD_1-0.pdf
+    if point_format > 3: 
+        num_classifications = 66
+    else:
+        num_classifications = 10
+    las.classification = np.random.randint(0, num_classifications, num_points)
+        
+    # Generate random values for each extra dimension
+    for dim_name, dim_type in extra_dims:
+        numpy_type = type_mapping[dim_type]
+                
+        # Generate appropriate random values based on the type
+        if numpy_type in [np.float32, np.float64]:
+            las[dim_name] = np.random.uniform(0, 10, num_points).astype(numpy_type)
+        elif numpy_type in [np.int8, np.int16, np.int32, np.int64]:
+            las[dim_name] = np.random.randint(-100, 100, num_points).astype(numpy_type)
+        elif numpy_type in [np.uint8, np.uint16, np.uint32, np.uint64]:
+            las[dim_name] = np.random.randint(0, 100, num_points).astype(numpy_type)
+        
+    # Write to file
+    las.write(output_file)
+    dimensions = list(las.point_format.dimension_names)
+    return {
+        "output_file": output_file,
+        "num_points": num_points,
+        "dimensions": dimensions,
+    }
+
+
+def test_output_file(result : dict, output_file: str):
+
+    # Validate output file path
+    output_path = Path(output_file)
+    if not output_path.exists():
+        raise ValueError(f"Error: Output file {output_file} does not exist")
+
+    # Print results
+    print(f"Successfully created test LAZ file at {result['output_file']}")
+    print(f"Number of points: {result['num_points']}")
+    print(f"Dimensions available: {result['dimensions']}")
+
+    # Print available dimensions using PDAL
+    pipeline = pdal.Pipeline() | pdal.Reader.las(result['output_file'])
+    pipeline.execute()
+    points = pipeline.arrays[0]
+    dimensions = list(points.dtype.fields.keys())
+    print("\nAvailable dimensions in input file:")
+    for dim in dimensions:
+        print(f"- {dim}")
+
+
+def parse_args():
+    # Parse arguments (assuming argparse is used)
+    parser = argparse.ArgumentParser(description="Create a random LAZ file.")
+    parser.add_argument("--output_file", type=str, help="Path to save the LAZ file")
+    parser.add_argument("--point_format", type=int, default=3, help="Point format of the LAZ file")
+    parser.add_argument("--num_points", type=int, default=100, help="Number of points to generate")
+    parser.add_argument("--extra_dims", type=str, nargs="*", default=[], help="Extra dimensions in the format name:type")
+    parser.add_argument("--crs", type=int, default=2154, help="Projection code")
+    parser.add_argument("--center", type=str, default="650000,6810000", help="Center of the area to generate points in")
+    return parser.parse_args()
+
+
+def main():
+   
+    # Parse arguments
+    args = parse_args()
+    
+    # Parse extra dimensions
+    extra_dims = [tuple(dim.split(":")) for dim in args.extra_dims]
+    
+    # Parse center
+    center = tuple(map(float, args.center.split(",")))
+
+    # Call create_random_laz
+    result = create_random_laz(args.output_file, args.point_format, args.num_points, args.crs, center, extra_dims)
+    
+    # Test output file
+    test_output_file(result, args.output_file)    
+
+if __name__ == "__main__":
+    main()

ign_pdal_tools-1.12.0/pdaltools/las_comparison.py

@@ -0,0 +1,105 @@
+import laspy
+from pathlib import Path
+import numpy as np
+import argparse
+
+def compare_las_dimensions(file1: Path, file2: Path, dimensions: list = None) -> bool:
+    """
+    Compare specified dimensions between two LAS files.
+    If no dimensions are specified, compares all available dimensions.
+    Sorts points by x,y,z,gps_time coordinates before comparison to ensure point order consistency.
+    
+    Args:
+        file1: Path to the first LAS file
+        file2: Path to the second LAS file
+        dimensions: List of dimension names to compare (optional)
+        
+    Returns:
+        bool: True if all specified dimensions are identical, False otherwise
+    """
+    try:
+        # Read both LAS files
+        las1 = laspy.read(file1)
+        las2 = laspy.read(file2)
+        
+        # Check if files have the same number of points
+        if len(las1) != len(las2):
+            print(f"Files have different number of points: {len(las1)} vs {len(las2)}")
+            return False
+            
+        # Sort points by x,y,z,gps_time coordinates
+        # Create sorting indices
+        sort_idx1 = np.lexsort((las1.z, las1.y, las1.x, las1.gps_time))
+        sort_idx2 = np.lexsort((las2.z, las2.y, las2.x, las2.gps_time))
+        
+        # If no dimensions specified, compare all dimensions
+        dimensions_las1 = sorted(las1.point_format.dimension_names)
+        dimensions_las2 = sorted(las2.point_format.dimension_names)
+        
+        if dimensions is None:
+            if dimensions_las1 != dimensions_las2:
+                print("Files have different dimensions")
+                return False
+            dimensions = dimensions_las1 
+        else:
+            for dim in dimensions:
+                if dim not in dimensions_las1 or dim not in dimensions_las2:
+                    print(f"Dimension '{dim}' is not found in one or both files. Available dimensions: {las1.point_format.dimension_names}")
+                    return False    
+
+        # 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]
+                
+                # 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
+                    
+            except KeyError:
+                print(f"Dimension '{dim}' not found in one or both files")
+                return False
+                
+        return True
+        
+    except laspy.errors.LaspyException as e:
+        print(f"LAS file error: {str(e)}")
+        return False
+    except FileNotFoundError as e:
+        print(f"File not found: {str(e)}")
+        return False
+    except ValueError as e:
+        print(f"Value error: {str(e)}")
+        return False
+
+# Update main function to use the new compare function
+def main():    
+    parser = argparse.ArgumentParser(description='Compare dimensions between two LAS files')
+    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.')
+    
+    args = parser.parse_args()
+    
+    file1 = Path(args.file1)
+    file2 = Path(args.file2)
+    
+    if not file1.exists() or not file2.exists():
+        print("Error: One or both files do not exist")
+        exit(1)
+    
+    result = compare_las_dimensions(file1, file2, args.dimensions)
+    print(f"Dimensions comparison result: {'identical' if result else 'different'}")
+    return result
+
+if __name__ == "__main__":
+    main()

{ign_pdal_tools-1.11.1 → ign_pdal_tools-1.12.0}/test/test_add_points_in_pointcloud.py

@@ -220,6 +220,16 @@ def test_line_to_multipoint(line, spacing, z_value, expected_points):
                 Point(10, 10, 6.0),
             ],
         ),
+        # Test case for empty lines
+        (
+            gpd.GeoDataFrame(
+                {"geometry": [], "RecupZ": []},
+                crs="EPSG:2154",
+            ),
+            2.5,
+            "RecupZ",
+            [],
+        ),
     ],
 )
 def test_generate_3d_points_from_lines(lines_gdf, spacing, altitude_column, expected_points):
@@ -251,7 +261,7 @@ def test_generate_3d_points_from_lines(lines_gdf, spacing, altitude_column, expe
             678,
             0.25,
             "RecupZ",
-        ),  # should add only lignes (.shp) within tile extend
+        ),  # should add only lines (.shp) within tile extend
         (INPUT_PCD, INPUT_LIGNES_SHAPE, None, 678, 0.25, "RecupZ"),  # Should work with or with an input epsg
         (
             INPUT_PCD,
@@ -261,6 +271,14 @@ def test_generate_3d_points_from_lines(lines_gdf, spacing, altitude_column, expe
             0.25,
             None,
         ),  # Should work with or without an input epsg and without altitude_column
+        (
+            INPUT_PCD_CROPPED,
+            INPUT_LIGNES_3D_GEOJSON,
+            None,
+            0,
+            0.25,
+            None,
+        ),  # Should work with lines and add no points if there is no geometry in the tile extent
     ],
 )
 def test_add_points_from_geometry_to_las(input_file, input_points, epsg, expected_nb_points, spacing, altitude_column):
@@ -272,11 +290,11 @@ def test_add_points_from_geometry_to_las(input_file, input_points, epsg, expecte
         input_points, input_file, OUTPUT_FILE, 68, epsg, 1000, spacing, altitude_column
     )
     assert Path(OUTPUT_FILE).exists()  # check output exists
-    
+
     # Read input and output files to compare headers
     input_las = laspy.read(input_file)
     output_las = laspy.read(OUTPUT_FILE)
-    
+
     # Compare headers
     assert input_las.header.version == output_las.header.version
     assert input_las.header.system_identifier == output_las.header.system_identifier
@@ -287,7 +305,7 @@ def test_add_points_from_geometry_to_las(input_file, input_points, epsg, expecte
     assert np.array_equal(input_las.header.scales, output_las.header.scales)
     assert np.array_equal(input_las.header.offsets, output_las.header.offsets)
     assert input_las.header.vlrs[0].string == output_las.header.vlrs[0].string
-    
+
     point_count = compute_count_one_file(OUTPUT_FILE)["68"]
     assert point_count == expected_nb_points  # Add all points from geojson
 

ign_pdal_tools-1.12.0/test/test_create_random_laz.py

@@ -0,0 +1,174 @@
+import os
+import tempfile
+import pytest
+import numpy as np
+import laspy
+import sys
+
+from pdaltools.create_random_laz import create_random_laz, main
+
+TEST_PATH = os.path.dirname(os.path.abspath(__file__))
+TMP_PATH = os.path.join(TEST_PATH, "tmp")
+
+
+def setup_module(module):
+    try:
+        os.makedirs(TMP_PATH, exist_ok=True)
+    except FileNotFoundError:
+        pass
+
+
+def test_create_random_laz_basic():
+    """Test basic functionality without extra dimensions"""
+    output_file = os.path.join(TMP_PATH, "test_basic.laz")
+    create_random_laz(output_file=output_file, num_points=50)
+    
+    # Check file exists
+    assert os.path.isfile(output_file)
+    
+    # Check file can be read
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+        assert len(las.points) == 50
+        assert "X" in las.point_format.dimension_names
+        assert "Y" in las.point_format.dimension_names
+        assert "Z" in las.point_format.dimension_names
+        assert "intensity" in las.point_format.dimension_names
+        assert "classification" in las.point_format.dimension_names
+
+
+def test_create_random_laz_invalid_type():
+    """Test error handling for invalid dimension type"""
+    output_file = os.path.join(TMP_PATH, "test_invalid_type.laz")
+    extra_dims = [("height", "invalid_type")]
+
+    with pytest.raises(ValueError):
+        create_random_laz(output_file=output_file, num_points=50, point_format=3, extra_dims=extra_dims)
+
+
+def test_create_random_point_format():
+    """Test that the point format is set correctly"""
+    output_file = os.path.join(TMP_PATH, "test_point_format.laz")
+    create_random_laz(output_file=output_file, point_format=6, num_points=50)
+    
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+        assert las.header.point_format.id == 6
+    
+
+def test_create_random_laz_no_extra_dims():
+    """Test that the output file is created correctly when no extra dimensions are provided"""
+    output_file = os.path.join(TMP_PATH, "test_no_extra_dims.laz")
+    create_random_laz(output_file, num_points=50)
+    
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+        assert len(las.points) == 50
+        assert "X" in las.point_format.dimension_names
+        assert "Y" in las.point_format.dimension_names
+        assert "Z" in las.point_format.dimension_names
+        assert "intensity" in las.point_format.dimension_names
+        assert "classification" in las.point_format.dimension_names
+
+
+def test_create_random_laz_crs_and_center():
+    """Test that the CRS is set correctly"""
+    output_file = os.path.join(TMP_PATH, "test_crs.laz")
+    create_random_laz(output_file, num_points=50, crs=2153, center=(650000, 6810000))
+    
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()   
+        epsg = las.header.parse_crs().to_epsg()
+        assert epsg == 2153
+
+
+def test_create_random_laz_all_types():
+    """Test all supported dimension types"""
+    output_file = os.path.join(TMP_PATH, "test_all_types.laz")
+    extra_dims = [
+        ("float32_dim", "float32"),
+        ("float64_dim", "float64"),
+        ("int8_dim", "int8"),
+        ("int16_dim", "int16"),
+        ("int32_dim", "int32"),
+        ("int64_dim", "int64"),
+        ("uint8_dim", "uint8"),
+        ("uint16_dim", "uint16"),
+        ("uint32_dim", "uint32"),
+        ("uint64_dim", "uint64"),
+    ]
+    
+    create_random_laz(output_file, num_points=25, extra_dims=extra_dims)
+    
+    # Check file exists
+    assert os.path.isfile(output_file)
+    
+    # Check file can be read and has correct dimensions
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+        assert len(las.points) == 25
+        
+        # Check that all extra dimensions exist
+        for dim_name, _ in extra_dims:
+            assert dim_name in las.point_format.dimension_names
+
+
+def test_create_random_laz_data_ranges():
+    """Test that generated data is within expected ranges for different types"""
+    output_file = os.path.join(TMP_PATH, "test_data_ranges.laz")
+    extra_dims = [
+        ("float_dim", "float32"),
+        ("int_dim", "int32"),
+        ("uint_dim", "uint8"),
+    ]
+    
+    create_random_laz(output_file, num_points=1000, extra_dims=extra_dims)
+    
+    with laspy.open(output_file) as las_file:
+        las = las_file.read()
+        
+        # Check float data is in expected range (0-10)
+        assert np.all(las.float_dim >= 0)
+        assert np.all(las.float_dim <= 10)
+        
+        # Check int data is in expected range (-100 to 100)
+        assert np.all(las.int_dim >= -100)
+        assert np.all(las.int_dim <= 100)
+        
+        # Check uint data is in expected range (0 to 100)
+        assert np.all(las.uint_dim >= 0)
+        assert np.all(las.uint_dim <= 100)
+
+def test_main():
+    """Test the main function"""
+    output_file = os.path.join(TMP_PATH, "test_main.laz")
+
+    original_argv = sys.argv
+    
+    try:
+        # Set up mock command-line arguments
+        sys.argv = [
+            "create_random_laz",
+            "--output_file", output_file,
+            "--point_format", "3",
+            "--num_points", "50",
+            "--crs", "2154",
+            "--center", "650000,6810000",
+            "--extra_dims", "height:float32",
+        ]
+        
+        # Run main function
+        main()
+        
+        # Verify output file exists
+        assert os.path.isfile(output_file)
+        
+        # Verify points count is reduced
+        with laspy.open(output_file) as las_file:
+            las = las_file.read()
+            assert len(las.points) == 50
+            assert "height" in las.point_format.dimension_names
+        
+    finally:
+        # Restore original sys.argv
+        sys.argv = original_argv

ign_pdal_tools-1.12.0/test/test_las_comparison.py

@@ -0,0 +1,275 @@
+import pytest
+import tempfile
+import numpy as np
+from pathlib import Path
+import laspy
+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:
+    """Helper function to create a test LAS file with specified dimensions"""
+    with tempfile.NamedTemporaryFile(suffix='.las', delete=False) as temp:
+        las = laspy.create(point_format=3, file_version="1.4")
+        
+        # Use provided dimensions or create default ones
+        if dimensions is None:
+            dimensions = {
+                'classification': np.random.randint(0, 10, len(x)),
+                'intensity': np.random.randint(0, 255, len(x)),
+                'return_number': np.random.randint(1, 5, len(x))
+            }
+        
+        las.x = x
+        las.y = y
+        las.z = z
+        
+        # Set all specified dimensions
+        for dim_name, dim_data in dimensions.items():
+            setattr(las, dim_name, dim_data)
+        
+        las.write(temp.name)
+        return Path(temp.name)
+
+def get_random_points(points: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    x = np.random.rand(points) * 1000
+    y = np.random.rand(points) * 1000
+    z = np.random.rand(points) * 100
+    return x, y, z
+
+def test_identical_dimensions():
+    """Test that identical dimensions return True"""
+    points = 10
+    x, y, z = get_random_points(points)
+    dimensions = {
+        'classification': np.random.randint(0, 10, points),
+        'intensity': np.random.randint(0, 255, points),
+        'return_number': np.random.randint(1, 5, points)
+    }
+    
+    file1 = create_test_las_file(x, y, z, dimensions)
+    file2 = create_test_las_file(x, y, z, dimensions)
+    
+    try:
+        # Test with specific dimensions
+        result = compare_las_dimensions(file1, file2, ['classification', 'intensity'])
+        assert result is True, "Files with identical dimensions should return True"
+
+        # Test with identical files
+        result = compare_las_dimensions(file1, file2)
+        assert result is True, "Files with identical dimensions should return True"        
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+def test_identical_dimensions_not_sorted():
+    """Test that identical dimensions return True"""
+    points = 10
+    x, y, z = get_random_points(points)
+    dimensions = {
+        'classification': np.random.randint(0, 10, points),
+        'intensity': np.random.randint(0, 255, points),
+        'return_number': np.random.randint(1, 5, points)
+    }
+    dimensions2 = {
+        'classification': dimensions['classification'][::-1],
+        'intensity': dimensions['intensity'][::-1],
+        'return_number': dimensions['return_number'][::-1]
+    }
+
+    file1 = create_test_las_file(x, y, z, dimensions)
+    file2 = create_test_las_file(x[::-1], y[::-1], z[::-1], dimensions2)
+    
+    try:
+        # Test with specific dimensions
+        result = compare_las_dimensions(file1, file2, ['classification', 'intensity'])
+        assert result is True, "Files with identical dimensions should return True"
+
+        # Test with identical files
+        result = compare_las_dimensions(file1, file2)
+        assert result is True, "Files with identical dimensions should return True"        
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+
+def test_different_dimensions_random():
+    """Test that files with random dimensions return False"""
+    points = 100
+    x, y, z = get_random_points(points)
+    
+    # Create file1 with random dimensions
+    dimensions1 = {
+        'classification': np.random.randint(0, 10, points),
+        'intensity': np.random.randint(0, 255, points),
+        'return_number': np.random.randint(1, 5, points)
+    }
+    file1 = create_test_las_file(x, y, z, dimensions1)
+    
+    # Create file2 with different dimensions
+    dimensions2 = {
+        'classification': np.random.randint(0, 10, points),  # Different classification
+        'intensity': dimensions1['intensity'],  # Same intensity
+        'return_number': dimensions1['return_number']  # Same return_number
+    }
+    file2 = create_test_las_file(x, y, z, dimensions2)
+    
+    try:
+        # Test full comparison (should be different)
+        result = compare_las_dimensions(file1, file2)
+        assert result is False, "Files with different classification should return False"
+        
+        # Test specific dimensions (should be identical)
+        result = compare_las_dimensions(file1, file2, ['intensity', 'return_number'])
+        assert result is True, "Files with identical intensity and return_number should return True"
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+def test_different_number_of_points():
+    """Test that files with different number of points return False"""
+    points = 100
+    x1, y1, z1 = get_random_points(points)
+    x2, y2, z2 = get_random_points(points + 1)
+    file1 = create_test_las_file(x1, y1, z1)
+    file2 = create_test_las_file(x2, y2, z2)
+    
+    try:
+        result = compare_las_dimensions(file1, file2)
+        assert result is False, "Files with different number of points should return False"
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+def test_different_dimensions_number():
+    """Test that files with different number of dimensions return False"""
+    points = 100
+    x, y, z = get_random_points(points)
+    
+    # Create file1 with random dimensions
+    dimensions1 = {
+        'classification': np.random.randint(0, 10, points),
+        'intensity': np.random.randint(0, 255, points),
+        'return_number': np.random.randint(1, 5, points)
+    }
+    file1 = create_test_las_file(x, y, z, dimensions1)
+    
+    # Create file2 only 2 dimensions
+    dimensions2 = {
+        'classification': np.random.randint(0, 10, points),  # Different classification
+        'intensity': dimensions1['intensity'],  # Same intensity
+    }
+    file2 = create_test_las_file(x, y, z, dimensions2)
+    
+    try:
+        # Test full comparison (should be different)
+        result = compare_las_dimensions(file1, file2)
+        assert result is False, "Files with different dimensions should return False"
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+def test_one_empty_file():
+    """Test that one empty file returns False"""
+    points = 100
+    x = np.random.rand(points) * 1000
+    y = np.random.rand(points) * 1000
+    z = np.random.rand(points) * 100
+    file1 = create_test_las_file(x, y, z)
+    file2 = create_test_las_file(np.array([]), np.array([]), np.array([]))
+    
+    try:
+        result = compare_las_dimensions(file1, file2)
+        assert result is False, "One empty file should return False"
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+def test_both_empty_files():
+    """Test that two empty files return True"""
+    file1 = create_test_las_file(np.array([]), np.array([]), np.array([]))
+    file2 = create_test_las_file(np.array([]), np.array([]), np.array([]))
+    
+    try:
+        result = compare_las_dimensions(file1, file2)
+        assert result is True, "Two empty files should return True"
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+def test_single_point():
+    """Test with single point files"""
+    points = 1
+    x = np.random.rand(points) * 1000
+    y = np.random.rand(points) * 1000
+    z = np.random.rand(points) * 100
+    dimensions = {
+        'classification': np.array([1]),
+        'intensity': np.array([100]),
+        'return_number': np.array([1])
+    }
+    file1 = create_test_las_file(x, y, z, dimensions)
+    file2 = create_test_las_file(x, y, z, dimensions)
+    
+    try:
+        result = compare_las_dimensions(file1, file2)
+        assert result is True, "Single point files with same dimensions should return True"
+    finally:
+        # Clean up
+        file1.unlink()
+        file2.unlink()
+
+def test_main_function():
+    """Test the main function with direct sys.argv"""
+    import sys
+    from io import StringIO
+    from contextlib import redirect_stdout
+    
+    # Test with identical files
+    points = 100
+    x = np.random.rand(points) * 1000
+    y = np.random.rand(points) * 1000
+    z = np.random.rand(points) * 100
+    classification = np.random.randint(0, 10, points)
+    
+    file1 = create_test_las_file(x, y, z, {'classification': classification})
+    file2 = create_test_las_file(x, y, z, {'classification': classification})
+    file3 = create_test_las_file(x, y, z, {'classification': classification + 1})  # Different classification
+
+    try:
+        # Test with identical files
+        sys.argv = ['script_name', str(file1), str(file2)]
+        with redirect_stdout(StringIO()) as f:
+            result = main()
+            assert result is True
+        
+        sys.argv = ['script_name', str(file1), str(file2), '--dimensions', 'classification']
+        with redirect_stdout(StringIO()) as f:
+            result = main()
+            assert result is True
+
+        sys.argv = ['script_name', str(file1), str(file2), '--dimensions', 'classification', 'intensity']
+        with redirect_stdout(StringIO()) as f:
+            result = main()
+            assert result is True
+
+        # Test with different files
+        sys.argv = ['script_name', str(file1), str(file3)]
+        with redirect_stdout(StringIO()) as f:
+            result = main()
+            assert result is False
+        
+    finally:
+        # Clean up
+        for f in [file1, file2, file3]:
+            if f.exists():
+                f.unlink()
+
+if __name__ == "__main__":
+    pytest.main()