Spaces:
Sleeping
Sleeping
| """Tests for geometry/normalization.py — format conversions.""" | |
| from __future__ import annotations | |
| import pytest | |
| from src.app.geometry import normalization | |
| class TestXyxyToXywh: | |
| def test_normal(self) -> None: | |
| result = normalization.xyxy_to_xywh((10, 20, 110, 70)) | |
| assert result == (10, 20, 100, 50) | |
| def test_swapped_coords(self) -> None: | |
| """Some providers may swap x1/x2 or y1/y2 — we handle it.""" | |
| result = normalization.xyxy_to_xywh((110, 70, 10, 20)) | |
| assert result == (10, 20, 100, 50) | |
| def test_zero_size(self) -> None: | |
| result = normalization.xyxy_to_xywh((10, 10, 10, 10)) | |
| assert result == (10, 10, 0, 0) | |
| class TestXywhToXyxy: | |
| def test_normal(self) -> None: | |
| result = normalization.xywh_to_xyxy((10, 20, 100, 50)) | |
| assert result == (10, 20, 110, 70) | |
| def test_roundtrip(self) -> None: | |
| original = (10, 20, 110, 70) | |
| xywh = normalization.xyxy_to_xywh(original) | |
| back = normalization.xywh_to_xyxy(xywh) | |
| assert back == original | |
| class TestCxcywhToXywh: | |
| def test_normal(self) -> None: | |
| result = normalization.cxcywh_to_xywh((50, 50, 100, 80)) | |
| assert result == (0, 10, 100, 80) | |
| def test_roundtrip(self) -> None: | |
| original = (10, 20, 100, 50) | |
| cxcywh = normalization.xywh_to_cxcywh(original) | |
| back = normalization.cxcywh_to_xywh(cxcywh) | |
| assert back == pytest.approx(original) | |
| class TestFourPointToXywh: | |
| def test_axis_aligned(self) -> None: | |
| points = [[100, 200], [400, 200], [400, 250], [100, 250]] | |
| result = normalization.four_point_to_xywh(points) | |
| assert result == (100, 200, 300, 50) | |
| def test_rotated_quad(self) -> None: | |
| # Slightly rotated — bbox is the enclosing axis-aligned box | |
| points = [[98, 205], [402, 195], [404, 245], [100, 255]] | |
| result = normalization.four_point_to_xywh(points) | |
| assert result[0] == 98 # min x | |
| assert result[1] == 195 # min y | |
| assert result[2] == pytest.approx(306) # max_x - min_x | |
| assert result[3] == pytest.approx(60) # max_y - min_y | |
| def test_tuples(self) -> None: | |
| points = [(0, 0), (10, 0), (10, 10), (0, 10)] | |
| result = normalization.four_point_to_xywh(points) | |
| assert result == (0, 0, 10, 10) | |
| def test_wrong_count(self) -> None: | |
| with pytest.raises(ValueError, match="4 points"): | |
| normalization.four_point_to_xywh([[0, 0], [1, 1]]) | |
| class TestFourPointToPolygon: | |
| def test_normal(self) -> None: | |
| points = [[100, 200], [400, 200], [400, 250], [100, 250]] | |
| result = normalization.four_point_to_polygon(points) | |
| assert result == [(100, 200), (400, 200), (400, 250), (100, 250)] | |
| def test_wrong_count(self) -> None: | |
| with pytest.raises(ValueError, match="4 points"): | |
| normalization.four_point_to_polygon([[0, 0]]) | |
| class TestNormalizedBbox: | |
| def test_to_pixels(self) -> None: | |
| result = normalization.normalize_bbox_to_pixels( | |
| (0.1, 0.2, 0.5, 0.3), 1000, 2000 | |
| ) | |
| assert result == (100, 400, 500, 600) | |
| def test_to_normalized(self) -> None: | |
| result = normalization.pixels_to_normalized_bbox( | |
| (100, 400, 500, 600), 1000, 2000 | |
| ) | |
| assert result == (0.1, 0.2, 0.5, 0.3) | |
| def test_zero_image_rejected(self) -> None: | |
| with pytest.raises(ValueError, match="must be > 0"): | |
| normalization.pixels_to_normalized_bbox((0, 0, 10, 10), 0, 100) | |
| def test_roundtrip(self) -> None: | |
| original = (50, 100, 200, 300) | |
| norm = normalization.pixels_to_normalized_bbox(original, 1000, 2000) | |
| back = normalization.normalize_bbox_to_pixels(norm, 1000, 2000) | |
| assert back == pytest.approx(original) | |