make message more ambiguous

Author: jonhealy1

stac_check/lint.py

@@ -554,15 +554,22 @@ def check_catalog_file_name(self) -> bool:
             return True
 
     def check_geometry_coordinates_order(self) -> bool:
-        """Checks if the coordinates in a geometry are in the correct order (longitude, latitude).
+        """Checks if the coordinates in a geometry may be in the incorrect order.
 
-        This function verifies that coordinates follow the GeoJSON specification where positions are in
-        [longitude, latitude] order. It detects cases where coordinates might be accidentally reversed
-        by checking if latitude values (which should be the second element in each coordinate pair)
-        are within the valid range of -90 to 90 degrees.
+        This function attempts to detect cases where coordinates might not follow the GeoJSON
+        specification where positions should be in [longitude, latitude] order. It uses several
+        heuristics to identify potentially problematic coordinates:
+
+        1. Checks if latitude values (second element) exceed ±90 degrees
+        2. Checks if longitude values (first element) exceed ±180 degrees
+        3. Uses a heuristic to detect when coordinates are likely reversed
+           (when first value > 90, second value < 90, and first value > second value*2)
+
+        Note that this check can never definitively determine if coordinates are reversed
+        or simply contain errors, it can only flag suspicious patterns.
 
         Returns:
-            bool: True if coordinates appear to be in the correct order, False if they seem reversed.
+            bool: True if coordinates appear to be in the expected order, False if they may be reversed.
         """
         if "geometry" not in self.data or self.data["geometry"] is None:
             return True
@@ -577,15 +584,19 @@ def is_valid_coordinate(coord):
             lon, lat = coord[0], coord[1]
 
             # Check if latitude (second value) is outside the valid range
-            # This could indicate reversed coordinates
             if abs(lat) > 90:
                 return False
 
             # Check if longitude (first value) is outside the valid range
-            # This is another indicator of possible coordinate reversal
             if abs(lon) > 180:
                 return False
 
+            # Additional heuristic for likely reversed coordinates
+            # If the first value (supposed longitude) is > 90, second value (supposed latitude) is < 90,
+            # and first value is significantly larger than second value, they may be reversed
+            if abs(lon) > 90 and abs(lat) < 90 and abs(lon) > abs(lat) * 2:
+                return False
+
             return True
 
         # Function to recursively check all coordinates in a geometry
@@ -706,7 +717,7 @@ def create_best_practices_dict(self) -> Dict:
             not self.check_geometry_coordinates_order()
             and config["geometry_coordinates_order"] == True
         ):
-            msg_1 = "Geometry coordinates should be in the correct order (longitude, latitude)"
+            msg_1 = "Geometry coordinates may be reversed or contain errors (expected order: longitude, latitude)"
             best_practices_dict["geometry_coordinates_order"] = [msg_1]
 
         return best_practices_dict

tests/test_lint.py

@@ -639,23 +639,51 @@ def test_geometry_coordinates_order():
         "properties": {"datetime": "2023-01-01T00:00:00Z"},
     }
 
+    # Create a test item with coordinates that may be reversed based on heuristic
+    # (first value > 90, second value < 90, first value > second value*2)
+    heuristic_incorrect_item = {
+        "stac_version": "1.0.0",
+        "stac_extensions": [],
+        "type": "Feature",
+        "id": "test-coordinates-heuristic-incorrect",
+        "bbox": [10.0, -10.0, 20.0, 10.0],
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    [120.0, 40.0],  # First value > 90, second < 90, first > second*2
+                    [120.0, 40.0],
+                    [120.0, 40.0],
+                    [120.0, 40.0],
+                    [120.0, 40.0],
+                ]
+            ],
+        },
+        "properties": {"datetime": "2023-01-01T00:00:00Z"},
+    }
+
     # Test with correct coordinates - this should pass
     linter = Linter(correct_item)
     assert linter.check_geometry_coordinates_order() == True
 
-    # Test with incorrect coordinates - this should fail
+    # Test with incorrect coordinates that are within valid ranges
+    # This will now fail with our enhanced heuristic
     linter = Linter(incorrect_item)
     assert (
         linter.check_geometry_coordinates_order() == True
-    )  # This will still pass because values are within valid ranges
+    )  # Still passes as values are within valid ranges
 
     # Test with clearly incorrect coordinates - this should fail
     linter = Linter(clearly_incorrect_item)
     assert linter.check_geometry_coordinates_order() == False
 
+    # Test with coordinates that trigger the heuristic - this should fail
+    linter = Linter(heuristic_incorrect_item)
+    assert linter.check_geometry_coordinates_order() == False
+
     # Test that the best practices dictionary contains the error message
     best_practices = linter.create_best_practices_dict()
     assert "geometry_coordinates_order" in best_practices
     assert best_practices["geometry_coordinates_order"] == [
-        "Geometry coordinates should be in the correct order (longitude, latitude)"
+        "Geometry coordinates may be reversed or contain errors (expected order: longitude, latitude)"
     ]