404 lines
12 KiB
Python
404 lines
12 KiB
Python
import cv2
|
|
import numpy as np
|
|
|
|
|
|
def _normalize_contour(contour, width, height):
|
|
points = contour.reshape(-1, 2)
|
|
|
|
return [
|
|
{
|
|
"x": round(float(x) / float(width), 8),
|
|
"y": round(float(y) / float(height), 8),
|
|
}
|
|
for x, y in points
|
|
]
|
|
|
|
|
|
def _simplify_contour(contour, max_points=120):
|
|
if contour is None or len(contour) < 3:
|
|
return contour
|
|
|
|
perimeter = cv2.arcLength(contour, True)
|
|
|
|
if perimeter <= 0:
|
|
return contour
|
|
|
|
epsilon = max(0.8, perimeter * 0.0025)
|
|
simplified = cv2.approxPolyDP(contour, epsilon, True)
|
|
|
|
while len(simplified) > max_points and epsilon < perimeter * 0.06:
|
|
epsilon *= 1.25
|
|
simplified = cv2.approxPolyDP(contour, epsilon, True)
|
|
|
|
if simplified is None or len(simplified) < 3:
|
|
return contour
|
|
|
|
return simplified
|
|
|
|
|
|
def _contour_score(contour, image_area, width, height):
|
|
area = abs(cv2.contourArea(contour))
|
|
|
|
if area <= 0:
|
|
return None
|
|
|
|
x, y, w, h = cv2.boundingRect(contour)
|
|
|
|
if w < 8 or h < 8:
|
|
return None
|
|
|
|
bbox_area = w * h
|
|
|
|
if bbox_area <= 0:
|
|
return None
|
|
|
|
area_ratio = area / image_area
|
|
bbox_ratio = bbox_area / image_area
|
|
fill_ratio = area / bbox_area
|
|
aspect = max(w, h) / max(1, min(w, h))
|
|
|
|
# Too small: usually dots/noise.
|
|
if area_ratio < 0.0004:
|
|
return None
|
|
|
|
# Too large: usually background / page.
|
|
if area_ratio > 0.96 or bbox_ratio > 0.98:
|
|
return None
|
|
|
|
# Very thin: usually dimensions/text lines.
|
|
if aspect > 40:
|
|
return None
|
|
|
|
# Prefer large compact-ish shapes, but allow irregular profiles.
|
|
score = area
|
|
|
|
if 0.08 <= fill_ratio <= 0.95:
|
|
score *= 1.25
|
|
|
|
# Penalize contours glued to the border because they are often crop/background artifacts.
|
|
border_touch = (
|
|
x <= 1 or
|
|
y <= 1 or
|
|
x + w >= width - 2 or
|
|
y + h >= height - 2
|
|
)
|
|
|
|
if border_touch:
|
|
score *= 0.65
|
|
|
|
return {
|
|
"score": score,
|
|
"area": area,
|
|
"bbox": (x, y, w, h),
|
|
"area_ratio": area_ratio,
|
|
"bbox_ratio": bbox_ratio,
|
|
"fill_ratio": fill_ratio,
|
|
"aspect": aspect,
|
|
"border_touch": border_touch,
|
|
}
|
|
|
|
|
|
def _best_contour_from_mask(mask, image_area, width, height, mode_name):
|
|
contours, _hierarchy = cv2.findContours(
|
|
mask,
|
|
cv2.RETR_EXTERNAL,
|
|
cv2.CHAIN_APPROX_SIMPLE
|
|
)
|
|
|
|
candidates = []
|
|
|
|
for contour in contours:
|
|
info = _contour_score(contour, image_area, width, height)
|
|
|
|
if info is None:
|
|
continue
|
|
|
|
candidates.append((info["score"], contour, info))
|
|
|
|
if not candidates:
|
|
return None, {
|
|
"mode": mode_name,
|
|
"contours_total": len(contours),
|
|
"candidates": 0,
|
|
}
|
|
|
|
candidates.sort(key=lambda item: item[0], reverse=True)
|
|
|
|
best_score, best_contour, best_info = candidates[0]
|
|
|
|
return best_contour, {
|
|
"mode": mode_name,
|
|
"contours_total": len(contours),
|
|
"candidates": len(candidates),
|
|
"selected": {
|
|
"score": round(float(best_score), 3),
|
|
"area": round(float(best_info["area"]), 3),
|
|
"bbox": {
|
|
"x": int(best_info["bbox"][0]),
|
|
"y": int(best_info["bbox"][1]),
|
|
"width": int(best_info["bbox"][2]),
|
|
"height": int(best_info["bbox"][3]),
|
|
},
|
|
"area_ratio": round(float(best_info["area_ratio"]), 5),
|
|
"bbox_ratio": round(float(best_info["bbox_ratio"]), 5),
|
|
"fill_ratio": round(float(best_info["fill_ratio"]), 5),
|
|
"aspect": round(float(best_info["aspect"]), 3),
|
|
"border_touch": bool(best_info["border_touch"]),
|
|
}
|
|
}
|
|
|
|
|
|
def _remove_small_components(mask, min_area):
|
|
num_labels, labels, stats, _centroids = cv2.connectedComponentsWithStats(mask, connectivity=8)
|
|
|
|
output = np.zeros_like(mask)
|
|
|
|
for label in range(1, num_labels):
|
|
area = stats[label, cv2.CC_STAT_AREA]
|
|
|
|
if area >= min_area:
|
|
output[labels == label] = 255
|
|
|
|
return output
|
|
|
|
|
|
def _make_masks(image):
|
|
height, width = image.shape[:2]
|
|
image_area = width * height
|
|
|
|
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
|
|
|
|
# Slight blur to reduce antialias noise.
|
|
blurred = cv2.GaussianBlur(gray, (3, 3), 0)
|
|
|
|
# Dark ink mask: lines, hatches, dots, technical strokes.
|
|
mask_dark_245 = cv2.inRange(blurred, 0, 245)
|
|
mask_dark_235 = cv2.inRange(blurred, 0, 235)
|
|
mask_dark_220 = cv2.inRange(blurred, 0, 220)
|
|
|
|
# Otsu inverse.
|
|
_t, mask_otsu = cv2.threshold(
|
|
blurred,
|
|
0,
|
|
255,
|
|
cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU
|
|
)
|
|
|
|
# Adaptive threshold helps on scans with grey background.
|
|
mask_adaptive = cv2.adaptiveThreshold(
|
|
blurred,
|
|
255,
|
|
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
|
|
cv2.THRESH_BINARY_INV,
|
|
31,
|
|
7
|
|
)
|
|
|
|
base_mask = cv2.bitwise_or(mask_dark_235, mask_otsu)
|
|
base_mask = cv2.bitwise_or(base_mask, mask_adaptive)
|
|
|
|
min_component_area = max(6, int(image_area * 0.00002))
|
|
base_mask = _remove_small_components(base_mask, min_component_area)
|
|
|
|
kernel_3 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
|
|
kernel_5 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
|
|
kernel_9 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))
|
|
kernel_13 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (13, 13))
|
|
kernel_21 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (21, 21))
|
|
|
|
masks = []
|
|
|
|
# Strategy 1: normal dark mask, light close.
|
|
m1 = cv2.morphologyEx(base_mask, cv2.MORPH_CLOSE, kernel_5, iterations=1)
|
|
m1 = cv2.morphologyEx(m1, cv2.MORPH_OPEN, kernel_3, iterations=1)
|
|
masks.append(("dark_close_5", m1))
|
|
|
|
# Strategy 2: stronger close for broken profile lines / dotted hatches.
|
|
m2 = cv2.morphologyEx(base_mask, cv2.MORPH_CLOSE, kernel_9, iterations=2)
|
|
m2 = cv2.morphologyEx(m2, cv2.MORPH_OPEN, kernel_3, iterations=1)
|
|
masks.append(("dark_close_9x2", m2))
|
|
|
|
# Strategy 3: very strong close, useful when profile is made of dots/hatches.
|
|
m3 = cv2.morphologyEx(base_mask, cv2.MORPH_CLOSE, kernel_13, iterations=2)
|
|
m3 = cv2.morphologyEx(m3, cv2.MORPH_OPEN, kernel_5, iterations=1)
|
|
masks.append(("dark_close_13x2", m3))
|
|
|
|
# Strategy 4: Canny edges closed.
|
|
edges = cv2.Canny(blurred, 60, 180)
|
|
e1 = cv2.dilate(edges, kernel_3, iterations=1)
|
|
e1 = cv2.morphologyEx(e1, cv2.MORPH_CLOSE, kernel_9, iterations=2)
|
|
masks.append(("canny_close_9x2", e1))
|
|
|
|
# Strategy 5: flood fill from closed boundaries.
|
|
boundary = cv2.dilate(mask_dark_245, kernel_3, iterations=1)
|
|
boundary = cv2.morphologyEx(boundary, cv2.MORPH_CLOSE, kernel_9, iterations=2)
|
|
|
|
passable = cv2.bitwise_not(boundary)
|
|
flood = passable.copy()
|
|
flood_mask = np.zeros((height + 2, width + 2), dtype=np.uint8)
|
|
|
|
for x in range(width):
|
|
if flood[0, x] > 0:
|
|
cv2.floodFill(flood, flood_mask, (x, 0), 128)
|
|
if flood[height - 1, x] > 0:
|
|
cv2.floodFill(flood, flood_mask, (x, height - 1), 128)
|
|
|
|
for y in range(height):
|
|
if flood[y, 0] > 0:
|
|
cv2.floodFill(flood, flood_mask, (0, y), 128)
|
|
if flood[y, width - 1] > 0:
|
|
cv2.floodFill(flood, flood_mask, (width - 1, y), 128)
|
|
|
|
outside = (flood == 128).astype(np.uint8) * 255
|
|
enclosed = cv2.bitwise_not(outside)
|
|
|
|
enclosed[0, :] = 0
|
|
enclosed[-1, :] = 0
|
|
enclosed[:, 0] = 0
|
|
enclosed[:, -1] = 0
|
|
|
|
enclosed = cv2.morphologyEx(enclosed, cv2.MORPH_OPEN, kernel_5, iterations=1)
|
|
masks.append(("flood_enclosed", enclosed))
|
|
|
|
# Strategy 6: if everything is sparse, glue nearby strokes aggressively.
|
|
m6 = cv2.morphologyEx(mask_dark_220, cv2.MORPH_CLOSE, kernel_21, iterations=1)
|
|
m6 = cv2.morphologyEx(m6, cv2.MORPH_OPEN, kernel_5, iterations=1)
|
|
masks.append(("aggressive_close_21", m6))
|
|
|
|
return masks, {
|
|
"gray_mean": round(float(gray.mean()), 3),
|
|
"base_mask_pixels": int((base_mask > 0).sum()),
|
|
"image_width": width,
|
|
"image_height": height,
|
|
}
|
|
|
|
|
|
def propose_contour_from_image_bytes(image_bytes, max_points=120):
|
|
"""
|
|
Receives a PNG/JPG image of the currently visible ROI canvas and returns
|
|
a proposed outer contour as normalized x/y points.
|
|
|
|
This is a proposal only. The frontend must allow editing.
|
|
"""
|
|
np_buffer = np.frombuffer(image_bytes, dtype=np.uint8)
|
|
image = cv2.imdecode(np_buffer, cv2.IMREAD_COLOR)
|
|
|
|
if image is None:
|
|
return {
|
|
"success": False,
|
|
"message": "Immagine non valida o non decodificabile."
|
|
}
|
|
|
|
height, width = image.shape[:2]
|
|
|
|
if width < 20 or height < 20:
|
|
return {
|
|
"success": False,
|
|
"message": "Immagine troppo piccola per il riconoscimento del contorno."
|
|
}
|
|
|
|
image_area = width * height
|
|
|
|
masks, base_diag = _make_masks(image)
|
|
|
|
attempts = []
|
|
best_global = None
|
|
|
|
for mode_name, mask in masks:
|
|
contour, diag = _best_contour_from_mask(
|
|
mask=mask,
|
|
image_area=image_area,
|
|
width=width,
|
|
height=height,
|
|
mode_name=mode_name
|
|
)
|
|
|
|
diag["mask_pixels"] = int((mask > 0).sum())
|
|
attempts.append(diag)
|
|
|
|
if contour is None:
|
|
continue
|
|
|
|
info = _contour_score(contour, image_area, width, height)
|
|
|
|
if info is None:
|
|
continue
|
|
|
|
score = info["score"]
|
|
|
|
if best_global is None or score > best_global["score"]:
|
|
best_global = {
|
|
"score": score,
|
|
"contour": contour,
|
|
"mode": mode_name,
|
|
"info": info,
|
|
"mask_pixels": int((mask > 0).sum()),
|
|
}
|
|
|
|
if best_global is None:
|
|
return {
|
|
"success": False,
|
|
"message": "Nessun contorno plausibile trovato. Prova una ROI più stretta o procedi manualmente.",
|
|
"diagnostics": {
|
|
**base_diag,
|
|
"attempts": attempts,
|
|
}
|
|
}
|
|
|
|
simplified = _simplify_contour(best_global["contour"], max_points=max_points)
|
|
|
|
if simplified is None or len(simplified) < 3:
|
|
return {
|
|
"success": False,
|
|
"message": "Il contorno trovato non ha abbastanza punti validi.",
|
|
"diagnostics": {
|
|
**base_diag,
|
|
"selected_mode": best_global["mode"],
|
|
"attempts": attempts,
|
|
}
|
|
}
|
|
|
|
area_px2 = float(abs(cv2.contourArea(simplified)))
|
|
x, y, w, h = cv2.boundingRect(simplified)
|
|
|
|
# Defensive check.
|
|
if area_px2 <= 0:
|
|
return {
|
|
"success": False,
|
|
"message": "Il contorno trovato ha area nulla.",
|
|
"diagnostics": {
|
|
**base_diag,
|
|
"selected_mode": best_global["mode"],
|
|
"attempts": attempts,
|
|
}
|
|
}
|
|
|
|
return {
|
|
"success": True,
|
|
"message": "Contorno proposto correttamente.",
|
|
"outer_polygon": _normalize_contour(simplified, width, height),
|
|
"holes": [],
|
|
"diagnostics": {
|
|
**base_diag,
|
|
"selected_mode": best_global["mode"],
|
|
"points_count": int(len(simplified)),
|
|
"area_px2": round(area_px2, 3),
|
|
"bbox": {
|
|
"x": int(x),
|
|
"y": int(y),
|
|
"width": int(w),
|
|
"height": int(h)
|
|
},
|
|
"selected": {
|
|
"score": round(float(best_global["score"]), 3),
|
|
"area": round(float(best_global["info"]["area"]), 3),
|
|
"area_ratio": round(float(best_global["info"]["area_ratio"]), 5),
|
|
"bbox_ratio": round(float(best_global["info"]["bbox_ratio"]), 5),
|
|
"fill_ratio": round(float(best_global["info"]["fill_ratio"]), 5),
|
|
"aspect": round(float(best_global["info"]["aspect"]), 3),
|
|
"border_touch": bool(best_global["info"]["border_touch"]),
|
|
"mask_pixels": int(best_global["mask_pixels"]),
|
|
},
|
|
"attempts": attempts,
|
|
}
|
|
} |