Merge pull request #798 from mapillary/feature/null-island-check

Move null island check for images to a dedicated method.

Author: caglarpir

mapillary_tools/process_sequence_properties.py

@@ -146,6 +146,55 @@ def duplication_check(
     return dedups, dups
 
 
+def _check_null_island(
+    sequence: PointSequence,
+) -> tuple[PointSequence, list[types.ErrorMetadata]]:
+    """
+    Filter out images with null island (0, 0) GPS coordinates.
+
+    Returns:
+        Tuple of (valid images, error metadatas for null island images)
+    """
+    valid: PointSequence = []
+    errors: list[types.ErrorMetadata] = []
+
+    for image in sequence:
+        if image.lat == 0 and image.lon == 0:
+            ex = exceptions.MapillaryNullIslandError(
+                "GPS coordinates in Null Island (0, 0)"
+            )
+            errors.append(
+                types.describe_error_metadata(
+                    exc=ex, filename=image.filename, filetype=types.FileType.IMAGE
+                )
+            )
+        else:
+            valid.append(image)
+
+    return valid, errors
+
+
+def _check_sequences_null_island(
+    input_sequences: T.Sequence[PointSequence],
+) -> tuple[list[PointSequence], list[types.ErrorMetadata]]:
+    """Apply null island check to all sequences."""
+    output_sequences: list[PointSequence] = []
+    output_errors: list[types.ErrorMetadata] = []
+
+    for sequence in input_sequences:
+        output_sequence, errors = _check_null_island(sequence)
+        if output_sequence:
+            output_sequences.append(output_sequence)
+        output_errors.extend(errors)
+
+    if output_errors:
+        LOG.info(
+            f"Null island check: {len(output_errors)} images removed with (0, 0) coordinates"
+        )
+
+    return output_sequences, output_errors
+
+
 def _group_images_by(
     image_metadatas: T.Iterable[types.ImageMetadata],
     group_key_func: T.Callable[[types.ImageMetadata], T.Hashable],
@@ -310,14 +359,6 @@ def _check_sequences_by_limits(
                         f"Sequence file size {humanize.naturalsize(sequence_filesize)} exceeds max allowed {humanize.naturalsize(max_sequence_filesize_in_bytes)}",
                     )
 
-            contains_null_island = any(
-                image.lat == 0 and image.lon == 0 for image in sequence
-            )
-            if contains_null_island:
-                raise exceptions.MapillaryNullIslandError(
-                    "GPS coordinates in Null Island (0, 0)"
-                )
-
             avg_speed_kmh = geo.avg_speed(sequence) * 3.6  # Convert m/s to km/h
             too_fast = len(sequence) >= 2 and avg_speed_kmh > max_capture_speed_kmh
             if too_fast:
@@ -765,6 +806,10 @@ def process_sequence_properties(
             cutoff_time=cutoff_time,
         )
 
+        # Null island check
+        sequences, errors = _check_sequences_null_island(sequences)
+        error_metadatas.extend(errors)
+
         # Duplication check
         sequences, errors = _check_sequences_duplication(
             sequences,
@@ -789,7 +834,7 @@ def process_sequence_properties(
         error_metadatas.extend(errors)
 
         # Check for zig-zag GPS patterns
-        # NOTE: This is done after _check_sequences_by_limits to filter missing or zero coordinates
+        # NOTE: This is done after _check_sequences_null_island to filter zero coordinates
         if not skip_zigzag_check:
             sequences, errors = _check_sequences_zigzag(
                 sequences,

tests/unit/test_sequence_processing.py

@@ -713,6 +713,48 @@ def test_video_error(tmpdir: py.path.local):
     )
 
 
+def test_image_null_island(tmpdir: py.path.local):
+    """Test that only images with (0,0) coordinates get errors, not the whole sequence."""
+    curdir = tmpdir.mkdir("null_island_test")
+    sequence: T.List[types.MetadataOrError] = [
+        # Image at null island - should get error
+        _make_image_metadata(Path(curdir) / Path("null_island.jpg"), 0, 0, 1, angle=10),
+        # Valid images in same folder - should pass through
+        _make_image_metadata(
+            Path(curdir) / Path("valid1.jpg"), 1.00001, 1.00001, 2, angle=20
+        ),
+        _make_image_metadata(
+            Path(curdir) / Path("valid2.jpg"), 1.00002, 1.00002, 3, angle=30
+        ),
+    ]
+    metadatas = psp.process_sequence_properties(
+        sequence,
+        cutoff_distance=1000000,
+        cutoff_time=100,
+        interpolate_directions=False,
+        duplicate_distance=0.1,
+        duplicate_angle=5,
+    )
+    metadata_by_filename = {m.filename.name: m for m in metadatas}
+
+    # Null island image should have an error
+    assert isinstance(metadata_by_filename["null_island.jpg"], types.ErrorMetadata), (
+        "Null island image should be an ErrorMetadata"
+    )
+    assert isinstance(
+        metadata_by_filename["null_island.jpg"].error,
+        exceptions.MapillaryNullIslandError,
+    ), "Error should be MapillaryNullIslandError"
+
+    # Valid images should pass through as ImageMetadata
+    assert isinstance(metadata_by_filename["valid1.jpg"], types.ImageMetadata), (
+        "Valid image should pass through"
+    )
+    assert isinstance(metadata_by_filename["valid2.jpg"], types.ImageMetadata), (
+        "Valid image should pass through"
+    )
+
+
 def test_split_sequence_by_filesize(tmpdir):
     sequence: T.List[types.Metadata] = [
         # s1