@camera.ui/server 0.0.50-internal.0 → 0.0.50-internal.2

package/src/camera/python/test/polygon.py

@@ -1,238 +0,0 @@
-from typing import Literal, TypedDict
-
-from typing_extensions import NotRequired
-
-Point = tuple[float, float]
-BoundingBox = tuple[float, float, float, float]
-
-
-class Detection(TypedDict):
-    id: NotRequired[str]
-    label: str
-    confidence: float
-    boundingBox: BoundingBox
-    inputWidth: int
-    inputHeight: int
-    origWidth: int
-    origHeight: int
-
-
-ZoneType = Literal["intersect", "contain"]
-ZoneFilter = Literal["include", "exclude"]
-
-
-class DetectionZone(TypedDict):
-    name: str
-    points: list[Point]
-    type: ZoneType
-    filter: ZoneFilter
-    classes: list[str]
-    isPrivacyMask: bool
-
-
-class MotionDetectionSettings(TypedDict):
-    timeout: int
-
-
-class ObjectDetectionSettings(TypedDict):
-    confidence: float
-
-
-class CameraDetectionSettings(TypedDict):
-    motion: MotionDetectionSettings
-    object: ObjectDetectionSettings
-
-
-def points_equal(p1: Point, p2: Point) -> bool:
-    return p1[0] == p2[0] and p1[1] == p2[1]
-
-
-def is_point_in_polygon(point: Point, polygon: list[Point]) -> bool:
-    x, y = point
-    inside = False
-
-    for i in range(len(polygon)):
-        j = (i + 1) % len(polygon)
-        xi, yi = polygon[i]
-        xj, yj = polygon[j]
-
-        # Check if the point is on the line
-        if (min(xi, xj) <= x <= max(xi, xj)) and (min(yi, yj) <= y <= max(yi, yj)):
-            # For vertical lines
-            if abs(xi - xj) < 1e-10 and abs(x - xi) < 1e-10:
-                return True
-            # For non-vertical lines
-            if abs(xi - xj) > 1e-10:
-                m = (yj - yi) / (xj - xi)
-                b = yi - m * xi
-                if abs(y - (m * x + b)) < 1e-10:
-                    return True
-
-        # Original Ray-Casting Algorithm
-        if ((yi > y) != (yj > y)) and (x < (xj - xi) * (y - yi) / (yj - yi) + xi):
-            inside = not inside
-
-    return inside
-
-
-def is_box_contained_in_polygon(box: BoundingBox, polygon: list[Point]) -> bool:
-    corners: list[Point] = [
-        (box[0], box[1]),  # Top-left
-        (box[2], box[1]),  # Top-right
-        (box[2], box[3]),  # Bottom-right
-        (box[0], box[3]),  # Bottom-left
-    ]
-
-    return all(is_point_in_polygon(point, polygon) for point in corners)
-
-
-def do_lines_intersect(a1: Point, a2: Point, b1: Point, b2: Point) -> bool:
-    denominator = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1])
-    if denominator == 0:
-        return False
-
-    ua = ((b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0])) / denominator
-    ub = ((a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0])) / denominator
-
-    return 0 <= ua <= 1 and 0 <= ub <= 1
-
-
-def do_polygons_intersect(box: BoundingBox, polygon: list[Point]) -> bool:
-    box_polygon: list[Point] = [
-        (box[0], box[1]),  # Top-left
-        (box[2], box[1]),  # Top-right
-        (box[2], box[3]),  # Bottom-right
-        (box[0], box[3]),  # Bottom-left
-        (box[0], box[1]),  # Close the polygon
-    ]
-
-    # Check if any point of one polygon is inside the other
-    if any(is_point_in_polygon(point, polygon) for point in box_polygon):
-        return True
-
-    if any(
-        point[0] >= box[0] and point[0] <= box[2] and point[1] >= box[1] and point[1] <= box[3]
-        for point in polygon
-    ):
-        return True
-
-    # Check if any lines intersect
-    return any(
-        do_lines_intersect(box_polygon[i], box_polygon[i + 1], polygon[j], polygon[j + 1])
-        for i in range(len(box_polygon) - 1)
-        for j in range(len(polygon) - 1)
-    )
-
-
-def convert_zone_points_to_pixels(zone: DetectionZone, detection: Detection) -> DetectionZone:
-    orig_width, orig_height = detection["origWidth"], detection["origHeight"]
-    converted_points = [(x * orig_width / 100, y * orig_height / 100) for x, y in zone["points"]]
-
-    if converted_points and not points_equal(converted_points[0], converted_points[-1]):
-        converted_points.append(converted_points[0])
-
-    return {
-        **zone,
-        "points": converted_points,
-    }
-
-
-def convert_bounding_box_to_pixels(detection: Detection) -> Detection:
-    orig_width = detection["origWidth"]
-    orig_height = detection["origHeight"]
-    input_width = detection["inputWidth"]
-    input_height = detection["inputHeight"]
-    xmin, ymin, xmax, ymax = detection["boundingBox"]
-
-    xmin = (xmin * orig_width) / input_width
-    ymin = (ymin * orig_height) / input_height
-    xmax = (xmax * orig_width) / input_width
-    ymax = (ymax * orig_height) / input_height
-
-    xmin = max(0, min(xmin, orig_width))
-    ymin = max(0, min(ymin, orig_height))
-    xmax = max(0, min(xmax, orig_width))
-    ymax = max(0, min(ymax, orig_height))
-
-    return {
-        **detection,
-        "boundingBox": (xmin, ymin, xmax, ymax),
-    }
-
-
-def are_detections_valid(
-    detections: list[Detection], zones: list[DetectionZone], activity_settings: CameraDetectionSettings
-) -> list[Detection]:
-    if not zones:
-        return [d for d in detections if d["confidence"] >= activity_settings["object"]["confidence"]]
-
-    valid_detections: list[Detection] = []
-
-    for detection in detections:
-        if detection["confidence"] < activity_settings["object"]["confidence"]:
-            continue
-
-        converted_detection = convert_bounding_box_to_pixels(detection)
-
-        # Check privacy masks first - always contain/include
-        is_in_privacy_mask = False
-        for zone in zones:
-            if not zone["isPrivacyMask"]:
-                continue
-
-            converted_zone = convert_zone_points_to_pixels(zone, converted_detection)
-            if is_box_contained_in_polygon(converted_detection["boundingBox"], converted_zone["points"]):
-                is_in_privacy_mask = True
-                break
-
-        if is_in_privacy_mask:
-            continue
-
-        has_include_zone = False
-        is_valid = False
-        should_exclude = False  # Neue Variable für Exclude-Status
-
-        # Check regular zones
-        for zone in zones:
-            if zone["isPrivacyMask"]:
-                continue
-
-            # Class filter
-            if zone["classes"] and detection["label"] not in zone["classes"]:
-                continue
-
-            converted_zone = convert_zone_points_to_pixels(zone, converted_detection)
-            intersects = do_polygons_intersect(converted_detection["boundingBox"], converted_zone["points"])
-            contained = is_box_contained_in_polygon(
-                converted_detection["boundingBox"], converted_zone["points"]
-            )
-
-            if zone["filter"] == "include":
-                has_include_zone = True
-                if (zone["type"] == "contain" and contained) or (
-                    zone["type"] == "intersect" and (intersects or contained)
-                ):
-                    is_valid = True
-                    break
-            else:  # exclude
-                if detection["label"] in zone["classes"]:  # noqa: SIM102
-                    if (zone["type"] == "contain" and contained) or (
-                        zone["type"] == "intersect" and (intersects or contained)
-                    ):
-                        should_exclude = True
-                        break
-
-        # If the detection should be excluded, skip it
-        if should_exclude:
-            continue
-
-        # If there are no include zones, the detection is valid (as it wasn't excluded)
-        if not has_include_zone:
-            valid_detections.append(detection)
-            continue
-
-        # If there are include zones, at least one must match
-        if is_valid:
-            valid_detections.append(detection)
-
-    return valid_detections

package/src/camera/python/test/polygon_test.py

@@ -1,256 +0,0 @@
-import time
-from typing import Any, Literal, TypedDict, cast
-
-from polygon import are_detections_valid
-from typing_extensions import NotRequired
-
-Point = tuple[float, float]
-BoundingBox = tuple[float, float, float, float]
-
-
-class Detection(TypedDict):
-    id: NotRequired[str]
-    label: str
-    confidence: float
-    boundingBox: BoundingBox
-    inputWidth: int
-    inputHeight: int
-    origWidth: int
-    origHeight: int
-
-
-ZoneType = Literal["intersect", "contain"]
-ZoneFilter = Literal["include", "exclude"]
-
-
-class DetectionZone(TypedDict):
-    name: str
-    points: list[Point]
-    type: ZoneType
-    filter: ZoneFilter
-    classes: list[str]
-    isPrivacyMask: bool
-
-
-class MotionDetectionSettings(TypedDict):
-    timeout: int
-
-
-class ObjectDetectionSettings(TypedDict):
-    confidence: float
-
-
-class CameraDetectionSettings(TypedDict):
-    motion: MotionDetectionSettings
-    object: ObjectDetectionSettings
-
-
-class TestCase(TypedDict):
-    name: str
-    detections: list[Detection]
-    zones: list[DetectionZone]
-    expectedValid: int
-
-
-# Test settings
-default_settings: CameraDetectionSettings = {
-    "motion": {
-        "timeout": 20,
-    },
-    "object": {
-        "confidence": 0.7,
-    },
-}
-
-
-def create_detection(
-    label: str,
-    confidence: float,
-    bounding_box: tuple[float, float, float, float],
-    width: int = 1920,
-    height: int = 1080,
-) -> Detection:
-    return {
-        "label": cast(Any, label),
-        "confidence": confidence,
-        "boundingBox": bounding_box,
-        "inputWidth": width,
-        "inputHeight": height,
-        "origWidth": width,
-        "origHeight": height,
-    }
-
-
-test_cases: list[TestCase] = [
-    {
-        "name": "Full Image Test",
-        "detections": [
-            create_detection("motion", 1, (0, 0, 1920, 1080)),  # Full image
-        ],
-        "zones": [
-            {
-                "name": "Full Image",
-                "points": [
-                    (0, 0),
-                    (0, 100),
-                    (100, 100),
-                    (100, 0),
-                    (0, 0),
-                ],
-                "type": "contain",
-                "filter": "include",
-                "classes": ["motion"],
-                "isPrivacyMask": False,
-            }
-        ],
-        "expectedValid": 1,
-    },
-    {
-        "name": "Simple Include Zone Test",
-        "detections": [
-            create_detection("person", 0.8, (100, 100, 200, 200)),  # Inside zone (first 25%)
-            create_detection("person", 0.9, (500, 500, 600, 600)),  # Outside zone
-        ],
-        "zones": [
-            {
-                "name": "Include Zone",
-                # 0-25% of the image
-                "points": [
-                    (0, 0),  # 0% x, 0% y
-                    (25, 0),  # 25% x, 0% y
-                    (25, 25),  # 25% x, 25% y
-                    (0, 25),  # 0% x, 25% y
-                    (0, 0),  # back to start
-                ],
-                "type": "contain",
-                "filter": "include",
-                "classes": ["person"],
-                "isPrivacyMask": False,
-            },
-        ],
-        "expectedValid": 1,
-    },
-    {
-        "name": "Multiple Zones Test",
-        "detections": [
-            create_detection("person", 0.8, (100, 100, 200, 200)),  # In person zone
-            create_detection("car", 0.9, (300, 300, 400, 400)),  # In vehicle zone
-            create_detection("bike", 0.7, (500, 500, 600, 600)),  # Outside both zones
-        ],
-        "zones": [
-            {
-                "name": "Person Zone",
-                "points": [
-                    (0, 0),
-                    (20, 0),  # 20% of width
-                    (20, 20),  # 20% of height
-                    (0, 20),
-                    (0, 0),
-                ],
-                "type": "contain",
-                "filter": "include",
-                "classes": ["person"],
-                "isPrivacyMask": False,
-            },
-            {
-                "name": "Vehicle Zone",
-                "points": [
-                    (15, 15),
-                    (35, 15),  # 15-35% width
-                    (35, 35),  # 15-35% height
-                    (15, 35),
-                    (15, 15),
-                ],
-                "type": "intersect",
-                "filter": "include",
-                "classes": ["car", "bike"],  # type: ignore
-                "isPrivacyMask": False,
-            },
-        ],
-        "expectedValid": 2,
-    },
-    {
-        "name": "Privacy Mask Test",
-        "detections": [
-            create_detection("person", 0.95, (100, 100, 200, 200)),  # In privacy mask
-            create_detection("person", 0.9, (800, 800, 900, 900)),  # Outside privacy mask
-        ],
-        "zones": [
-            {
-                "name": "Privacy Area",
-                "points": [
-                    (0, 0),
-                    (20, 0),  # 20% width
-                    (20, 20),  # 20% height
-                    (0, 20),
-                    (0, 0),
-                ],
-                "type": "intersect",
-                "filter": "include",
-                "classes": [],
-                "isPrivacyMask": True,
-            },
-        ],
-        "expectedValid": 1,
-    },
-    {
-        "name": "Exclude Zone Test",
-        "detections": [
-            create_detection("person", 0.9, (100, 100, 200, 200)),  # In exclude zone
-            create_detection("person", 0.9, (500, 500, 600, 600)),  # Outside exclude zone
-        ],
-        "zones": [
-            {
-                "name": "Exclude Zone",
-                "points": [
-                    (0, 0),
-                    (20, 0),  # 20% width
-                    (20, 20),  # 20% height
-                    (0, 20),
-                    (0, 0),
-                ],
-                "type": "contain",
-                "filter": "exclude",
-                "classes": ["person"],
-                "isPrivacyMask": False,
-            },
-        ],
-        "expectedValid": 1,
-    },
-]
-
-
-def validate_results(test_case: TestCase, valid_detections: list[Detection]) -> bool:
-    passed = len(valid_detections) == test_case["expectedValid"]
-    print(f"Test {'✅ PASSED' if passed else '❌ FAILED'}")
-    print(f"Expected {test_case['expectedValid']} valid detections, got {len(valid_detections)}")
-    return passed
-
-
-# Run tests
-print("Running Detection Zone Tests\n")
-
-passed_tests = 0
-for test_case in test_cases:
-    print(f"Test Case: {test_case['name']}")
-    print("------------------------")
-
-    start_time = time.perf_counter()
-    valid_detections = are_detections_valid(test_case["detections"], test_case["zones"], default_settings)
-    end_time = time.perf_counter()
-    print(f"{test_case['name']} execution time: {((end_time - start_time) * 1000):.3f}ms")
-
-    if validate_results(test_case, valid_detections):
-        passed_tests += 1
-
-    print("\nValid Detections:")
-    for i, detection in enumerate(valid_detections, 1):
-        print(f"{i}. {detection['label']} (confidence: {detection['confidence']})")
-        print(f"   Bounding Box: [{', '.join(map(str, detection['boundingBox']))}]")
-
-    print("\n")
-
-print(f"Test Summary: {passed_tests}/{len(test_cases)} tests passed\n")
-
-if __name__ == "__main__":
-    pass