Upload app.py with huggingface_hub

app.py

@@ -105,222 +105,6 @@ def supports_keyword(callable_obj, keyword):
     return keyword in signature.parameters
 
 
-def _order_points(points):
-    import numpy as np
-
-    rect = np.zeros((4, 2), dtype="float32")
-    point_sum = points.sum(axis=1)
-    point_diff = np.diff(points, axis=1)
-
-    rect[0] = points[np.argmin(point_sum)]
-    rect[2] = points[np.argmax(point_sum)]
-    rect[1] = points[np.argmin(point_diff)]
-    rect[3] = points[np.argmax(point_diff)]
-    return rect
-
-
-def _warp_largest_page(image: Image.Image) -> Image.Image:
-    try:
-        import cv2
-        import numpy as np
-    except ImportError:
-        return image
-
-    rgb = np.array(image)
-    height, width = rgb.shape[:2]
-    max_side = max(width, height)
-    scale = 1200 / max_side if max_side > 1200 else 1.0
-
-    if scale != 1.0:
-        scan = cv2.resize(rgb, (int(width * scale), int(height * scale)))
-    else:
-        scan = rgb
-
-    gray = cv2.cvtColor(scan, cv2.COLOR_RGB2GRAY)
-    gray = cv2.GaussianBlur(gray, (5, 5), 0)
-    edges = cv2.Canny(gray, 50, 150)
-    edges = cv2.dilate(edges, np.ones((5, 5), dtype=np.uint8), iterations=1)
-
-    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    image_area = scan.shape[0] * scan.shape[1]
-    for contour in sorted(contours, key=cv2.contourArea, reverse=True)[:8]:
-        area = cv2.contourArea(contour)
-        if area < image_area * 0.25:
-            continue
-
-        perimeter = cv2.arcLength(contour, True)
-        approx = cv2.approxPolyDP(contour, 0.02 * perimeter, True)
-        if len(approx) != 4:
-            continue
-
-        points = approx.reshape(4, 2).astype("float32") / scale
-        rect = _order_points(points)
-        top_left, top_right, bottom_right, bottom_left = rect
-
-        target_width = int(max(
-            np.linalg.norm(bottom_right - bottom_left),
-            np.linalg.norm(top_right - top_left),
-        ))
-        target_height = int(max(
-            np.linalg.norm(top_right - bottom_right),
-            np.linalg.norm(top_left - bottom_left),
-        ))
-        if target_width < 200 or target_height < 200:
-            continue
-
-        destination = np.array([
-            [0, 0],
-            [target_width - 1, 0],
-            [target_width - 1, target_height - 1],
-            [0, target_height - 1],
-        ], dtype="float32")
-        matrix = cv2.getPerspectiveTransform(rect, destination)
-        warped = cv2.warpPerspective(rgb, matrix, (target_width, target_height))
-        return Image.fromarray(warped)
-
-    return image
-
-
-def _crop_to_music_content(image: Image.Image) -> Image.Image:
-    staff_crop = _crop_to_staff_band(image)
-    if staff_crop is not None:
-        return staff_crop
-
-    try:
-        import numpy as np
-    except ImportError:
-        return image
-
-    gray = np.array(image.convert("L"))
-    content = gray < 235
-    row_density = content.mean(axis=1)
-    col_density = content.mean(axis=0)
-    rows = np.where(row_density > 0.01)[0]
-    cols = np.where(col_density > 0.004)[0]
-    if len(rows) == 0 or len(cols) == 0:
-        return image
-
-    width, height = image.size
-    left, right = int(cols[0]), int(cols[-1])
-    top, bottom = _select_music_row_band(row_density, rows)
-    content_width = right - left + 1
-    content_height = bottom - top + 1
-    if (
-        content_width * content_height < width * height * 0.12
-        and (content_width < width * 0.35 or content_height < 48)
-    ):
-        return image
-
-    pad_x = max(int(content_width * 0.04), 24)
-    pad_y = max(int(content_height * 0.18), 24)
-    return image.crop((
-        max(left - pad_x, 0),
-        max(top - pad_y, 0),
-        min(right + pad_x, width),
-        min(bottom + pad_y, height),
-    ))
-
-
-def _crop_to_staff_band(image: Image.Image):
-    try:
-        import cv2
-        import numpy as np
-    except ImportError:
-        return None
-
-    rgb = np.array(image)
-    gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
-    height, width = gray.shape[:2]
-    if width < 80 or height < 40:
-        return None
-
-    # Normalize uneven camera lighting before looking for staff lines.
-    background = cv2.medianBlur(gray, 31)
-    normalized = cv2.divide(gray, background, scale=255)
-    thresholded = cv2.adaptiveThreshold(
-        normalized,
-        255,
-        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-        cv2.THRESH_BINARY_INV,
-        31,
-        12,
-    )
-
-    horizontal_kernel = cv2.getStructuringElement(
-        cv2.MORPH_RECT,
-        (max(width // 18, 35), 1),
-    )
-    staff_lines = cv2.morphologyEx(thresholded, cv2.MORPH_OPEN, horizontal_kernel)
-    row_strength = staff_lines.mean(axis=1) / 255.0
-    candidate_rows = np.where(row_strength > max(0.03, row_strength.max() * 0.25))[0]
-    if len(candidate_rows) < 3:
-        return None
-
-    top, bottom = _select_music_row_band(row_strength, candidate_rows)
-    line_span = bottom - top + 1
-    if line_span < 10:
-        return None
-
-    band_pad = max(int(line_span * 1.6), 48)
-    top = max(top - band_pad, 0)
-    bottom = min(bottom + band_pad, height - 1)
-
-    band_mask = thresholded[top:bottom + 1, :]
-    col_strength = band_mask.mean(axis=0) / 255.0
-    active_cols = np.where(col_strength > max(0.006, col_strength.max() * 0.08))[0]
-    if len(active_cols) < width * 0.2:
-        return None
-
-    left, right = int(active_cols[0]), int(active_cols[-1])
-    content_width = right - left + 1
-    content_height = bottom - top + 1
-    if content_width < 120 or content_height < 40:
-        return None
-
-    pad_x = max(int(content_width * 0.03), 20)
-    pad_y = max(int(content_height * 0.08), 12)
-    return image.crop((
-        max(left - pad_x, 0),
-        max(top - pad_y, 0),
-        min(right + pad_x, width),
-        min(bottom + pad_y, height),
-    ))
-
-
-def _select_music_row_band(row_density, active_rows):
-    try:
-        import numpy as np
-    except ImportError:
-        return int(active_rows[0]), int(active_rows[-1])
-
-    active = row_density > 0.01
-    runs = []
-    start = None
-    for index, is_active in enumerate(active):
-        if is_active and start is None:
-            start = index
-        elif not is_active and start is not None:
-            runs.append((start, index - 1))
-            start = None
-    if start is not None:
-        runs.append((start, len(active) - 1))
-
-    if not runs:
-        return int(active_rows[0]), int(active_rows[-1])
-
-    first, last = int(active_rows[0]), int(active_rows[-1])
-    total_height = last - first + 1
-    if total_height < len(row_density) * 0.55:
-        return first, last
-
-    smoothed = np.convolve(row_density, np.ones(9) / 9, mode="same")
-    best = max(
-        runs,
-        key=lambda run: float(smoothed[run[0]:run[1] + 1].sum()) * max(run[1] - run[0] + 1, 1),
-    )
-    return int(best[0]), int(best[1])
-
-
 def _ensure_horizontal_music(image: Image.Image) -> Image.Image:
     width, height = image.size
     if height > width:
@@ -328,75 +112,6 @@ def _ensure_horizontal_music(image: Image.Image) -> Image.Image:
     return image
 
 
-def _deskew_image(image: Image.Image) -> Image.Image:
-    """Correct slight rotation by aligning detected staff lines to horizontal."""
-    try:
-        import cv2
-        import numpy as np
-    except ImportError:
-        return image
-
-    rgb = np.array(image)
-    gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
-    height, width = gray.shape[:2]
-    if width < 120 or height < 40:
-        return image
-
-    background = cv2.medianBlur(gray, 31)
-    normalized = cv2.divide(gray, background, scale=255)
-    edges = cv2.Canny(normalized, 30, 100)
-
-    lines = cv2.HoughLines(edges, 1, np.pi / 360, threshold=max(width // 5, 40))
-    if lines is None:
-        return image
-
-    angles = []
-    for line in lines:
-        rho, theta = line[0]
-        angle_from_horizontal = theta - np.pi / 2
-        if abs(angle_from_horizontal) < np.radians(10):
-            angles.append(angle_from_horizontal)
-
-    if len(angles) < 2:
-        return image
-
-    median_angle = float(np.median(angles))
-    if abs(median_angle) < np.radians(0.3):
-        return image
-
-    angle_deg = max(-10.0, min(10.0, float(np.degrees(median_angle))))
-    return image.rotate(-angle_deg, resample=Image.Resampling.BICUBIC, expand=False, fillcolor=(255, 255, 255))
-
-
-def _binarize_to_training_style(image: Image.Image) -> Image.Image:
-    """Convert to clean black-on-white to match training image style."""
-    try:
-        import cv2
-        import numpy as np
-    except ImportError:
-        return image
-
-    gray = np.array(image.convert("L"))
-    height, width = gray.shape[:2]
-
-    # Normalize uneven camera lighting before thresholding.
-    blur_size = max(min(width, height) // 10, 15) | 1
-    background = cv2.medianBlur(gray, blur_size)
-    normalized = cv2.divide(gray, background, scale=255)
-
-    block_size = max(min(width, height) // 20, 11) | 1
-    binary = cv2.adaptiveThreshold(
-        normalized,
-        255,
-        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-        cv2.THRESH_BINARY,
-        block_size,
-        6,
-    )
-    binary = cv2.medianBlur(binary, 3)
-    return Image.fromarray(binary).convert("RGB")
-
-
 def _score_training_orientation(image: Image.Image):
     try:
         import cv2
@@ -526,10 +241,7 @@ def _normalize_to_training_orientation(image: Image.Image):
     candidates = []
     for rotation in (0, 90, 180, 270):
         candidate = image.rotate(rotation, expand=True) if rotation else image.copy()
-        candidate = _warp_largest_page(candidate)
-        candidate = _crop_to_music_content(candidate)
         candidate = _ensure_horizontal_music(candidate)
-        candidate = _deskew_image(candidate)
         score = _score_training_orientation(candidate)
         candidates.append((score, rotation, candidate))
 
@@ -555,7 +267,6 @@ def preprocess_sheet_music_image(image_path):
     original_size = original.size
     image, rotation, orientation_score = _normalize_to_training_orientation(original)
     image = _limit_image_size(image)
-    image = _binarize_to_training_style(image)
     processed_size = image.size
 
     temp_file = tempfile.NamedTemporaryFile(suffix=".png", delete=False)