Spaces:
Sleeping
Sleeping
File size: 6,637 Bytes
2d9a408 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | """
vision_model.py
-----------------
Visual Inventory & Rack Occupancy Scanner.
A deliberately different computer-vision approach from a YOLO-style deep
detector: a small, fully deterministic **classical image-processing
pipeline** (OpenCV: color-based background/shelf segmentation ->
morphological cleanup -> connected components -> geometric filtering) that
(a) counts box/pallet-like objects on a warehouse rack and (b) estimates
what fraction of the rack's storage slots are occupied.
Why classical CV, deliberately: zero model downloads (self-contained and
reproducible), runs instantly on a free CPU Space, and every detection is a
traceable contour rather than an opaque activation. A production system
would likely fine-tune a detector; this module demonstrates the systems
thinking (synthetic ground truth, honest evaluation under noise) that would
carry over directly.
Synthetic scenes: rack photos can't be licensed/scraped for a portfolio
project, so -- like every other dataset here -- scenes are generated with
PIL with known ground truth, which is what allows honest metrics.
Development notes (kept because they're real):
* v1 used Canny edges + heavy dilation and merged every box and shelf bar
into one blob. Switching to per-pixel color-distance segmentation fixed it.
* On clean renders (noise_level=0) v2 hit a suspiciously perfect 100%, so
`noise_level` (Gaussian pixel noise, brightness/contrast jitter, per-box
color variation) was added; accuracy then degrades realistically.
* Occupancy was first computed from padded box pixel area vs full cell area
(a definitional mismatch that under-counted ~40%); it now counts occupied
grid cells, matching how ground truth is defined.
"""
import random
from dataclasses import dataclass
from typing import List, Optional, Tuple
import cv2
import numpy as np
from PIL import Image, ImageDraw
RACK_W, RACK_H = 640, 400
SHELF_ROWS, SHELF_COLS = 3, 6
MARGIN = 20
SHELF_BAR_H = 10
BOX_COLORS = [
(181, 101, 29), (139, 69, 19), (205, 133, 63), (160, 82, 45),
(222, 184, 135), (128, 0, 0), (46, 87, 46), (25, 65, 100),
]
BG_COLOR = (235, 235, 230)
SHELF_COLOR = (90, 90, 95)
@dataclass
class RackScene:
image: Image.Image
true_box_count: int
true_occupancy: float # fraction of cells filled, 0-1
def generate_rack_scene(fill_prob: float = 0.6, seed: Optional[int] = None, noise_level: float = 0.0) -> RackScene:
"""One synthetic rack image with known ground-truth box count/occupancy."""
rng = random.Random(seed)
img = Image.new("RGB", (RACK_W, RACK_H), BG_COLOR)
draw = ImageDraw.Draw(img)
cell_w = (RACK_W - 2 * MARGIN) / SHELF_COLS
cell_h = (RACK_H - 2 * MARGIN) / SHELF_ROWS
for row in range(SHELF_ROWS + 1):
y = MARGIN + row * cell_h
draw.rectangle([MARGIN - 5, y - SHELF_BAR_H / 2, RACK_W - MARGIN + 5, y + SHELF_BAR_H / 2], fill=SHELF_COLOR)
n_filled = 0
for row in range(SHELF_ROWS):
for col in range(SHELF_COLS):
if rng.random() < fill_prob:
x0, y0 = MARGIN + col * cell_w, MARGIN + row * cell_h
pad = min(cell_w, cell_h) * 0.12
bw, bh = cell_w - 2 * pad, cell_h - 2 * pad - 4
bx0, by0 = x0 + pad, y0 + pad + 4
base = rng.choice(BOX_COLORS)
if noise_level > 0:
j = int(25 * noise_level)
color = tuple(int(np.clip(c + rng.randint(-j, j), 0, 255)) for c in base)
else:
color = base
draw.rectangle([bx0, by0, bx0 + bw, by0 + bh], fill=color, outline=(30, 30, 30), width=2)
draw.line([bx0 + 4, by0 + bh * 0.4, bx0 + bw - 4, by0 + bh * 0.4], fill=(20, 20, 20), width=2)
n_filled += 1
if noise_level > 0:
arr = np.array(img).astype(np.float32)
brightness = rng.uniform(-20, 20) * noise_level
contrast = 1.0 + rng.uniform(-0.15, 0.15) * noise_level
arr = (arr - 127.5) * contrast + 127.5 + brightness
arr += np.random.RandomState(seed).normal(0, 10 * noise_level, arr.shape)
img = Image.fromarray(np.clip(arr, 0, 255).astype(np.uint8))
return RackScene(img, n_filled, n_filled / (SHELF_ROWS * SHELF_COLS))
@dataclass
class DetectionResult:
detected_count: int
estimated_occupancy: float
annotated_image: Image.Image
boxes: List[Tuple[int, int, int, int]]
def _iou(a, b) -> float:
ax, ay, aw, ah = a
bx, by, bw, bh = b
iw = max(0, min(ax + aw, bx + bw) - max(ax, bx))
ih = max(0, min(ay + ah, by + bh) - max(ay, by))
inter = iw * ih
union = aw * ah + bw * bh - inter
return inter / union if union > 0 else 0.0
def _nms(boxes, thr=0.3):
kept = []
for b in sorted(boxes, key=lambda b: b[2] * b[3], reverse=True):
if all(_iou(b, k) < thr for k in kept):
kept.append(b)
return kept
def detect_boxes(image: Image.Image, min_area_frac: float = 0.01, max_area_frac: float = 0.25) -> DetectionResult:
"""Color-distance segmentation -> morphology -> contours -> geometric filter."""
rgb = np.array(image.convert("RGB")).astype(np.int16)
dist = lambda c: np.sqrt(np.sum((rgb - np.array(c)) ** 2, axis=-1))
mask = ((dist(BG_COLOR) > 60) & (dist(SHELF_COLOR) > 60)).astype(np.uint8) * 255
k = np.ones((3, 3), np.uint8)
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k, iterations=2)
mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, k, iterations=1)
contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
h, w = rgb.shape[:2]
boxes = []
for c in contours:
area = cv2.contourArea(c)
if not (h * w * min_area_frac <= area <= h * w * max_area_frac):
continue
x, y, bw, bh = cv2.boundingRect(c)
aspect = bw / float(bh) if bh else 0
if 0.2 <= aspect <= 3.0:
boxes.append((x, y, bw, bh))
boxes = _nms(boxes)
cell_w = (RACK_W - 2 * MARGIN) / SHELF_COLS
cell_h = (RACK_H - 2 * MARGIN) / SHELF_ROWS
cells = set()
for (x, y, bw, bh) in boxes:
col = max(0, min(SHELF_COLS - 1, int((x + bw / 2 - MARGIN) // cell_w)))
row = max(0, min(SHELF_ROWS - 1, int((y + bh / 2 - MARGIN) // cell_h)))
cells.add((row, col))
occupancy = len(cells) / (SHELF_ROWS * SHELF_COLS)
annotated = image.convert("RGB").copy()
d = ImageDraw.Draw(annotated)
for (x, y, bw, bh) in boxes:
d.rectangle([x, y, x + bw, y + bh], outline=(0, 220, 90), width=3)
return DetectionResult(len(boxes), float(occupancy), annotated, boxes)
|