249 lines
7.4 KiB
Python
249 lines
7.4 KiB
Python
"""ADR-117 P2 tests — BoundingBox + PersonPose + PoseEstimate bindings.
|
|
|
|
Run with: cd python && .venv/Scripts/python -m pytest tests/test_pose.py -v
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import pytest
|
|
|
|
from wifi_densepose import (
|
|
BoundingBox,
|
|
Keypoint,
|
|
KeypointType,
|
|
PersonPose,
|
|
PoseEstimate,
|
|
)
|
|
|
|
|
|
# ─── BoundingBox ─────────────────────────────────────────────────────
|
|
|
|
|
|
def test_bounding_box_construct() -> None:
|
|
bb = BoundingBox(0.1, 0.2, 0.5, 0.7)
|
|
assert bb.x_min == pytest.approx(0.1)
|
|
assert bb.y_min == pytest.approx(0.2)
|
|
assert bb.x_max == pytest.approx(0.5)
|
|
assert bb.y_max == pytest.approx(0.7)
|
|
|
|
|
|
def test_bounding_box_dimensions() -> None:
|
|
bb = BoundingBox(0.0, 0.0, 4.0, 3.0)
|
|
assert bb.width == pytest.approx(4.0)
|
|
assert bb.height == pytest.approx(3.0)
|
|
assert bb.area == pytest.approx(12.0)
|
|
assert bb.center == pytest.approx((2.0, 1.5))
|
|
|
|
|
|
def test_bounding_box_from_center() -> None:
|
|
bb = BoundingBox.from_center(2.0, 3.0, 4.0, 6.0)
|
|
assert bb.x_min == pytest.approx(0.0)
|
|
assert bb.y_min == pytest.approx(0.0)
|
|
assert bb.x_max == pytest.approx(4.0)
|
|
assert bb.y_max == pytest.approx(6.0)
|
|
|
|
|
|
def test_bounding_box_iou_no_overlap() -> None:
|
|
a = BoundingBox(0.0, 0.0, 1.0, 1.0)
|
|
b = BoundingBox(2.0, 2.0, 3.0, 3.0)
|
|
assert a.iou(b) == pytest.approx(0.0)
|
|
|
|
|
|
def test_bounding_box_iou_full_overlap() -> None:
|
|
a = BoundingBox(0.0, 0.0, 1.0, 1.0)
|
|
b = BoundingBox(0.0, 0.0, 1.0, 1.0)
|
|
assert a.iou(b) == pytest.approx(1.0)
|
|
|
|
|
|
def test_bounding_box_iou_partial() -> None:
|
|
a = BoundingBox(0.0, 0.0, 10.0, 10.0)
|
|
b = BoundingBox(5.0, 5.0, 15.0, 15.0)
|
|
# intersection 25, union 175 → 1/7
|
|
assert a.iou(b) == pytest.approx(25.0 / 175.0)
|
|
|
|
|
|
def test_bounding_box_eq() -> None:
|
|
assert BoundingBox(1, 2, 3, 4) == BoundingBox(1, 2, 3, 4)
|
|
assert BoundingBox(1, 2, 3, 4) != BoundingBox(1, 2, 3, 5)
|
|
|
|
|
|
def test_bounding_box_repr() -> None:
|
|
bb = BoundingBox(0.1, 0.2, 0.5, 0.7)
|
|
assert "BoundingBox" in repr(bb)
|
|
assert "x_min=0.1" in repr(bb)
|
|
|
|
|
|
# ─── PersonPose ──────────────────────────────────────────────────────
|
|
|
|
|
|
def test_person_pose_empty() -> None:
|
|
p = PersonPose()
|
|
assert p.id is None
|
|
assert p.visible_keypoint_count == 0
|
|
assert p.bounding_box is None
|
|
assert p.confidence == 0.0
|
|
|
|
|
|
def test_person_pose_set_get_keypoint() -> None:
|
|
p = PersonPose()
|
|
kp = Keypoint(KeypointType.Nose, 0.5, 0.3, 0.95)
|
|
p.set_keypoint(kp)
|
|
got = p.get_keypoint(KeypointType.Nose)
|
|
assert got is not None
|
|
assert got.x == pytest.approx(0.5)
|
|
assert got.confidence == pytest.approx(0.95)
|
|
|
|
|
|
def test_person_pose_get_missing_returns_none() -> None:
|
|
p = PersonPose()
|
|
p.set_keypoint(Keypoint(KeypointType.Nose, 0.5, 0.3, 0.95))
|
|
assert p.get_keypoint(KeypointType.LeftWrist) is None
|
|
|
|
|
|
def test_person_pose_visible_count() -> None:
|
|
p = PersonPose()
|
|
p.set_keypoint(Keypoint(KeypointType.Nose, 0.0, 0.0, 0.9)) # visible
|
|
p.set_keypoint(Keypoint(KeypointType.LeftEar, 0.0, 0.0, 0.2)) # invisible
|
|
p.set_keypoint(Keypoint(KeypointType.RightEar, 0.0, 0.0, 0.8)) # visible
|
|
assert p.visible_keypoint_count == 2
|
|
|
|
|
|
def test_person_pose_visible_keypoints_list() -> None:
|
|
p = PersonPose()
|
|
p.set_keypoint(Keypoint(KeypointType.Nose, 0.0, 0.0, 0.9))
|
|
p.set_keypoint(Keypoint(KeypointType.LeftEar, 0.0, 0.0, 0.2))
|
|
vis = p.visible_keypoints()
|
|
assert len(vis) == 1
|
|
assert vis[0].keypoint_type == KeypointType.Nose
|
|
|
|
|
|
def test_person_pose_keypoints_dict_excludes_missing() -> None:
|
|
p = PersonPose()
|
|
p.set_keypoint(Keypoint(KeypointType.Nose, 0.0, 0.0, 0.9))
|
|
p.set_keypoint(Keypoint(KeypointType.LeftWrist, 0.5, 0.5, 0.6))
|
|
d = p.keypoints()
|
|
assert KeypointType.Nose in d
|
|
assert KeypointType.LeftWrist in d
|
|
assert KeypointType.RightAnkle not in d
|
|
assert len(d) == 2
|
|
|
|
|
|
def test_person_pose_set_id() -> None:
|
|
p = PersonPose()
|
|
p.set_id(7)
|
|
assert p.id == 7
|
|
|
|
|
|
def test_person_pose_set_bounding_box() -> None:
|
|
p = PersonPose()
|
|
bb = BoundingBox(0.1, 0.1, 0.5, 0.9)
|
|
p.set_bounding_box(bb)
|
|
assert p.bounding_box == bb
|
|
|
|
|
|
def test_person_pose_compute_bbox_returns_none_when_empty() -> None:
|
|
p = PersonPose()
|
|
assert p.compute_bounding_box() is None
|
|
|
|
|
|
def test_person_pose_compute_bbox_from_keypoints() -> None:
|
|
p = PersonPose()
|
|
p.set_keypoint(Keypoint(KeypointType.Nose, 0.0, 0.0, 0.95))
|
|
p.set_keypoint(Keypoint(KeypointType.RightAnkle, 1.0, 2.0, 0.95))
|
|
bb = p.compute_bounding_box()
|
|
assert bb is not None
|
|
# bbox should span both keypoints
|
|
assert bb.x_min <= 0.0
|
|
assert bb.y_min <= 0.0
|
|
assert bb.x_max >= 1.0
|
|
assert bb.y_max >= 2.0
|
|
# also stored
|
|
assert p.bounding_box is not None
|
|
|
|
|
|
def test_person_pose_set_confidence_validation() -> None:
|
|
p = PersonPose()
|
|
p.set_confidence(0.85)
|
|
assert p.confidence == pytest.approx(0.85)
|
|
with pytest.raises(ValueError):
|
|
p.set_confidence(1.5)
|
|
|
|
|
|
def test_person_pose_repr() -> None:
|
|
p = PersonPose()
|
|
p.set_id(3)
|
|
p.set_keypoint(Keypoint(KeypointType.Nose, 0.0, 0.0, 0.9))
|
|
r = repr(p)
|
|
assert "PersonPose" in r
|
|
assert "id=Some(3)" in r or "id=3" in r
|
|
|
|
|
|
# ─── PoseEstimate ────────────────────────────────────────────────────
|
|
|
|
|
|
def test_pose_estimate_construct_empty() -> None:
|
|
e = PoseEstimate([], 0.5, 1.0, "test-v0")
|
|
assert e.person_count == 0
|
|
assert not e.has_detections
|
|
assert e.confidence == pytest.approx(0.5)
|
|
assert e.latency_ms == pytest.approx(1.0)
|
|
assert e.model_version == "test-v0"
|
|
|
|
|
|
def test_pose_estimate_construct_with_persons() -> None:
|
|
p1 = PersonPose()
|
|
p1.set_id(1)
|
|
p1.set_confidence(0.8)
|
|
p2 = PersonPose()
|
|
p2.set_id(2)
|
|
p2.set_confidence(0.9)
|
|
e = PoseEstimate([p1, p2], 0.85, 5.2, "v0.7.0")
|
|
assert e.person_count == 2
|
|
assert e.has_detections
|
|
assert e.confidence == pytest.approx(0.85)
|
|
|
|
|
|
def test_pose_estimate_highest_confidence_person() -> None:
|
|
p1 = PersonPose()
|
|
p1.set_confidence(0.5)
|
|
p2 = PersonPose()
|
|
p2.set_confidence(0.95)
|
|
p3 = PersonPose()
|
|
p3.set_confidence(0.7)
|
|
e = PoseEstimate([p1, p2, p3], 0.85, 5.2, "v0.7.0")
|
|
best = e.highest_confidence_person()
|
|
assert best is not None
|
|
assert best.confidence == pytest.approx(0.95)
|
|
|
|
|
|
def test_pose_estimate_highest_confidence_returns_none_when_empty() -> None:
|
|
e = PoseEstimate([], 0.5, 1.0, "test")
|
|
assert e.highest_confidence_person() is None
|
|
|
|
|
|
def test_pose_estimate_metadata_strings_nonempty() -> None:
|
|
e = PoseEstimate([], 0.5, 1.0, "test")
|
|
assert isinstance(e.id, str)
|
|
assert isinstance(e.timestamp, str)
|
|
assert e.id # non-empty
|
|
assert e.timestamp # non-empty
|
|
|
|
|
|
def test_pose_estimate_confidence_validation() -> None:
|
|
with pytest.raises(ValueError):
|
|
PoseEstimate([], 1.5, 0.0, "test")
|
|
|
|
|
|
def test_pose_estimate_repr_contains_counts() -> None:
|
|
e = PoseEstimate([], 0.5, 2.3, "v0.7.0")
|
|
r = repr(e)
|
|
assert "PoseEstimate" in r
|
|
assert "v0.7.0" in r
|
|
|
|
|
|
def test_build_features_marks_p2_complete() -> None:
|
|
import wifi_densepose
|
|
|
|
assert "p2-keypoint-bindings" in wifi_densepose.__build_features__
|
|
assert "p2-pose-bindings" in wifi_densepose.__build_features__
|