Files
douyi_guaji_main/douyin_pixel.py
T
Your Name c30b73bbd3 feat: Enhance documentation and improve code structure
- Added comprehensive documentation for the unified screenshot and score recording process in the new markdown file.
- Updated existing markdown files to include additional spacing for better readability.
- Improved code structure by adding type hints and comments for clarity in various Python scripts.
- Enhanced logging functionality to support better debugging and monitoring across modules.
- Streamlined configuration settings to ensure consistency and clarity in the project structure.
2025-12-25 16:12:13 +08:00

857 lines
30 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import os
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import Any, Optional
from PIL import Image
def _safe_open_screenshot_rgb(pic_path: str) -> Optional[Image.Image]:
try:
if not pic_path or (not os.path.exists(pic_path)):
return None
pic = Image.open(pic_path)
pic.load() # Force load to catch truncated files early
return pic.convert("RGB")
except (OSError, IOError, SyntaxError):
# Handle truncated image files
return None
except Exception:
return None
def detect_coupon_popup_background(
pic_rgb: Image.Image,
return_info: bool = False,
template_threshold: float | None = None,
analyser: Any = None,
) -> bool | tuple[bool, dict]:
"""检测底部优惠券大弹窗(仅模板匹配)。
模板匹配区域(基于1080x2400基准):
- 左上: (9, 1173)
- 右下: (1079, 2255)
使用 `assets/coupon.png` 作为模板。
参数:
pic_rgb: RGB格式的整屏截图
return_info: 是否返回详细信息(包含检测分数)
template_threshold: 模板匹配阈值(默认0.75,如果提供则使用,否则从analyser读取)
analyser: analyser对象,用于读取配置阈值
返回:
bool: 是否检测到优惠券背景(return_info=False时)
tuple[bool, dict]: (检测结果, 详细信息)(return_info=True时)
"""
try:
try:
import cv2 # type: ignore
import numpy as np # type: ignore
except Exception:
if return_info:
return False, {
"method": "template_match",
"template_score": None,
"reason": "opencv_unavailable",
}
return False
width, height = pic_rgb.size
scale_x = width / 1080.0
scale_y = height / 2400.0
x1 = int(9 * scale_x)
y1 = int(1173 * scale_y)
x2 = int(1079 * scale_x)
y2 = int(2255 * scale_y)
x1 = max(0, min(x1, width))
y1 = max(0, min(y1, height))
x2 = max(0, min(x2, width))
y2 = max(0, min(y2, height))
if x1 >= x2 or y1 >= y2:
if return_info:
return False, {
"method": "template_match",
"template_score": None,
"reason": "invalid_region",
}
return False
bgr = cv2.cvtColor(np.array(pic_rgb), cv2.COLOR_RGB2BGR)
roi = bgr[y1:y2, x1:x2] # type: ignore[index]
if roi.size == 0:
if return_info:
return False, {
"method": "template_match",
"template_score": None,
"reason": "empty_roi",
}
return False
base_dir = os.path.dirname(__file__)
template_path = os.path.join(base_dir, "assets", "coupon.png")
if not os.path.exists(template_path):
if return_info:
return False, {
"method": "template_match",
"template_score": None,
"reason": "template_not_found",
}
return False
template = cv2.imread(template_path, cv2.IMREAD_COLOR)
if template is None:
if return_info:
return False, {
"method": "template_match",
"template_score": None,
"reason": "template_load_failed",
}
return False
if roi.shape[0] < template.shape[0] or roi.shape[1] < template.shape[1]:
if return_info:
return False, {
"method": "template_match",
"template_score": None,
"reason": "template_too_large",
}
return False
res = cv2.matchTemplate(roi, template, cv2.TM_CCOEFF_NORMED)
_, max_val, _, _ = cv2.minMaxLoc(res)
# 获取阈值:优先使用传入参数,其次从analyser读取,最后使用默认值
if template_threshold is not None:
threshold = float(template_threshold)
elif analyser is not None:
try:
threshold = float(
getattr(analyser, "coupon_template_match_threshold", 0.75) or 0.75
)
except Exception:
threshold = 0.75
else:
threshold = 0.75
result = max_val >= threshold
if return_info:
return result, {
"method": "template_match",
"template_score": float(max_val),
"effective_threshold": threshold,
"reason": None if result else "score_below_threshold",
}
return result
except Exception as e:
if return_info:
return False, {
"method": "template_match",
"template_score": None,
"reason": f"exception: {str(e)}",
}
return False
def detect_redpacket_popup_background(pic_rgb: Image.Image) -> bool:
"""中央购物红包弹窗检测(暂时禁用,始终返回 False)。"""
return False
def detect_lucky_draw_result_popup(
pic_rgb: Image.Image, red_ratio_threshold: float = 0.8, return_info: bool = False
) -> bool | tuple[bool, dict]:
"""检测抽奖结果弹窗:检测指定区域的红色占比("我知道了"按钮区域)。
使用基准 1080x2400 坐标的检测区域:
- 左上: (181, 1261)
- 右下: (890, 1389)
"""
try:
width, height = pic_rgb.size
scale_x = width / 1080.0
scale_y = height / 2400.0
x1 = int(181 * scale_x)
y1 = int(1261 * scale_y)
x2 = int(890 * scale_x)
y2 = int(1389 * scale_y)
# 边界与顺序
x1, x2 = max(0, min(x1, width)), max(0, min(x2, width))
y1, y2 = max(0, min(y1, height)), max(0, min(y2, height))
if x1 > x2:
x1, x2 = x2, x1
if y1 > y2:
y1, y2 = y2, y1
if x1 >= x2 or y1 >= y2:
return False
# 双截图记录:保存实时操作截图(像素检测区域)
detect_roi = None
try:
import douyin_screenshot_manager
detect_roi = pic_rgb.crop((x1, y1, x2, y2))
douyin_screenshot_manager.save_latest_attempt(
detect_roi, operation_type="pixel_detect"
)
# 保存调试图像(检测前)- 使用全屏截图,用框框选出识别区域
debug_path = douyin_screenshot_manager.save_debug_image(
pic_rgb, # 使用全屏截图
operation_type="pixel_detect",
picname="lucky_draw_result",
step="before_detect",
coords=(x1, y1, x2, y2), # 标注识别区域
extra_info={
"threshold": red_ratio_threshold,
"region_size": f"{x2-x1}x{y2-y1}",
},
)
if debug_path:
try:
import logging
logging.info(
f"[调试图像] 像素检测前保存: {debug_path}, threshold={red_ratio_threshold}"
)
except Exception:
pass
except Exception:
pass
red_count = 0
total_samples = 0
step_x = max(1, (x2 - x1) // 10)
step_y = max(1, (y2 - y1) // 10)
for y in range(y1, y2, step_y):
for x in range(x1, x2, step_x):
try:
r, g, b = pic_rgb.getpixel((x, y))
total_samples += 1
# 根据实际检测结果:R: 245-255, G: 44-255, B: 85-255
# 红色按钮检测:R >= 245 且 R 明显大于 G 和 B
if r >= 245 and r <= 255 and (r - g) >= 50 and (r - b) >= 50:
red_count += 1
except Exception:
continue
if total_samples == 0:
return False
red_ratio = red_count / total_samples
result = red_ratio >= red_ratio_threshold
# 保存调试图像(检测结果)- 使用全屏截图,用框框选出识别区域
try:
import douyin_screenshot_manager
if result:
# 检测成功
if detect_roi is None:
detect_roi = pic_rgb.crop((x1, y1, x2, y2))
douyin_screenshot_manager.save_last_success(
detect_roi, operation_type="pixel_detect"
)
# 无论成功失败都保存debug截图
debug_path = douyin_screenshot_manager.save_debug_image(
pic_rgb, # 使用全屏截图
operation_type="pixel_detect",
picname="lucky_draw_result",
step="detected" if result else "not_detected",
coords=(x1, y1, x2, y2), # 标注识别区域
extra_info={
"red_ratio": round(red_ratio, 4),
"red_count": red_count,
"total_samples": total_samples,
"threshold": red_ratio_threshold,
"result": "success" if result else "failed",
},
)
if debug_path:
try:
import logging
logging.info(
f"[调试图像] 抽奖结果检测保存: {debug_path}, red_ratio={red_ratio:.4f}, threshold={red_ratio_threshold}, score={red_ratio:.4f}"
)
except Exception:
pass
except Exception:
pass
# 如果请求详细信息,返回包含red_ratio的字典
if return_info:
return result, {
"method": "pixel_detect",
"red_ratio": red_ratio,
"red_count": red_count,
"total_samples": total_samples,
"effective_threshold": red_ratio_threshold,
"reason": None if result else "red_ratio_below_threshold",
}
return result
except Exception:
return False
def detect_attend_button_red_area(
pic_rgb: Image.Image,
return_info: bool = False,
red_ratio_threshold: float | None = None,
analyser: Any = None,
) -> bool | tuple[bool, dict]:
"""检测参与按钮:大片红色区域。
参与按钮通常在屏幕底部,有大片红色背景。
检测区域:(306,2030)-(780,2110) 基准1080x2400,但实际可能更宽
扩展检测区域到更宽的范围以覆盖"一键参与评论"等按钮
"""
try:
width, height = pic_rgb.size
# 缩放坐标到实际尺寸
scale_x = width / 1080.0
scale_y = height / 2400.0
# 检测区域(基准1080x2400,扩展宽度以覆盖更宽的按钮)
x1 = int(200 * scale_x) # 扩展左侧
y1 = int(2000 * scale_y) # 稍微上移
x2 = int(880 * scale_x) # 扩展右侧
y2 = int(2120 * scale_y) # 稍微下移
# 确保坐标在范围内
x1 = max(0, min(x1, width))
y1 = max(0, min(y1, height))
x2 = max(0, min(x2, width))
y2 = max(0, min(y2, height))
if x1 >= x2 or y1 >= y2:
return False
# 保存调试图像(检测前)- 使用全屏截图,用框框选出识别区域
try:
import douyin_screenshot_manager
debug_path = douyin_screenshot_manager.save_debug_image(
pic_rgb, # 使用全屏截图
operation_type="pixel_detect",
picname="attend_button",
step="before_detect",
coords=(x1, y1, x2, y2), # 标注识别区域
extra_info={"region_size": f"{x2-x1}x{y2-y1}"},
)
if debug_path:
try:
import logging
logging.info(f"[调试图像] 参与按钮检测前保存: {debug_path}")
except Exception:
pass
except Exception:
pass
# 采样检测点:检测大片红色区域
red_count = 0
sample_points = []
step_x = max(1, (x2 - x1) // 15)
step_y = max(1, (y2 - y1) // 10)
for y in range(y1, y2, step_y):
for x in range(x1, x2, step_x):
try:
r, g, b = pic_rgb.getpixel((x, y))
# 检测红色:R值高,G和B相对较低
if r > 200 and (r - g) > 50 and (r - b) > 50:
red_count += 1
except Exception:
continue
# 如果红色像素占比足够高(至少25%),认为有大片红色背景
total_samples = len(list(range(y1, y2, step_y))) * len(
list(range(x1, x2, step_x))
)
if total_samples == 0:
return False
red_ratio = red_count / total_samples if total_samples > 0 else 0
# 获取阈值:优先使用传入参数,其次从analyser读取,最后使用默认值
if red_ratio_threshold is not None:
threshold = float(red_ratio_threshold)
elif analyser is not None:
try:
threshold = float(
getattr(analyser, "attend_button_red_ratio_threshold", 0.25) or 0.25
)
except Exception:
threshold = 0.25
else:
threshold = 0.25
result = red_ratio >= threshold
# 如果请求详细信息,返回包含red_ratio的字典
if return_info:
return result, {
"method": "pixel_detect",
"red_ratio": red_ratio,
"red_count": red_count,
"total_samples": total_samples,
"effective_threshold": threshold,
"reason": None if result else "red_ratio_below_threshold",
}
# 保存调试图像(检测结果)- 使用全屏截图,用框框选出识别区域
if result:
try:
import douyin_screenshot_manager
debug_path = douyin_screenshot_manager.save_debug_image(
pic_rgb, # 使用全屏截图
operation_type="pixel_detect",
picname="attend_button",
step="detected",
coords=(x1, y1, x2, y2), # 标注识别区域
extra_info={
"red_ratio": round(red_ratio, 4),
"red_count": red_count,
"total_samples": total_samples,
"result": "success",
},
)
if debug_path:
try:
import logging
logging.info(
f"[调试图像] 参与按钮检测成功保存: {debug_path}, red_ratio={red_ratio:.4f}, score={red_ratio:.4f}"
)
except Exception:
pass
except Exception:
pass
return result
except Exception:
if return_info:
return False, {
"method": "pixel_detect",
"red_ratio": None,
"reason": "exception",
}
return False
def detect_fansclub_join_red_area(
pic_rgb: Image.Image,
return_info: bool = False,
red_ratio_threshold: float | None = None,
analyser: Any = None,
) -> bool | tuple[bool, dict]:
"""检测粉丝团加入:大片红色区域。
粉丝团加入按钮通常在屏幕中下部,有大片红色背景。
检测区域:(200,1940)-(880,2140) 基准1080x2400
"""
try:
width, height = pic_rgb.size
# 缩放坐标到实际尺寸
scale_x = width / 1080.0
scale_y = height / 2400.0
# 检测区域(基准1080x2400)
x1 = int(200 * scale_x)
y1 = int(1940 * scale_y)
x2 = int(880 * scale_x)
y2 = int(2140 * scale_y)
# 确保坐标在范围内
x1 = max(0, min(x1, width))
y1 = max(0, min(y1, height))
x2 = max(0, min(x2, width))
y2 = max(0, min(y2, height))
if x1 >= x2 or y1 >= y2:
if return_info:
return False, {
"method": "pixel_detect",
"red_ratio": None,
"reason": "invalid_region",
}
return False
# 采样检测点:检测大片红色区域
red_count = 0
sample_points = []
step_x = max(1, (x2 - x1) // 15)
step_y = max(1, (y2 - y1) // 10)
for y in range(y1, y2, step_y):
for x in range(x1, x2, step_x):
try:
r, g, b = pic_rgb.getpixel((x, y))
# 检测红色:R值高,G和B相对较低
if r > 200 and (r - g) > 50 and (r - b) > 50:
red_count += 1
except Exception:
continue
# 如果红色像素占比足够高(至少25%),认为有大片红色背景
total_samples = len(list(range(y1, y2, step_y))) * len(
list(range(x1, x2, step_x))
)
if total_samples == 0:
if return_info:
return False, {
"method": "pixel_detect",
"red_ratio": None,
"reason": "no_samples",
}
return False
red_ratio = red_count / total_samples if total_samples > 0 else 0
# 获取阈值:优先使用传入参数,其次从analyser读取,最后使用默认值
if red_ratio_threshold is not None:
threshold = float(red_ratio_threshold)
elif analyser is not None:
try:
threshold = float(
getattr(analyser, "fansclub_join_red_ratio_threshold", 0.25) or 0.25
)
except Exception:
threshold = 0.25
else:
threshold = 0.25
result = red_ratio >= threshold
if return_info:
return result, {
"method": "pixel_detect",
"red_ratio": red_ratio,
"red_count": red_count,
"total_samples": total_samples,
"effective_threshold": threshold,
"reason": None if result else "red_ratio_below_threshold",
}
return result
except Exception:
if return_info:
return False, {
"method": "pixel_detect",
"red_ratio": None,
"reason": "exception",
}
return False
def detect_live_room_icons_by_pixel(pic_rgb: Image.Image) -> tuple[bool, float]:
"""通过像素检测右上角x和xin图标区域,判断是否在直播间。
检测右上角区域(60%-100%宽度,0%-40%高度)的像素特征:
- x图标:通常是白色或浅色的X形状
- xin图标:通常是粉色/红色的心形图标
返回:
(detected, confidence) 其中 confidence 为置信度(0.0~1.0)
"""
try:
width, height = pic_rgb.size
# 缩放坐标到实际尺寸(基于1080x2400)
scale_x = width / 1080.0
scale_y = height / 2400.0
# 检测区域:右上角(60%-100%宽度,0%-40%高度)
x1 = int(648 * scale_x) # 60%宽度 = 648
y1 = 0
x2 = width # 100%宽度
y2 = int(960 * scale_y) # 40%高度 = 960
# 确保坐标在范围内
x1 = max(0, min(x1, width))
y1 = max(0, min(y1, height))
x2 = max(0, min(x2, width))
y2 = max(0, min(y2, height))
if x1 >= x2 or y1 >= y2:
return False, 0.0
# 采样检测点
step_x = max(1, (x2 - x1) // 20)
step_y = max(1, (y2 - y1) // 20)
# 检测特征:
# 1. 白色/浅色像素(x图标)
# 2. 粉色/红色像素(xin图标)
white_count = 0
pink_red_count = 0
total_samples = 0
for y in range(y1, y2, step_y):
for x in range(x1, x2, step_x):
try:
r, g, b = pic_rgb.getpixel((x, y))
total_samples += 1
# 检测白色/浅色(x图标):RGB值都较高且接近
if (
r > 200
and g > 200
and b > 200
and abs(r - g) < 30
and abs(g - b) < 30
):
white_count += 1
# 检测粉色/红色(xin图标):R值高,G和B相对较低
if r > 200 and (r - g) > 50 and (r - b) > 50:
pink_red_count += 1
except Exception:
continue
if total_samples == 0:
return False, 0.0
# 计算置信度
white_ratio = white_count / total_samples if total_samples > 0 else 0
pink_red_ratio = pink_red_count / total_samples if total_samples > 0 else 0
# 如果白色或粉色/红色像素占比足够高,认为检测到图标
# 阈值:白色>=5% 或 粉色/红色>=3%
detected = white_ratio >= 0.05 or pink_red_ratio >= 0.03
# 计算置信度(基于检测到的像素比例)
confidence = min(1.0, max(white_ratio * 10, pink_red_ratio * 15))
return detected, confidence
except Exception:
return False, 0.0
def detect_fudai_detail_page(
pic_rgb: Image.Image,
resolution_ratio_x: int = 1080,
resolution_ratio_y: int = 2400,
y_pianyi: int = 0,
template_threshold: float = 0.7,
return_info: bool = False,
analyser: Any = None,
) -> bool | tuple[bool, dict]:
"""检测是否处于福袋详情页。
检测策略:任务数量检测
1. 通过检测任务数量来判断是否在福袋详情页
2. 如果任务数量 <= 0,则认为不在福袋详情页
3. 如果任务数量 >= 1,则认为在福袋详情页,并返回任务数量
参数:
pic_rgb: RGB格式的整屏截图(保留用于兼容性,实际不使用)
resolution_ratio_x: 分辨率X比例(默认1080,保留用于兼容性)
resolution_ratio_y: 分辨率Y比例(默认2400,保留用于兼容性)
y_pianyi: Y轴偏移(默认0,保留用于兼容性)
template_threshold: 模板匹配阈值(保留用于兼容性,不再使用)
return_info: 是否返回详细信息(包含任务数量)
analyser: 分析器对象(必需,用于任务数量检测)
返回:
bool: 是否检测到福袋详情页(return_info=False时)
tuple[bool, dict]: (检测结果, 详细信息)(return_info=True时)
详细信息包含:
- method: 检测方法("task_count")
- task_count: 任务数量(0/1/2/3)
"""
# ---------- 任务数量检测 ----------
if analyser is None:
# analyser 参数必需
if return_info:
return False, {
"method": "task_count",
"task_count": 0,
"reason": "analyser_required",
}
return False
try:
from douyin_detection import check_detail_height
# 执行任务数量检测
task_count = int(check_detail_height(analyser) or 0)
# 判断是否在福袋详情页
# 如果任务数量 <= 0,则认为不在福袋详情页
# 如果任务数量 >= 1,则认为在福袋详情页
is_in_detail = task_count >= 1
if return_info:
return is_in_detail, {
"method": "task_count",
"task_count": task_count,
}
return is_in_detail
except Exception as e:
# 检测异常
if return_info:
return False, {
"method": "task_count",
"task_count": 0,
"reason": f"detection_exception: {str(e)}",
}
return False
def read_pixel_stage_state_from_screenshot(
pic_path: str,
resolution_ratio_x: int = 1080,
resolution_ratio_y: int = 2400,
y_pianyi: int = 0,
lucky_draw_red_ratio_threshold: float = 0.8,
fudai_template_threshold: float = 0.7,
return_details: bool = False,
analyser: Any = None,
) -> dict[str, bool] | tuple[dict[str, bool], dict[str, dict]]:
"""从 screenshot.png 读取"阶段诊断"需要的多区域像素特征(不调用 OCR)。
使用多线程并行执行所有检测函数以提高性能。
参数:
pic_path: 截图路径
resolution_ratio_x: 分辨率X比例(默认1080)
resolution_ratio_y: 分辨率Y比例(默认2400)
y_pianyi: Y轴偏移(默认0)
lucky_draw_red_ratio_threshold: 抽奖结果红色比例阈值(默认0.8)
fudai_template_threshold: 福袋详情模板匹配阈值(默认0.7)
return_details: 是否返回每个检测步骤的详细信息(包括分数)
返回:
dict[str, bool]: 检测结果(return_details=False时)
tuple[dict[str, bool], dict[str, dict]]: (检测结果, 详细信息)(return_details=True时)
"""
state: dict[str, bool] = {
"has_coupon_bg": False,
"has_redpacket_bg": False,
"has_lucky_draw_result": False,
"has_attend_button_red": False,
"has_fansclub_join_red": False,
"has_fudai_detail": False,
}
details: dict[str, dict] = {}
pic_rgb = _safe_open_screenshot_rgb(pic_path)
if pic_rgb is None:
if return_details:
return state, details
return state
# 并行执行所有检测函数
# 注意:优惠券检测需要额外参数,使用lambda包装
# 注意:福袋详情检测使用任务数量检测,需要analyser参数
# 从analyser读取阈值(如果可用)
coupon_threshold = None
attend_button_threshold = None
fansclub_threshold = None
if analyser is not None:
try:
coupon_threshold = float(
getattr(analyser, "coupon_template_match_threshold", None) or 0.75
)
except Exception:
pass
try:
attend_button_threshold = float(
getattr(analyser, "attend_button_red_ratio_threshold", None) or 0.25
)
except Exception:
pass
try:
fansclub_threshold = float(
getattr(analyser, "fansclub_join_red_ratio_threshold", None) or 0.25
)
except Exception:
pass
detection_tasks = {
"has_coupon_bg": lambda pic: detect_coupon_popup_background(
pic,
return_info=True,
template_threshold=coupon_threshold,
analyser=analyser,
),
"has_redpacket_bg": detect_redpacket_popup_background,
"has_lucky_draw_result": lambda pic: detect_lucky_draw_result_popup(
pic, lucky_draw_red_ratio_threshold, return_info=True
),
"has_attend_button_red": lambda pic: detect_attend_button_red_area(
pic,
return_info=True,
red_ratio_threshold=attend_button_threshold,
analyser=analyser,
),
"has_fansclub_join_red": lambda pic: detect_fansclub_join_red_area(
pic,
return_info=True,
red_ratio_threshold=fansclub_threshold,
analyser=analyser,
),
"has_fudai_detail": lambda pic: detect_fudai_detail_page(
pic,
resolution_ratio_x,
resolution_ratio_y,
y_pianyi,
fudai_template_threshold,
return_info=True,
analyser=analyser,
),
}
# 使用线程池并行执行检测
with ThreadPoolExecutor(max_workers=6) as executor:
# 提交所有任务
future_to_key = {
executor.submit(detect_func, pic_rgb): key
for key, detect_func in detection_tasks.items()
}
# 收集结果
for future in as_completed(future_to_key):
key = future_to_key[future]
try:
result = future.result()
# 处理结果
if isinstance(result, tuple):
# 检测函数返回 (bool, dict) 格式
is_detected, info = result
state[key] = bool(is_detected)
if return_details:
details[key] = {
"detected": bool(is_detected),
"method": info.get("method", "unknown"),
"template_score": info.get("template_score"),
"task_count": info.get("task_count"), # 添加task_count支持
"red_ratio": info.get("red_ratio"), # 添加red_ratio支持
"effective_threshold": info.get("effective_threshold"),
"reason": info.get("reason"),
}
else:
# 其他检测返回 bool(不应该发生,因为所有检测都支持return_info)
state[key] = bool(result)
if return_details:
details[key] = {
"detected": bool(result),
"method": "unknown",
}
except Exception as e:
# 如果某个检测失败,保持默认值 False
state[key] = False
if return_details:
details[key] = {
"detected": False,
"error": str(e),
}
if return_details:
return state, details
return state