tests/test_jav_poster_crop.py
Rama master · réplica de lectura del repositorio original.
# -*- coding: utf-8 -*-
"""横版封套里正封取景框的判据。
图都是 Pillow 当场合成的，不依赖真实封面：折痕是一条画上去的竖线，位置已知，
所以「找到的那一列对不对」有确定答案可比。
"""
from __future__ import annotations
import functools
import io
import json
import tempfile
import unittest
from unittest.mock import patch
from pathlib import Path
from PIL import Image
from peach import images, jav_poster_crop
from peach.jav_poster_crop import CENTER, FOLD, MANUAL, MANUAL_SOURCE, NONE, RATIO
class CompressedSpineTests(unittest.TestCase):
def test_a_face_left_of_the_cut_keeps_its_right_side(self):
face = {'cx': .5, 'cy': .2, 'w': .1, 'h': .2, 'score': .9}
box = jav_poster_crop.crop_record('STARS-350', 840, 563, [0.] * 840, face=face)['box']
self.assertEqual(box, {'x0': 0, 'y0': 0, 'x1': 840, 'y1': 563, 'method': NONE})
def test_blurred_padding_around_a_centered_front_is_excluded(self):
profile = jav_poster_crop.ColumnProfile([.02] * 224 + [.2] * 394 + [.02] * 222, [0.] * 840)
profile.seams[224] = profile.seams[618] = .95
face = {'cx': .487, 'cy': .231, 'w': .135, 'h': .242, 'score': .93}
box = jav_poster_crop.crop_record('HHL-018', 840, 563, profile, face=face)['box']
self.assertEqual(box, {'x0': 225, 'y0': 0, 'x1': 618, 'y1': 563, 'method': CENTER})
def test_busy_side_pictures_do_not_form_blurred_padding(self):
profile = jav_poster_crop.ColumnProfile([.2] * 840, [0.] * 840)
profile.seams[224] = profile.seams[618] = .95
self.assertIsNone(jav_poster_crop.padded_center_panel(840, 563, profile))
def test_both_boundaries_are_required_for_blurred_padding(self):
profile = jav_poster_crop.ColumnProfile([.02] * 224 + [.2] * 394 + [.02] * 222, [0.] * 840)
profile.seams[224] = .95
self.assertIsNone(jav_poster_crop.padded_center_panel(840, 563, profile))
def test_soft_spine_edge_is_separated_from_the_lettering(self):
record = json.loads((Path(__file__).parent / 'fixtures/cover-profiles/ipzz-477.json').read_text(encoding='utf-8'))
profile = jav_poster_crop.ColumnProfile(record['gradient'], record['seams'])
box = jav_poster_crop.front_panel_box(*record['px'], profile, code='IPZZ-477')
self.assertEqual(box['method'], FOLD)
self.assertGreaterEqual(box['x0'], 422)
self.assertLessEqual(box['x0'], 423)
def sleeve(width: int, height: int, fold: int | None) -> Image.Image:
"""一张封套：左边是背面，右边是正面，中间可选一条书脊折痕。"""
image = Image.new("RGB", (width, height), (200, 200, 200))
if fold is None:
return image
for x in range(fold, min(fold + 3, width)):
for y in range(height):
image.putpixel((x, y), (0, 0, 0))
for x in range(min(fold + 3, width), width):
for y in range(height):
image.putpixel((x, y), (150, 150, 150))
return image
def centred(width: int, height: int, x0: int, x1: int,
right: tuple[int, int, int] = (60, 60, 60)) -> Image.Image:
"""16:9 拼图：左右两块剧照，正中 `x0`～`x1` 是正封。"""
image = Image.new("RGB", (width, height), (90, 90, 90))
image.paste((200, 200, 200), (x0, 0, x1, height))
image.paste(right, (x1, 0, width, height))
return image
def edge_left(width: int, height: int) -> Image.Image:
"""折痕带之外有一条强边，带内平整：这张图没有可采信的折痕。"""
image = Image.new("RGB", (width, height), (200, 200, 200))
for x in range(0, int(width * 0.1)):
for y in range(height):
image.putpixel((x, y), (10, 10, 10))
return image
def gradient_of(image: Image.Image):
import cv2
import numpy
array = cv2.cvtColor(numpy.array(image), cv2.COLOR_RGB2BGR)
return jav_poster_crop.column_gradient(array)
def opencv_available() -> bool:
try:
import cv2 # noqa: F401
import numpy # noqa: F401
except ImportError:
return False
return True
@functools.lru_cache(maxsize=3)
def batch_script(name='poster_crop_boxes'):
"""按文件路径载入封面维护脚本。"""
import importlib.util
root = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location(
name, root / 'scripts' / (name + '.py'))
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
class CropShapeTests(unittest.TestCase):
"""框的形状：从折痕一路到源图的右下角，满高，中间不另取子区域。"""
def assert_reaches_the_corner(self, box: dict, width: int, height: int):
self.assertEqual((box["x1"], box["y0"], box["y1"]), (width, 0, height),
f"框不是「折痕到右缘、满高」：{box}")
self.assertGreater(box["x1"], box["x0"])
self.assertGreaterEqual(box["x0"], 0)
def test_the_box_runs_from_the_fold_to_the_bottom_right_corner(self):
for width, height in ((800, 539), (2184, 1464), (1000, 674), (760, 600)):
with self.subTest(size=(width, height)):
box = jav_poster_crop.front_panel_box(width, height)
self.assertEqual(box["method"], RATIO)
self.assert_reaches_the_corner(box, width, height)
def test_the_prior_puts_the_fold_where_the_front_panel_has_its_real_shape(self):
"""没有梯度可用时，正封的形状就是先验本身——按高度从右缘量回去。"""
for width, height in ((800, 539), (2184, 1464)):
with self.subTest(size=(width, height)):
box = jav_poster_crop.front_panel_box(width, height, [0.0] * width)
self.assertEqual(box["method"], RATIO)
self.assertAlmostEqual((box["x1"] - box["x0"]) / height,
jav_poster_crop.PANEL_ASPECT, places=2)
def test_a_degenerate_size_gives_an_empty_box_and_no_method(self):
self.assertEqual(jav_poster_crop.front_panel_box(0, 0),
{"x0": 0, "y0": 0, "x1": 0, "y1": 0, "method": NONE})
class MethodTests(unittest.TestCase):
"""各档各自的触发条件。"""
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_a_visible_spine_is_found_and_the_front_starts_there(self):
width, height, fold = 800, 540, 420
profile = gradient_of(sleeve(width, height, fold))
self.assertIsNotNone(profile)
found = jav_poster_crop.fold_column(width, height, profile)
self.assertIsNotNone(found, "画上去的折痕没被找到")
# 那条三列宽的黑线整条留在框外，正封从它右边开始。
self.assertGreaterEqual(found, fold + 3, found)
self.assertLessEqual(found - (fold + 3), 2, found)
box = jav_poster_crop.front_panel_box(width, height, profile)
self.assertEqual(box["method"], FOLD)
self.assertEqual((box["x0"], box["x1"], box["y0"], box["y1"]),
(found, width, 0, height))
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_without_a_spine_the_front_falls_back_to_the_prior_shape(self):
width, height = 800, 540
profile = gradient_of(edge_left(width, height))
self.assertIsNone(jav_poster_crop.fold_column(width, height, profile))
box = jav_poster_crop.front_panel_box(width, height, profile)
self.assertEqual(box["method"], RATIO)
self.assertEqual(box["x0"],
round(width - jav_poster_crop.PANEL_ASPECT * height))
def test_a_missing_gradient_falls_back_to_the_prior_shape(self):
"""OpenCV 不在时取景仍然给得出框，只是退化成先验几何。"""
box = jav_poster_crop.front_panel_box(800, 540, None)
self.assertEqual(box["method"], RATIO)
def test_a_portrait_or_square_image_is_not_cropped(self):
for width, height in ((600, 900), (800, 800), (900, 800)):
with self.subTest(size=(width, height)):
box = jav_poster_crop.front_panel_box(width, height)
self.assertEqual(box, {"x0": 0, "y0": 0, "x1": width, "y1": height,
"method": NONE})
def test_a_sixteen_by_nine_still_is_not_cropped(self):
"""整幅都是画面的官方剧照没有「正面那一块」，按先验切会裁出半张背景。"""
box = jav_poster_crop.front_panel_box(1920, 1080)
self.assertEqual(box["method"], NONE)
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_a_centred_front_panel_in_a_still_is_framed_between_its_seams(self):
"""「剧照 | 正封 | 剧照」的 16:9 拼图：框在两条满高拼接缝之间，满高。"""
width, height = 1348, 758
box = jav_poster_crop.front_panel_box(
width, height, gradient_of(centred(width, height, 408, 940)))
self.assertEqual(box["method"], CENTER)
self.assertEqual((box["y0"], box["y1"]), (0, height))
self.assertLessEqual(abs(box["x0"] - 408), 1, box)
self.assertLessEqual(abs(box["x1"] - 940), 1, box)
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_one_full_height_seam_is_enough_and_the_other_side_mirrors_it(self):
"""一侧剧照压暗后和正封边缘同色，那一侧没有缝；居中是版式本身，按对称补上。"""
width, height = 1348, 758
box = jav_poster_crop.front_panel_box(
width, height, gradient_of(centred(width, height, 408, 940, right=(200, 200, 200))))
self.assertEqual(box["method"], CENTER)
self.assertEqual(box["x1"], width - box["x0"])
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_a_strong_edge_that_stops_short_is_content_not_a_seam(self):
"""边位上的强边只占半截高度：那是画面里的人或物，不是拼接缝。"""
width, height = 1348, 758
image = Image.new("RGB", (width, height), (200, 200, 200))
image.paste((20, 20, 20), (0, 0, 408, height // 2))
box = jav_poster_crop.front_panel_box(width, height, gradient_of(image))
self.assertEqual(box["method"], NONE)
def test_a_still_without_seam_evidence_is_not_cropped(self):
"""只给列梯度、没有接缝覆盖率的调用方，16:9 那一档照旧不给框。"""
profile = [0.0] * 1348
profile[408] = 1.0
self.assertEqual(jav_poster_crop.front_panel_box(1348, 758, profile)["method"], NONE)
def test_the_window_peak_must_be_a_real_cliff(self):
"""窗里总有一个最大值，它不够陡就只是噪声的最高点，按它切会切进画面。"""
profile = [0.0] * 800
profile[80] = 1.0
profile[425] = 0.1
self.assertIsNone(jav_poster_crop.fold_column(800, 540, profile))
profile[425] = 0.9
self.assertIsNotNone(jav_poster_crop.fold_column(800, 540, profile))
def test_a_stronger_edge_outside_the_window_never_wins(self):
"""窗外那道边正是误判的来路：画面里的强边、书脊的另一条边都在窗外。"""
profile = [0.0] * 800
profile[330] = 1.0 # 正封会连着整条书脊
profile[470] = 1.0 # 切进正封，大标题被削掉一截
self.assertIsNone(jav_poster_crop.fold_column(800, 539, profile))
profile[418] = 0.5 # 一列宽的峭壁，斜坡下一列就落回基线
self.assertEqual(jav_poster_crop.fold_column(800, 539, profile), 419)
def test_the_window_is_measured_off_the_height_not_the_width(self):
"""同一个正封形状在低清和高清封套上都要认得出，尽管像素位置差着上千。"""
for width, height in ((800, 539), (2184, 1464)):
with self.subTest(size=(width, height)):
fold = round(width - 0.71 * height)
profile = [0.0] * width
profile[fold] = 1.0
self.assertEqual(jav_poster_crop.fold_column(width, height, profile),
fold + 1)
def test_the_cut_lands_past_the_slope_not_in_the_middle_of_it(self):
"""折痕是一道有宽度的斜坡，梯度的峰在最陡处，书脊最后几列还在它右边。"""
profile = [0.3] * 800 # 画面忙的封套，处处都有梯度响应
for column, value in zip(range(417, 422), (0.35, 0.48, 0.39, 0.44, 0.24)):
profile[column] = value
self.assertEqual(jav_poster_crop.fold_column(800, 539, profile), 421)
def test_the_walk_past_the_slope_is_bounded(self):
"""梯度一路不落回基线时不能一直走下去，最多走源图宽的 1%。"""
profile = [0.0] * 800
profile[418] = 1.0
for column in range(419, 500):
profile[column] = 0.5 # 斜坡右边一直不落回基线
self.assertEqual(jav_poster_crop.fold_column(800, 539, profile), 426)
@staticmethod
def banded_fold(closing_edge: int) -> list[float]:
"""ABF-328 的折痕照着量出来的梯度：书脊边、七列灰色阴影、另一道边才到正封。"""
profile = [0.3] * 2184
profile[1139], profile[1140] = 0.73, 0.56
for column in range(1141, 1147):
profile[column] = 0.2
profile[closing_edge - 1], profile[closing_edge] = 0.56, 0.59
profile[closing_edge + 1] = 0.06
return profile
def test_a_shadow_band_beside_the_fold_stays_outside_the_front(self):
"""两道边之间梯度短暂落回基线；停在那儿，卡片左缘就留下一道灰线。"""
self.assertEqual(jav_poster_crop.fold_column(2184, 1477, self.banded_fold(1148)), 1149)
def test_an_edge_well_inside_the_front_is_content_not_the_band(self):
"""离折痕超过一道边的宽度，那是正封里的标题字或人物边缘，不是阴影带的另一侧。"""
self.assertEqual(jav_poster_crop.fold_column(2184, 1477, self.banded_fold(1160)), 1141)
def test_a_busy_front_beside_a_weak_fold_is_not_mistaken_for_the_band(self):
"""折痕本身偏弱时，正封里一片花哨的画面处处都和它相当，那些边都不够峭壁。"""
profile = [0.1] * 2184
profile[100] = 1.0 # 窗外画面里最强的那道边
profile[1139] = 0.4
for column in range(1141, 1150):
profile[column] = 0.3 if column % 2 else 0.32
self.assertEqual(jav_poster_crop.fold_column(2184, 1477, profile), 1140)
def test_a_thick_spine_puts_both_of_its_edges_in_the_window(self):
"""书脊厚到两条边都落进窗里时按形状挑：左边那条更强，右边那条才是折痕。"""
profile = [0.0] * 3762
profile[1939] = 0.57 # 书脊左缘，挨着封底的留白
profile[1978] = 0.46 # 书脊右缘，正封从这里开始
self.assertEqual(jav_poster_crop.fold_column(3762, 2535, profile), 1979)
def test_an_edge_too_weak_to_be_a_rival_never_gets_to_vote(self):
"""形状更像正封不足以让一条弱边胜出：强度差太多的根本不进候选。"""
profile = [0.0] * 3762
profile[1939] = 0.57
profile[1978] = 0.20 # 不到窗内最强边的七成
self.assertEqual(jav_poster_crop.fold_column(3762, 2535, profile), 1940)
def test_a_profile_that_does_not_match_the_image_is_ignored(self):
self.assertIsNone(jav_poster_crop.fold_column(800, 540, [1.0] * 400))
class SeamBeyondTests(unittest.TestCase):
"""厚书脊里的文字边压过了折痕时，切点右边那条满高缝才是折痕。
ABW-147 的形状：3762×2535，书脊 1922～1978 列，窗内最强的边是书脊文字的 1939，
书脊右缘 1978 的梯度不到它的七成、进不了候选，可它从上贯到下，文字边不满高。
"""
WIDTH, HEIGHT = 3762, 2535
TEXT_EDGE, SPINE_EDGE = 1939, 1978
def profile(self, seam_at_text: float = 0.36, spine_edge: int = SPINE_EDGE,
spine_strength: float = 0.66, spine_seam: float = 0.91):
gradient = [0.0] * self.WIDTH
seams = [0.0] * self.WIDTH
gradient[self.TEXT_EDGE], seams[self.TEXT_EDGE] = 0.99, seam_at_text
gradient[spine_edge], seams[spine_edge] = spine_strength, spine_seam
return jav_poster_crop.ColumnProfile(gradient, seams)
def test_a_full_height_seam_right_of_a_cut_that_is_not_one_becomes_the_fold(self):
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT, self.profile()),
self.SPINE_EDGE + 1)
def test_a_cut_that_is_itself_a_full_height_seam_stays_where_it_is(self):
"""正封里紧挨折痕的边框、色带同样满高；折痕已经满高就没有理由再往右走。"""
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(seam_at_text=0.9)),
self.TEXT_EDGE + 1)
def test_a_seam_outside_the_window_is_content_not_the_fold(self):
"""窗外的满高缝切出来的正封形状不对，那是正封里的一条竖线。"""
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(spine_edge=2100)),
self.TEXT_EDGE + 1)
def test_a_seam_left_of_the_cut_is_never_looked_at(self):
"""书脊左缘也是满高缝，往左看会把整条书脊带回框里。"""
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(spine_edge=1900, spine_strength=0.5)),
self.TEXT_EDGE + 1)
def test_a_faint_seam_that_is_no_cliff_does_not_pull_the_cut(self):
"""淡淡的印刷分隔线能满高，但过不了峭壁那一关。"""
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(spine_strength=0.2)),
self.TEXT_EDGE + 1)
def test_a_bare_gradient_without_seams_behaves_as_before(self):
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT, list(self.profile())),
self.TEXT_EDGE + 1)
@unittest.skipUnless(opencv_available(), "需要 OpenCV")
def test_a_lettered_spine_is_cut_at_its_far_edge_from_the_image_itself(self):
"""从画面量：书脊底色上一列竖排文字，文字边和书脊右缘都在窗里，正封从右缘起。"""
width, height, spine, edge = 800, 538, 400, 430
image = Image.new("RGB", (width, height), (40, 40, 40)) # 封底和书脊一样暗，左缘弱
image.paste((20, 20, 20), (spine, 0, edge, height))
image.paste((120, 120, 120), (edge, 0, width, height))
for y in range(0, height, 6): # 书脊里的白色文字：窗内最强、却不满高的边
image.paste((255, 255, 255), (spine + 12, y, spine + 15, min(y + 4, height)))
box = jav_poster_crop.front_panel_box(width, height, gradient_of(image))
self.assertEqual(box["method"], FOLD)
self.assertGreaterEqual(box["x0"], edge)
self.assertLessEqual(box["x0"], edge + 3)
class SharpFoldTests(unittest.TestCase):
"""书脊里竖排片名是一片宽的高地，折痕是一条窄线：按突出度折痕才是窗里最显眼的那条。
DDK-023 的形状：800×539，折痕窗 390～433，书脊片名的高地 391～408 最高 0.50，
折痕 419 列只有 0.34（不到高地七成），满高覆盖 0.68（不到 `_seam_beyond` 的 0.75）。
"""
WIDTH, HEIGHT, FOLD_AT = 800, 539, 419
def profile(self, fold_seam: float = 0.68):
gradient = [0.1] * self.WIDTH
seams = [0.3] * self.WIDTH
gradient[3] = 1.0 # 封底左缘，全图最强
for column in range(391, 409): # 片名那片高地
gradient[column] = 0.5 - abs(column - 401) * 0.01
gradient[self.FOLD_AT], gradient[self.FOLD_AT + 1] = 0.34, 0.28
seams[self.FOLD_AT] = fold_seam
return jav_poster_crop.ColumnProfile(gradient, seams)
def test_a_narrow_fold_beside_a_lettered_plateau_is_the_fold(self):
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT, self.profile()),
self.FOLD_AT + 2)
def test_a_narrow_edge_that_is_not_full_height_is_front_lettering(self):
"""正封里紧挨折痕的大字也是窄尖峰，但只占几行，不进候选。"""
self.assertLess(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(fold_seam=0.3)),
self.FOLD_AT)
class SharpBeyondTests(unittest.TestCase):
"""书脊和正封同底色时折痕只在书脊内容所在的行里存在：切点右边那根孤立尖峰才是折痕。
IPZ-602 的形状：800×536，折痕窗 393～436，书脊内一块带边框的面板与竖排文字形成
390～409 的高地（最高 0.51，满高覆盖 0.5 上下），按形状选中高地右端、切在 410；
折痕 420 列梯度 0.24、满高覆盖 0.20，左边面板内部 0.06～0.11、右边正封留白 0.02～0.04，
周围 16 列中位数 0.065，折痕是它的 3.7 倍。合成剖面左侧取 0.07、右侧 0.02（3.4 倍）。
"""
WIDTH, HEIGHT, FOLD_AT = 800, 536, 420
def profile(self, left: float = 0.07, right: float = 0.02, panel_seam: float = 0.5,
seams: bool = True):
gradient = [0.05] * self.WIDTH
coverage = [0.1] * self.WIDTH
gradient[3] = 1.0 # 封底左缘，全图最强
for column in range(390, 410): # 面板边框与文字那片高地
gradient[column] = 0.4
coverage[column] = panel_seam
gradient[396], gradient[404] = 0.51, 0.45
for column in range(410, self.FOLD_AT): # 面板内部到折痕
gradient[column] = left
gradient[self.FOLD_AT], gradient[self.FOLD_AT + 1] = 0.24, 0.14
coverage[self.FOLD_AT] = 0.2
for column in range(self.FOLD_AT + 2, 440): # 正封左缘
gradient[column] = right
return jav_poster_crop.ColumnProfile(gradient, coverage) if seams else gradient
def test_an_isolated_edge_past_a_bordered_panel_is_the_fold(self):
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT, self.profile()),
self.FOLD_AT + 2)
def test_an_edge_that_rises_into_front_content_is_the_start_of_lettering(self):
"""左边留白、右边忙：那是正封内容的起笔，切点已经在折痕上（PPT-018 的金色片名）。
右侧取 0.12 而不是更高：周围中位数是左右两侧合起来算的，右侧再高，尖峰就先在
孤立度上被拦下，方向判据反而没被测到。
"""
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(left=0.02, right=0.12)),
410)
def test_an_edge_among_other_strokes_is_not_isolated(self):
"""周围中位数压不下去的尖峰是大字里的一笔，哪怕左边比右边忙（MIMK-009 的 423 列）。"""
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(left=0.12, right=0.09)),
410)
def test_a_cut_that_is_already_a_full_height_seam_stays(self):
"""高地本身满高就是折痕，右边再孤立的尖峰也是正封内容。"""
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(panel_seam=0.8)),
410)
def test_a_bare_gradient_without_seams_behaves_as_before(self):
self.assertEqual(jav_poster_crop.fold_column(self.WIDTH, self.HEIGHT,
self.profile(seams=False)),
410)
class CodeShapeTests(unittest.TestCase):
"""哪些番号的封面是横版封套。判据全部走 `catalog_rules` 现有函数。"""
def test_studio_and_amateur_codes_are_sleeves(self):
for code in ("ABW-232", "abw-232", "278GYAN-017", "259LUXU-1475"):
with self.subTest(code=code):
self.assertTrue(jav_poster_crop.crops_to_portrait(code))
def test_finished_landscape_artwork_is_not_cropped(self):
for code in ("HEYZO-1380", "FC2-PPV-1812235", "FC2-1812235",
"040221-001", "092620-001"):
with self.subTest(code=code):
self.assertFalse(jav_poster_crop.crops_to_portrait(code))
def test_non_jav_and_korean_codes_are_not_cropped(self):
for code in ("", None, "20211103_JENNIFERMENDEZ", "HHD800",
"AR-101", "NOAH-101"):
with self.subTest(code=code):
self.assertFalse(jav_poster_crop.crops_to_portrait(code))
def test_a_western_release_is_stopped_by_the_shape_of_its_artwork(self):
"""欧美片的编号和厂牌番号同形，番号这一关拦不住它，宽高比这一关拦得住。
它们的封面是成品横版剧照，落在 16:9 一档，所以走的是 `none`。
"""
self.assertTrue(jav_poster_crop.crops_to_portrait("BLACKED-2021"))
self.assertEqual(
jav_poster_crop.crop_record("BLACKED-2021", 1920, 1080)["box"]["method"],
NONE)
class WideSleeveTests(unittest.TestCase):
"""Blu-ray 模板的宽封套：厂牌开门，比例决定走不走，正封形状另有一套先验。"""
WIDE = (750, 419)
def test_only_the_listed_labels_open_the_door(self):
for code in ("CWPBD-126", "cwpbd-119", "SMBD-110"):
with self.subTest(code=code):
self.assertTrue(jav_poster_crop.is_wide_sleeve_label(code))
for code in ("IDBD-446", "PBD-390", "ABW-232", "259LUXU-1475", "", None):
with self.subTest(code=code):
self.assertFalse(jav_poster_crop.is_wide_sleeve_label(code))
def test_a_wide_sleeve_of_a_listed_label_is_cut_at_its_own_prior(self):
"""没有梯度时按宽封套的先验从右缘量回去，不是 DVD 那一档的 0.704。"""
width, height = self.WIDE
box = jav_poster_crop.front_panel_box(width, height, None, "CWPBD-126")
self.assertEqual(box["method"], RATIO)
self.assertEqual(box["x0"], round(width - jav_poster_crop.WIDE_PANEL_ASPECT * height))
self.assertEqual((box["x1"], box["y0"], box["y1"]), (width, 0, height))
def test_the_same_image_without_the_label_is_still_a_still(self):
"""比例一样的图，厂牌不在名单里就照旧当 16:9 剧照：这一档全靠厂牌开门。"""
width, height = self.WIDE
for code in ("ABW-232", None):
with self.subTest(code=code):
box = jav_poster_crop.front_panel_box(width, height, None, code)
self.assertEqual(box["method"], NONE)
def test_a_listed_label_with_a_dvd_shaped_cover_walks_the_dvd_path(self):
"""厂牌只开门，不定切法：同一厂牌哪一期换成 DVD 比例的封套，仍按那一档的形状切；
比例超出宽封套区间的仍是剧照。"""
record = jav_poster_crop.crop_record("CWPBD-126", 800, 540, [0.0] * 800)
self.assertEqual(record["box"]["method"], RATIO)
self.assertEqual(record["box"]["x0"],
round(800 - jav_poster_crop.PANEL_ASPECT * 540))
self.assertEqual(jav_poster_crop.crop_record("SMBD-110", 1900, 1000)["box"]["method"],
NONE)
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_a_spine_inside_the_narrow_window_is_found(self):
width, height = self.WIDE
fold = round(width - 0.855 * height)
profile = gradient_of(sleeve(width, height, fold))
box = jav_poster_crop.front_panel_box(width, height, profile, "SMBD-172")
self.assertEqual(box["method"], FOLD)
# 那条三列宽的黑线整条留在框外，正封从它右边开始。
self.assertGreaterEqual(box["x0"], fold + 3, box)
self.assertLessEqual(box["x0"] - (fold + 3), 2, box)
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_an_edge_outside_the_narrow_window_is_content_not_the_spine(self):
"""书脊上竖排的片名字边比书脊右缘强，但它切出的形状不在窗里，不按它切。"""
width, height = self.WIDE
text_edge = round(width - 0.90 * height)
profile = gradient_of(sleeve(width, height, text_edge))
box = jav_poster_crop.front_panel_box(width, height, profile, "CWPBD-126")
self.assertEqual(box["method"], RATIO)
self.assertEqual(box["x0"], round(width - jav_poster_crop.WIDE_PANEL_ASPECT * height))
def test_the_record_routes_the_code_into_the_shape_decision(self):
record = jav_poster_crop.crop_record("SMBD-110", *self.WIDE, [0.0] * self.WIDE[0])
self.assertEqual(record["box"]["method"], RATIO)
self.assertEqual(record["px"], list(self.WIDE))
class RecordTests(unittest.TestCase):
"""边车的内容、读写与失效判定。"""
def setUp(self):
self.root = Path(tempfile.mkdtemp()).resolve()
self.cover = self.root / "ABW-232.jpg"
sleeve(800, 540, 420).save(self.cover)
def test_a_shape_that_is_not_cropped_never_touches_the_gradient(self):
"""番号形态先判：不该裁的图连解码都不做。"""
calls = []
def source():
calls.append(1)
return [0.0] * 800
record = jav_poster_crop.crop_record("HEYZO-1380", 800, 540, source)
self.assertEqual(record["box"]["method"], NONE)
self.assertEqual(calls, [])
def test_the_record_carries_the_version_the_size_and_the_box(self):
record = jav_poster_crop.crop_record("ABW-232", 800, 540, [0.0] * 800)
self.assertEqual(record["version"], jav_poster_crop.ALGORITHM_VERSION)
self.assertEqual(record["px"], [800, 540])
self.assertEqual(record["box"]["method"], RATIO)
def test_the_sidecar_sits_beside_the_cover_and_round_trips(self):
record = jav_poster_crop.crop_record("ABW-232", 800, 540, [0.0] * 800)
path = jav_poster_crop.write_sidecar(self.cover, record)
self.assertEqual(path.name, "ABW-232.poster.json")
self.assertEqual(jav_poster_crop.read_sidecar(self.cover), record)
self.assertTrue(jav_poster_crop.is_current(record, 800, 540))
def test_an_outdated_version_or_a_replaced_cover_forces_a_recount(self):
record = jav_poster_crop.crop_record("ABW-232", 800, 540, [0.0] * 800)
self.assertFalse(jav_poster_crop.is_current(record, 2184, 1464),
"封面被更大的那张换掉之后，旧框落在新图上是一块错位的区域")
stale = dict(record, version="poster-crop-v0")
self.assertFalse(jav_poster_crop.is_current(stale, 800, 540))
self.assertFalse(jav_poster_crop.is_current(None, 800, 540))
def test_a_broken_sidecar_reads_as_missing(self):
jav_poster_crop.sidecar_path(self.cover).write_text("{not json",
encoding="utf-8")
self.assertIsNone(jav_poster_crop.read_sidecar(self.cover))
class ProjectionTests(unittest.TestCase):
"""API 字段的投影：只有真的算出框的那一档才给值。"""
def test_a_real_box_projects_with_the_source_size(self):
record = jav_poster_crop.crop_record("ABW-232", 800, 540, [0.0] * 800)
projected = jav_poster_crop.projection(record)
self.assertEqual(projected["px"], [800, 540])
self.assertEqual(projected["method"], RATIO)
self.assertEqual((projected["x1"], projected["y0"], projected["y1"]),
(800, 0, 540))
def test_everything_unusable_projects_to_none(self):
for record in (None, {}, {"version": "poster-crop-v0"},
jav_poster_crop.crop_record("HEYZO-1380", 800, 540),
{"version": jav_poster_crop.ALGORITHM_VERSION,
"px": [800, 540], "box": {"x0": 0, "x1": 0, "y0": 0,
"y1": 0, "method": RATIO}},
{"version": jav_poster_crop.ALGORITHM_VERSION,
"px": [800, 540], "box": {"x0": 0, "x1": 900, "y0": 0,
"y1": 540, "method": RATIO}}):
with self.subTest(record=record):
self.assertIsNone(jav_poster_crop.projection(record))
class ManualBoxTests(unittest.TestCase):
"""人在详情页自己框的那一块，与算出来的框共用同一份边车。"""
def test_a_hand_drawn_box_records_its_four_edges_and_its_source(self):
record = jav_poster_crop.manual_record(800, 540, {"x0": 200, "y0": 40,
"x1": 600, "y1": 500})
self.assertEqual(record["box"], {"x0": 200, "y0": 40, "x1": 600, "y1": 500,
"method": MANUAL})
self.assertEqual(record["px"], [800, 540])
self.assertEqual(record["source"], MANUAL_SOURCE)
self.assertTrue(jav_poster_crop.is_manual(record))
self.assertEqual(jav_poster_crop.projection(record)["method"], MANUAL)
def test_a_box_that_is_not_a_box_is_refused_before_it_reaches_the_disk(self):
for box in (None, {}, {"x0": 0, "y0": 0, "x1": 0, "y1": 100},
{"x0": "左", "y0": 0, "x1": 100, "y1": 100},
# 夹回图里之后只剩一条线：整幅右侧之外的框没有内容可取。
{"x0": 900, "y0": 0, "x1": 1000, "y1": 100}):
with self.subTest(box=box):
self.assertIsNone(jav_poster_crop.manual_record(800, 540, box))
def test_edges_outside_the_image_are_pulled_back_in(self):
record = jav_poster_crop.manual_record(800, 540, {"x0": -20, "y0": -5,
"x1": 1200, "y1": 900})
self.assertEqual(record["box"]["x0"], 0)
self.assertEqual((record["box"]["x1"], record["box"]["y1"]), (800, 540))
def test_a_hand_drawn_box_survives_an_algorithm_bump_but_not_a_new_cover(self):
"""手工框后面没有算法，改判据不构成重算它的理由；换了封面它就作废。"""
record = jav_poster_crop.manual_record(800, 540, {"x0": 200, "y0": 0,
"x1": 600, "y1": 540})
stale = dict(record, version="poster-crop-v0")
self.assertTrue(jav_poster_crop.is_current(stale, 800, 540))
self.assertIsNotNone(jav_poster_crop.projection(stale))
# 算出来的框换个版本号就该重算，两档判据不能混。
computed = dict(jav_poster_crop.crop_record("ABW-232", 800, 540, [0.0] * 800),
version="poster-crop-v0")
self.assertFalse(jav_poster_crop.is_current(computed, 800, 540))
self.assertIsNone(jav_poster_crop.projection(computed))
# 封面被更大的那张换掉：框描述的是另一张图，手工框也一样作废。
self.assertFalse(jav_poster_crop.is_current(record, 1600, 1080))
class CropBytesTests(unittest.TestCase):
"""按框切出新字节：原图不动，格式只在 PNG 与 JPEG 之间取一个。"""
@staticmethod
def payload(image: Image.Image, fmt: str) -> bytes:
buffer = io.BytesIO()
image.save(buffer, format=fmt)
return buffer.getvalue()
def test_a_jpeg_crop_comes_back_as_a_jpeg_of_the_boxed_size(self):
body = self.payload(Image.new("RGB", (800, 540), (10, 120, 200)), "JPEG")
cropped = images.crop_to_box(body, (200, 40, 600, 500))
self.assertEqual(images.measure_image_size(cropped), (400, 460))
with Image.open(io.BytesIO(cropped)) as opened:
self.assertEqual(opened.format, "JPEG")
def test_a_png_stays_a_png_and_transparency_lands_on_white(self):
source = Image.new("RGBA", (100, 100), (0, 0, 0, 0))
cropped = images.crop_to_box(self.payload(source, "PNG"), (0, 0, 50, 50))
with Image.open(io.BytesIO(cropped)) as opened:
self.assertEqual(opened.format, "PNG")
# 同一张透明图存成 JPEG 那一路要铺白底，否则透明处落成黑块。
flattened = images.crop_to_box(self.payload(source.convert("RGBA"), "WEBP"),
(0, 0, 50, 50))
with Image.open(io.BytesIO(flattened)) as opened:
self.assertEqual(opened.convert("RGB").getpixel((10, 10)), (255, 255, 255))
def test_a_box_outside_the_image_or_a_junk_payload_yields_nothing(self):
body = self.payload(Image.new("RGB", (100, 100)), "JPEG")
self.assertIsNone(images.crop_to_box(body, (0, 0, 200, 50)))
self.assertIsNone(images.crop_to_box(body, (50, 0, 50, 50)))
self.assertIsNone(images.crop_to_box(b"not an image", (0, 0, 10, 10)))
class BatchScriptTests(unittest.TestCase):
"""批处理只写边车、只处理该处理的那些图。"""
def setUp(self):
self.script = batch_script()
self.root = Path(tempfile.mkdtemp()).resolve()
self.cover = self.root / "ABW-232.jpg"
sleeve(800, 540, 420).save(self.cover)
self.before = self.cover.read_bytes()
def run_script(self, *argv):
return self.script.main([*argv, "--covers", str(self.root)])
def test_a_dry_run_writes_nothing(self):
self.assertEqual(self.run_script(), 0)
self.assertFalse(jav_poster_crop.sidecar_path(self.cover).exists())
def test_online_upgrade_checks_official_sources_without_local_snapshots(self):
from peach.jav_cover_fetch import Candidate
script = batch_script('upgrade_audited_covers')
candidate = Candidate('pics.dmm.co.jp', 'https://pics.dmm.co.jp/a.jpg', '')
report = self.root / 'report'
with patch.object(script, 'best_cover', return_value=(candidate, (2184, 1468), self.before)) as fetch:
with patch.object(script, 'install_cover') as install:
result = script.upgrade(self.cover, [], object(), report, live=True,
metadata_root=self.root / 'metadata')
self.assertEqual(result['status'], 'installed')
self.assertEqual(fetch.call_args.args[1], 'ABW-232')
self.assertEqual(fetch.call_args.kwargs['metadata_root'], self.root / 'metadata')
self.assertEqual(install.call_args.kwargs['evidence']['resolver'], 'official-live-upgrade-v1')
self.assertEqual((report / 'originals/ABW-232.jpg').read_bytes(), self.before)
def test_upgrade_resets_connections_only_for_retryable_source_failures(self):
from peach.jav_cover_fetch import NotFound, Unavailable
from unittest.mock import Mock
script = batch_script('upgrade_audited_covers')
for error, expected in ((NotFound('HTTP 404'), False), (Unavailable('HTTP 503'), True)):
transport = Mock()
result = script.failure_result('ABW-232', error, transport)
self.assertEqual(result['retryable'], expected)
self.assertEqual(transport.renew.call_count, int(expected))
def test_javdb_quarantine_preserves_bytes_and_resumes_without_duplicates(self):
covers = self.root / 'generated/covers'
covers.mkdir(parents=True)
target = covers / 'MIDV-377.jpg'
target.write_bytes(self.before)
evidence = target.with_suffix('.scraping.json')
evidence.write_text(json.dumps({'source': 'javdb', 'source_url': 'https://c0.jdbstatic.com/a.jpg'}), encoding='utf-8')
official = covers / 'SPONE-001.jpg'
official.write_bytes(self.before)
report = self.root / 'review/quarantine'
args = ['--data-root', str(self.root), '--report', str(report)]
script = batch_script('quarantine_javdb_covers')
self.assertEqual(script.main(args), 0)
self.assertTrue(target.exists())
self.assertEqual(script.main([*args, '--apply']), 0)
self.assertFalse(target.exists())
self.assertFalse(evidence.exists())
self.assertEqual((report / 'originals/MIDV-377.jpg').read_bytes(), self.before)
self.assertEqual(official.read_bytes(), self.before)
self.assertEqual(script.main([*args, '--apply']), 0)
result = json.loads((report / 'manifest.json').read_text(encoding='utf-8'))
self.assertEqual((result['matched'], result['quarantined']), (0, 1))
def test_quarantine_collision_does_not_partially_move_an_item(self):
covers = self.root / 'generated/covers'
covers.mkdir(parents=True)
target = covers / 'MIDV-377.jpg'
target.write_bytes(self.before)
evidence = target.with_suffix('.scraping.json')
evidence.write_text(json.dumps({'source': 'javdb'}), encoding='utf-8')
report = self.root / 'review/quarantine'
(report / 'originals').mkdir(parents=True)
(report / 'originals/MIDV-377.scraping.json').write_text('{}', encoding='utf-8')
with self.assertRaises(FileExistsError):
batch_script('quarantine_javdb_covers').main([
'--data-root', str(self.root), '--report', str(report), '--apply'])
self.assertEqual(target.read_bytes(), self.before)
self.assertTrue(evidence.exists())
def test_audit_keeps_manual_frames_and_reports_unknown_provenance(self):
manual = jav_poster_crop.manual_record(800, 540, {'x0': 420, 'y0': 0, 'x1': 800, 'y1': 540})
jav_poster_crop.write_sidecar(self.cover, manual)
script = batch_script('audit_cover_artwork')
row, proposed, _, _ = script.inspect(self.cover, self.root / 'metadata')
self.assertEqual(proposed, manual)
self.assertEqual(row['method'], MANUAL)
self.assertTrue('missing_provenance' in row['reasons'])
self.assertEqual(self.cover.read_bytes(), self.before)
def test_face_crossing_the_spine_is_preserved_by_offline_reframing(self):
target = self.root / 'SPONE-001.jpg'
Image.new('RGB', (800, 600), 'gray').save(target)
target.with_suffix('.face.json').write_text(json.dumps({
'px': [800, 600], 'face': {'cx': .555, 'cy': .331, 'w': .257, 'h': .422, 'score': .918},
}), encoding='utf-8')
row, proposed, _, layout = batch_script('audit_cover_artwork').inspect(target, self.root / 'metadata')
self.assertEqual((proposed['box']['method'], layout), (NONE, 'still'))
self.assertEqual(row['x0'], 0)
def test_offline_reframing_preserves_a_centered_front_with_padding(self):
from peach.cover_artwork import FACE_ALGORITHM_VERSION
target = self.root / 'HHL-018.jpg'
Image.new('RGB', (840, 563), 'gray').save(target)
target.with_suffix('.face.json').write_text(json.dumps({
'version': FACE_ALGORITHM_VERSION, 'px': [840, 563],
'face': {'cx': .487, 'cy': .231, 'w': .135, 'h': .242, 'score': .93},
}), encoding='utf-8')
profile = jav_poster_crop.ColumnProfile([.02] * 224 + [.2] * 394 + [.02] * 222, [0.] * 840)
profile.seams[224] = profile.seams[618] = .95
with patch.object(jav_poster_crop, 'file_gradient', return_value=profile):
row, proposed, _, layout = batch_script('audit_cover_artwork').inspect(target, self.root / 'metadata')
self.assertEqual((proposed['box']['method'], layout), (CENTER, ''))
self.assertEqual((row['x0'], proposed['box']['x1']), (225, 618))
def test_audit_refreshes_legacy_front_only_faces_before_classifying_the_cover(self):
from peach.face_detect import Face
from peach.cover_artwork import FACE_ALGORITHM_VERSION
from unittest.mock import Mock
target = self.root / 'SPONE-001.jpg'
Image.new('RGB', (800, 600), 'gray').save(target)
target.with_suffix('.face.json').write_text(json.dumps({
'px': [800, 600], 'face': {'cx': .8, 'cy': .3, 'w': .06, 'h': .1, 'score': .9},
}), encoding='utf-8')
detector = Mock()
detector.detect.return_value = [Face(.555, .331, .257, .422, .918), Face(.8, .3, .06, .1, .9)]
row, proposed, face, layout = batch_script('audit_cover_artwork').inspect(target, self.root / 'metadata', detector=detector)
self.assertEqual((proposed['box']['method'], layout), (NONE, 'still'))
self.assertEqual((face['version'], face['face']['cx']), (FACE_ALGORITHM_VERSION, .555))
self.assertNotIn('stale_face', row['reasons'])
def test_face_cache_requires_current_algorithm_and_image_dimensions(self):
from peach.cover_artwork import FACE_ALGORITHM_VERSION
script = batch_script('detect_cover_faces')
target = self.cover.with_suffix('.face.json')
for version, size, expected in (('old', [800, 540], False),
(FACE_ALGORITHM_VERSION, [1, 1], False), (FACE_ALGORITHM_VERSION, [800, 540], True)):
target.write_text(json.dumps({'version': version, 'px': size}), encoding='utf-8')
self.assertEqual(script.current_face(self.cover), expected)
def test_apply_writes_the_sidecar_and_leaves_the_image_untouched(self):
self.assertEqual(self.run_script("--apply"), 0)
record = json.loads(
jav_poster_crop.sidecar_path(self.cover).read_text(encoding="utf-8"))
self.assertEqual(record["px"], [800, 540])
self.assertIn(record["box"]["method"], (FOLD, RATIO))
self.assertEqual(self.cover.read_bytes(), self.before,
"取景是边车元数据，原图一个字节都不动")
@unittest.skipUnless(opencv_available(), "缺 vision 依赖组")
def test_a_centred_still_is_counted_in_its_own_bucket(self):
"""16:9 居中拼图是单独一档，批处理照样计数、写边车，不因为认不得这档停下。"""
still = self.root / "PASN-027.jpg"
centred(1348, 758, 408, 940).save(still)
self.assertEqual(self.run_script("--apply"), 0)
self.assertEqual(jav_poster_crop.read_sidecar(still)["box"]["method"], CENTER)
def test_a_current_sidecar_is_skipped_and_a_stale_one_is_redone(self):
self.run_script("--apply")
self.assertEqual(self.script.pending([self.cover], False), [])
stale = jav_poster_crop.read_sidecar(self.cover)
jav_poster_crop.write_sidecar(self.cover, dict(stale, version="poster-crop-v0"))
self.assertEqual(self.script.pending([self.cover], False),
[(self.cover, (800, 540))])
def test_an_unreadable_cover_is_counted_and_never_given_a_box(self):
broken = self.root / "BAD-001.jpg"
broken.write_bytes(b"not an image")
self.assertEqual(self.run_script("--apply"), 0)
self.assertFalse(jav_poster_crop.sidecar_path(broken).exists())
class ImageSizeTests(unittest.TestCase):
def test_the_size_probe_reports_none_for_junk(self):
root = Path(tempfile.mkdtemp()).resolve()
broken = root / "x.jpg"
broken.write_bytes(b"nope")
self.assertIsNone(batch_script().image_size(broken))
good = root / "y.jpg"
buffer = io.BytesIO()
Image.new("RGB", (40, 30)).save(buffer, "JPEG")
good.write_bytes(buffer.getvalue())
self.assertEqual(batch_script().image_size(good), (40, 30))
if __name__ == "__main__":
unittest.main()