flowchart LR
    GEN["Синтетичний BGR-кадр"] --> HSV["BGR → HSV / gray"]
    HSV --> MASK["Порогові маски кольору"]
    MASK --> MORPH["Opening + closing"]
    MORPH --> CONT["Контур і моменти"]
    CONT --> FEAT["Площа, центр, vertices, circularity, solidity"]
    FEAT --> GATE{"Усі пороги пройдено?"}
    GATE -->|так| CLASS["Кандидат cube/cylinder"]
    GATE -->|ні| UNKNOWN["UNKNOWN"]

# safe-smoke
from dataclasses import dataclass

@dataclass(frozen=True)
class Features:
    area: float
    color_score: float
    shape_score: float

def decide(f: Features) -> str:
    values = (f.area, f.color_score, f.shape_score)
    if any(value != value for value in values):
        return "UNKNOWN"
    if f.area < 500 or f.color_score < 0.70 or f.shape_score < 0.70:
        return "UNKNOWN"
    return "KNOWN"

assert decide(Features(1200, 0.90, 0.85)) == "KNOWN"
assert decide(Features(499, 0.99, 0.99)) == "UNKNOWN"
assert decide(Features(1200, 0.69, 0.99)) == "UNKNOWN"
assert decide(Features(float("nan"), 0.99, 0.99)) == "UNKNOWN"
print("safe-smoke: UNKNOWN policy PASS")

{
  "min_area": 500.0,
  "min_color_score": 0.70,
  "min_shape_score": 0.70,
  "morph_kernel": 5,
  "red_ranges": [[[0, 120, 80], [10, 255, 255]], [[170, 120, 80], [179, 255, 255]]],
  "blue_ranges": [[[100, 120, 80], [130, 255, 255]]]
}

from __future__ import annotations

import argparse
import json
import math
from dataclasses import asdict, dataclass
from pathlib import Path

import cv2
import numpy as np


@dataclass(frozen=True)
class Result:
    sample: str
    label: str
    reason: str
    confidence: float
    area: float
    circularity: float
    solidity: float
    vertices: int
    center_x: int | None
    center_y: int | None


def synthetic_samples() -> dict[str, np.ndarray]:
    def canvas() -> np.ndarray:
        return np.full((240, 320, 3), 245, dtype=np.uint8)

    red_cylinder = canvas()
    cv2.circle(red_cylinder, (160, 120), 48, (0, 0, 255), -1)
    blue_cube = canvas()
    cv2.rectangle(blue_cube, (112, 72), (208, 168), (255, 0, 0), -1)
    empty = canvas()
    tiny = canvas()
    cv2.circle(tiny, (160, 120), 8, (0, 0, 255), -1)
    ambiguous = canvas()
    cv2.rectangle(ambiguous, (105, 70), (160, 170), (0, 0, 255), -1)
    cv2.rectangle(ambiguous, (160, 70), (215, 170), (255, 0, 0), -1)
    border = canvas()
    cv2.circle(border, (8, 120), 48, (0, 0, 255), -1)
    return {
        "red-cylinder": red_cylinder,
        "blue-cube": blue_cube,
        "empty": empty,
        "tiny": tiny,
        "ambiguous": ambiguous,
        "border": border,
    }


def mask_ranges(hsv: np.ndarray, ranges: list[list[list[int]]]) -> np.ndarray:
    result = np.zeros(hsv.shape[:2], dtype=np.uint8)
    for low, high in ranges:
        result = cv2.bitwise_or(
            result,
            cv2.inRange(hsv, np.array(low, np.uint8), np.array(high, np.uint8)),
        )
    return result


def classify(name: str, image: np.ndarray, cfg: dict) -> tuple[Result, np.ndarray, np.ndarray]:
    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    red = mask_ranges(hsv, cfg["red_ranges"])
    blue = mask_ranges(hsv, cfg["blue_ranges"])
    combined = cv2.bitwise_or(red, blue)
    k = int(cfg["morph_kernel"])
    if k <= 0 or k % 2 == 0:
        raise ValueError("morph_kernel must be a positive odd integer")
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
    clean = cv2.morphologyEx(combined, cv2.MORPH_OPEN, kernel)
    clean = cv2.morphologyEx(clean, cv2.MORPH_CLOSE, kernel)
    contours, _ = cv2.findContours(clean, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    annotated = image.copy()
    if not contours:
        return Result(name, "UNKNOWN", "no-contour", 0.0, 0.0, 0.0, 0.0, 0, None, None), annotated, gray

    contour = max(contours, key=cv2.contourArea)
    area = float(cv2.contourArea(contour))
    perimeter = float(cv2.arcLength(contour, True))
    circularity = 0.0 if perimeter == 0 else 4.0 * math.pi * area / (perimeter * perimeter)
    hull_area = float(cv2.contourArea(cv2.convexHull(contour)))
    solidity = 0.0 if hull_area == 0 else area / hull_area
    approx = cv2.approxPolyDP(contour, 0.02 * perimeter, True)
    moments = cv2.moments(contour)
    cx = None if moments["m00"] == 0 else int(moments["m10"] / moments["m00"])
    cy = None if moments["m00"] == 0 else int(moments["m01"] / moments["m00"])

    contour_mask = np.zeros(clean.shape, dtype=np.uint8)
    cv2.drawContours(contour_mask, [contour], -1, 255, -1)
    pixels = max(1, cv2.countNonZero(contour_mask))
    red_score = cv2.countNonZero(cv2.bitwise_and(red, contour_mask)) / pixels
    blue_score = cv2.countNonZero(cv2.bitwise_and(blue, contour_mask)) / pixels
    color, color_score = max((("red", red_score), ("blue", blue_score)), key=lambda item: item[1])
    color_margin = abs(red_score - blue_score)

    # Спершу перевіряємо чотирикутник: circularity ідеального квадрата ≈ 0.785,
    # тому низький поріг кола без цього порядку помилково прийняв би квадрат.
    if len(approx) == 4 and solidity >= 0.90:
        shape, shape_score = "cube-candidate", min(1.0, solidity)
    elif circularity >= 0.82:
        shape, shape_score = "cylinder-candidate", min(1.0, circularity)
    else:
        shape, shape_score = "UNKNOWN", 0.0

    confidence = min(color_score, shape_score)
    touches_border = bool(
        np.any(contour[:, :, 0] <= 0)
        or np.any(contour[:, :, 1] <= 0)
        or np.any(contour[:, :, 0] >= image.shape[1] - 1)
        or np.any(contour[:, :, 1] >= image.shape[0] - 1)
    )
    gates = [
        (area >= float(cfg["min_area"]), "area-too-small"),
        (color_score >= float(cfg["min_color_score"]), "low-color-score"),
        (color_margin >= 0.20, "ambiguous-color"),
        (shape_score >= float(cfg["min_shape_score"]), "unknown-shape"),
        (not touches_border, "touches-border"),
        (cx is not None and cy is not None, "invalid-center"),
    ]
    failed = [reason for passed, reason in gates if not passed]
    label = "UNKNOWN" if failed else f"{color}-{shape}"
    reason = ",".join(failed) if failed else "accepted"
    cv2.drawContours(annotated, [contour], -1, (0, 180, 0), 2)
    cv2.putText(annotated, label, (8, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (30, 30, 30), 2)
    result = Result(name, label, reason, confidence, area, circularity, solidity, len(approx), cx, cy)
    return result, annotated, gray


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", type=Path, required=True)
    parser.add_argument("--out", type=Path, required=True)
    args = parser.parse_args()
    cfg = json.loads(args.config.read_text(encoding="utf-8"))
    args.out.mkdir(parents=True, exist_ok=True)
    results: list[Result] = []
    for name, image in synthetic_samples().items():
        result, annotated, gray = classify(name, image, cfg)
        results.append(result)
        cv2.imwrite(str(args.out / f"{name}-annotated.png"), annotated)
        cv2.imwrite(str(args.out / f"{name}-gray.png"), gray)
    labels = {result.sample: result.label for result in results}
    assert labels["red-cylinder"] == "red-cylinder-candidate"
    assert labels["blue-cube"] == "blue-cube-candidate"
    for sample in ("empty", "tiny", "ambiguous", "border"):
        assert labels[sample] == "UNKNOWN", (sample, labels[sample])
    (args.out / "metrics.json").write_text(
        json.dumps([asdict(result) for result in results], ensure_ascii=False, indent=2),
        encoding="utf-8",
    )
    print(f"PASS: {len(results)} synthetic samples; outputs={args.out}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

python lab16_cv.py --config lab16-config.json --out lab16-output

python -m json.tool lab16-output/metrics.json