Feibo.AntiCAP 3.3.6__tar.gz

feibo_anticap-3.3.6/AntiCAP/__init__.py

@@ -0,0 +1,5 @@
+# coding=utf-8
+from .core import Handler
+from .utils.exceptions import AntiCAPException
+
+__all__ = ['Handler', 'AntiCAPException']

feibo_anticap-3.3.6/AntiCAP/core.py

@@ -0,0 +1,116 @@
+# coding=utf-8
+
+import logging
+
+from AntiCAP.utils.common import get_model_path
+from .utils.manager import ModelManager
+from .modules import ocr, math_solver, detection, click, slider, similarity, rotation, geetest
+
+class Handler(object):
+    logging.getLogger('ultralytics').setLevel(logging.WARNING)
+
+    def __init__(self, show_banner=True):
+        self.manager = ModelManager()
+        
+        if show_banner:
+            print('''
+            -----------------------------------------------------------  
+            |      _              _     _    ____      _      ____    |
+            |     / \     _ __   | |_  (_)  / ___|    / \    |  _ \   |
+            |    / _ \   | '_ \  | __| | | | |       / _ \   | |_) |  |
+            |   / ___ \  | | | | | |_  | | | |___   / ___ \  |  __/   |
+            |  /_/   \_\ |_| |_|  \__| |_|  \____| /_/   \_\ |_|      |
+            ----------------------------------------------------------- 
+            |         Github: https://github.com/81NewArk/AntiCAP     |
+            |         Blog  : https://www.newark81.vip/               |          
+            |         Author: 81NewArk                                |       
+            -----------------------------------------------------------''')
+
+    # 文字识别
+    def OCR(self, img_base64: str = None, use_gpu: bool = False, png_fix: bool = False, probability=False):
+        return ocr.solve_ocr(self.manager, img_base64, use_gpu, png_fix, probability)
+
+    # 算术识别
+    def Math(self, img_base64: str, math_model_path: str = '', use_gpu: bool = False):
+        return math_solver.solve_math(self.manager, img_base64, math_model_path, use_gpu)
+
+    # 图标侦测
+    def Detection_Icon(self, img_base64: str = None, detectionIcon_model_path: str = '', use_gpu: bool = False):
+        return detection.solve_detection_icon(self.manager, img_base64, detectionIcon_model_path, use_gpu)
+
+    # 按序侦测图标
+    def ClickIcon_Order(self, order_img_base64: str, target_img_base64: str, detectionIcon_model_path: str = '', sim_onnx_model_path: str = '', use_gpu: bool = False):
+        return click.solve_click_icon_order(self.manager, order_img_base64, target_img_base64, detectionIcon_model_path, sim_onnx_model_path, use_gpu)
+
+    # 文字侦测
+    def Detection_Text(self, img_base64: str = None, detectionText_model_path: str = '', use_gpu: bool = False):
+        return detection.solve_detection_text(self.manager, img_base64, detectionText_model_path, use_gpu)
+
+    # 按序侦测文字
+    def ClickText_Order(self, order_img_base64: str, target_img_base64: str, detectionText_model_path: str = '', sim_onnx_model_path: str = '', use_gpu: bool = False):
+        return click.solve_click_text_order(self.manager, order_img_base64, target_img_base64, detectionText_model_path, sim_onnx_model_path, use_gpu)
+
+    # 缺口滑块
+    def Slider_Match(self, target_base64: str = None, background_base64: str = None, simple_target: bool = False, flag: bool = False):
+        return slider.solve_slider_match(self.manager, target_base64, background_base64, simple_target, flag)
+
+    # 阴影滑块
+    def Slider_Comparison(self, target_base64: str = None, background_base64: str = None):
+        return slider.solve_slider_comparison(self.manager, target_base64, background_base64)
+
+    # 图像相似度比较
+    def Compare_Image_Similarity(self, image1_base64: str, image2_base64: str, sim_onnx_model_path: str = None, use_gpu: bool = False):
+        return similarity.solve_compare_image_similarity(self.manager, image1_base64, image2_base64, sim_onnx_model_path, use_gpu)
+
+    # 单图旋转角度
+    def Single_Rotate(self, img_base64: str, rotate_onnx_modex_path: str = '', use_gpu: bool = False):
+        return rotation.solve_single_rotate(self.manager, img_base64, rotate_onnx_modex_path, use_gpu)
+
+    # 双图旋转
+    def Double_Rotate(self, inside_base64: str, outside_base64: str, check_pixel: int = 10, speed_ratio: float = 1, grayscale: bool = False, anticlockwise: bool = False, cut_pixel_value: int = 0):
+        return rotation.solve_double_rotate(self.manager, inside_base64, outside_base64, check_pixel, speed_ratio, grayscale, anticlockwise, cut_pixel_value)
+
+    # 极验滑块
+    def Geetest_SlideCAPTCHA(self, img_base64: str, use_gpu: bool = False):
+        return geetest.SlideCAPTCHA(self.manager, img_base64, use_gpu)
+
+    # 极验图标点选 - 图标识别
+    def Geetest_IconClick_Icon(self, img_base64: str, model_path: str = '', use_gpu: bool = False):
+        """
+        识别极验图标点选验证码中的图标
+
+        使用 GeetestIconClick_Icon.pt 模型检测图片中的所有图标，
+        返回每个图标的类别、位置和置信度。
+
+        Args:
+            img_base64: base64 编码的验证码图片
+            model_path: 自定义模型路径（可选，默认使用内置模型）
+            use_gpu: 是否使用 GPU 推理
+
+        Returns:
+            list: [{'class': str, 'box': [x1,y1,x2,y2], 'confidence': float}, ...]
+        """
+        return geetest.IconClick_Icon(self.manager, img_base64, model_path, use_gpu)
+
+    # 极验图标点选 - 图标相似度比较 (ICONCNN)
+    def Geetest_IconClick_Similarity(self, img1_base64: str, img2_base64: str, model_path: str = '', use_gpu: bool = False):
+        """
+        使用 ICONCNN 模型比较两张极验图标的相似度
+
+        通过 GeetestIconClick_Group_Icon-ICONCNN.onnx 模型提取两张图片的特征向量，
+        计算余弦相似度，并返回匹配结果与置信度。
+
+        Args:
+            img1_base64: 第一张图标的 base64 编码
+            img2_base64: 第二张图标的 base64 编码
+            model_path: 自定义模型路径（可选，默认使用内置 ICONCNN 模型）
+            use_gpu: 是否使用 GPU 推理
+
+        Returns:
+            dict: {'similarity': float, 'is_match': bool, 'confidence': str}
+        """
+        model_path = model_path or get_model_path('GeetestIconClick_Group_Icon-ICONCNN.onnx')
+        return geetest.IconClick_Similarity(self.manager, img1_base64, img2_base64, model_path, use_gpu)
+    def Geetest_IconClick_Similarity2(self, img1_base64: str, img2_base64: str, model_path: str = '', use_gpu: bool = False):
+        model_path=  model_path or get_model_path('GeetestIconClick_Group_Icon-ICONCNN.onnx')
+        return similarity.solve_compare_image_similarity(self.manager, img1_base64, img2_base64, model_path , use_gpu)

feibo_anticap-3.3.6/AntiCAP/modules/__init__.py

@@ -0,0 +1,8 @@
+from . import ocr
+from . import math_solver
+from . import detection
+from . import click
+from . import slider
+from . import similarity
+from . import rotation
+from . import geetest

feibo_anticap-3.3.6/AntiCAP/modules/click.py

@@ -0,0 +1,113 @@
+import numpy as np
+from scipy.optimize import linear_sum_assignment
+from .similarity import get_siamese_similarity
+from ..utils.common import get_model_path, decode_base64_to_image
+
+
+def handle_matching(manager, order_image, target_image, order_boxes_list, target_boxes_list, siamese_model_path, use_gpu, sim_onnx_model_path):
+    """
+    通用匹配处理函数，使用匈牙利算法（Hungarian Algorithm）求解全局最优匹配
+    """
+    if not order_boxes_list or not target_boxes_list:
+        return [[0, 0, 0, 0]] * len(order_boxes_list)
+
+    num_orders = len(order_boxes_list)
+    num_targets = len(target_boxes_list)
+    
+    # 1. 构建相似度矩阵 (Cost Matrix)
+    # 我们希望总相似度最大，linear_sum_assignment 是求最小开销，所以存入负的相似度
+    cost_matrix = np.zeros((num_orders, num_targets))
+
+    for i, order_box in enumerate(order_boxes_list):
+        order_crop = order_image.crop(order_box)
+        if order_crop.width == 0 or order_crop.height == 0:
+            continue
+            
+        for j, target_box in enumerate(target_boxes_list):
+            target_crop = target_image.crop(target_box)
+            if target_crop.width == 0 or target_crop.height == 0:
+                continue
+                
+            similarity_score = get_siamese_similarity(
+                manager, order_crop, target_crop, 
+                siamese_model_path, use_gpu, 
+                is_custom_model=bool(sim_onnx_model_path)
+            )
+            # 记录分值 (由于求解器求最小，我们存负值)
+            cost_matrix[i, j] = -similarity_score
+
+    # 2. 执行匈牙利算法求解
+    # row_ind 会对应 order_boxes_list 的索引，col_ind 会对应最优匹配的 target_boxes_list 索引
+    row_ind, col_ind = linear_sum_assignment(cost_matrix)
+
+    # 3. 构造返回结果，保持与 order_boxes_list 顺序一致
+    # 初始化全 0 结果
+    best_matching_boxes = [[0, 0, 0, 0]] * num_orders
+    
+    # 填充结果
+    # 注意：如果目标比候选框多，这里的 row_ind/col_ind 只会包含匹配上的部分
+    for r, c in zip(row_ind, col_ind):
+        # 即使匹配上了，如果得分太低（例如相似度为 0），也可以视作无效匹配
+        # 这里保留原逻辑的灵活性，目前只要有匹配索引就写入
+        target_box = target_boxes_list[c]
+        best_matching_boxes[r] = [int(coord) for coord in target_box]
+
+    return best_matching_boxes
+
+
+def solve_click_icon_order(manager, order_img_base64: str, target_img_base64: str, detectionIcon_model_path: str = '', sim_onnx_model_path: str = '', use_gpu: bool = False):
+    detectionIcon_model_path = detectionIcon_model_path or get_model_path('[AntiCAP]-Detection_Icon-YOLO.pt')
+    
+    if sim_onnx_model_path:
+        siamese_model_path = sim_onnx_model_path
+    else:
+        siamese_model_path = get_model_path('[AntiCAP]-Siamese-ResNet18.onnx')
+
+    model = manager.get_yolo_model(detectionIcon_model_path, use_gpu)
+
+    order_image = decode_base64_to_image(order_img_base64).convert("RGB")
+    target_image = decode_base64_to_image(target_img_base64).convert("RGB")
+
+    order_results = model(order_image, verbose=False)
+    target_results = model(target_image, verbose=False)
+
+    order_boxes_list = []
+    if order_results and order_results[0].boxes:
+        order_boxes = order_results[0].boxes.xyxy.cpu().numpy().tolist()
+        order_boxes.sort(key=lambda x: x[0])  # 按提示图的 X 坐标排序（通常文字提示是从左到右的）
+        order_boxes_list = order_boxes
+
+    target_boxes_list = []
+    if target_results and target_results[0].boxes:
+        target_boxes_list = target_results[0].boxes.xyxy.cpu().numpy().tolist()
+
+    return handle_matching(manager, order_image, target_image, order_boxes_list, target_boxes_list, siamese_model_path, use_gpu, sim_onnx_model_path)
+
+
+def solve_click_text_order(manager, order_img_base64: str, target_img_base64: str, detectionText_model_path: str = '', sim_onnx_model_path: str = '', use_gpu: bool = False):
+    detectionText_model_path = detectionText_model_path or get_model_path('[AntiCAP]-Detection_Text-YOLO.pt')
+    
+    if sim_onnx_model_path:
+        siamese_model_path = sim_onnx_model_path
+    else:
+        siamese_model_path = get_model_path('[AntiCAP]-Siamese-ResNet18.onnx')
+
+    model = manager.get_yolo_model(detectionText_model_path, use_gpu)
+
+    order_image = decode_base64_to_image(order_img_base64).convert("RGB")
+    target_image = decode_base64_to_image(target_img_base64).convert("RGB")
+
+    order_results = model(order_image, verbose=False)
+    target_results = model(target_image, verbose=False)
+
+    order_boxes_list = []
+    if order_results and order_results[0].boxes:
+        order_boxes = order_results[0].boxes.xyxy.cpu().numpy().tolist()
+        order_boxes.sort(key=lambda x: x[0])
+        order_boxes_list = order_boxes
+
+    target_boxes_list = []
+    if target_results and target_results[0].boxes:
+        target_boxes_list = target_results[0].boxes.xyxy.cpu().numpy().tolist()
+
+    return handle_matching(manager, order_image, target_image, order_boxes_list, target_boxes_list, siamese_model_path, use_gpu, sim_onnx_model_path)

feibo_anticap-3.3.6/AntiCAP/modules/detection.py

@@ -0,0 +1,41 @@
+from ..utils.common import get_model_path, decode_base64_to_image
+
+def solve_detection_icon(manager, img_base64: str = None, detectionIcon_model_path: str = '', use_gpu: bool = False):
+    detectionIcon_model_path = detectionIcon_model_path or get_model_path('[AntiCAP]-Detection_Icon-YOLO.pt')
+    model = manager.get_yolo_model(detectionIcon_model_path, use_gpu)
+
+    image = decode_base64_to_image(img_base64)
+
+    results = model(image)
+
+    detections = []
+    for box in results[0].boxes:
+        coords = box.xyxy[0].tolist()
+        rounded_box = [round(coord, 2) for coord in coords]
+        class_name = results[0].names[int(box.cls[0])]
+        detections.append({
+            'class': class_name,
+            'box': rounded_box
+        })
+
+    return detections
+
+def solve_detection_text(manager, img_base64: str = None, detectionText_model_path: str = '', use_gpu: bool = False):
+    detectionText_model_path = detectionText_model_path or get_model_path('[AntiCAP]-Detection_Text-YOLO.pt')
+    model = manager.get_yolo_model(detectionText_model_path, use_gpu)
+
+    image = decode_base64_to_image(img_base64).convert("RGB")
+
+    results = model(image)
+
+    detections = []
+    for box in results[0].boxes:
+        coords = box.xyxy[0].tolist()
+        rounded_box = [round(coord, 2) for coord in coords]
+        class_name = results[0].names[int(box.cls[0])]
+        detections.append({
+            'class': class_name,
+            'box': rounded_box
+        })
+
+    return detections

feibo_anticap-3.3.6/AntiCAP/modules/geetest.py

@@ -0,0 +1,221 @@
+# -*- coding: utf-8 -*-
+"""
+极验验证码识别模块
+
+包含两种极验验证码的识别功能：
+1. SlideCAPTCHA: 极验滑块验证码缺口识别
+   - 使用 YOLO ONNX 模型识别极验滑块验证码中的缺口位置
+   - 模型输出格式为 [x, y, w, h, confidence]，通过 NMS 去重后返回缺口坐标
+
+2. IconClick_Icon: 极验图标点选验证码的图标识别
+   - 使用 YOLO PT 模型识别极验图标点选验证码中的图标位置和类别
+   - 返回每个图标的类别名称、位置坐标和置信度
+   - 可用于按顺序点选图标等场景
+
+3. IconClick_GroupIcon: 极验图标点选验证码的图标相似度比较
+   - 使用 GeetestIconClick_Group_Icon-ICONCNN.onnx 模型提取图标特征向量
+   - 计算两张图片的余弦相似度，判断是否匹配及置信度
+"""
+
+import numpy as np
+import cv2
+from PIL import Image
+import torch
+import torch.nn.functional as F
+
+
+from AntiCAP.modules import similarity
+from ..utils.common import get_model_path, decode_base64_to_image
+
+
+def SlideCAPTCHA(manager, img_base64: str, use_gpu: bool = False):
+    """
+    识别极验滑块验证码的缺口位置
+
+    Args:
+        manager: ModelManager 实例，用于管理 ONNX 模型会话
+        img_base64: base64 编码的验证码图片字符串
+        use_gpu: 是否使用 GPU 进行推理
+
+    Returns:
+        list: 缺口坐标 [x1, y1, x2, y2]，未检测到则返回空列表
+              x1, y1 为左上角坐标，x2, y2 为右下角坐标
+    """
+    # 获取模型路径并创建 ONNX 推理会话
+    model_path = get_model_path('GeetestSlideCAPTCHA.onnx')
+    session = manager.get_onnx_session(model_path, use_gpu)
+
+    # 解码 base64 图片并转换为 RGB 格式
+    img = decode_base64_to_image(img_base64).convert("RGB")
+
+    # 获取模型输入尺寸，优先从模型元数据中读取，默认 640x640
+    input_meta = session.get_inputs()[0]
+    if len(input_meta.shape) == 4 and isinstance(input_meta.shape[2], int) and isinstance(input_meta.shape[3], int):
+        input_size = (input_meta.shape[3], input_meta.shape[2])  # (width, height)
+    else:
+        input_size = (640, 640)
+
+    # 记录原始图片尺寸，用于后续坐标还原
+    orig_w, orig_h = img.size
+
+    # 将图片缩放到模型输入尺寸，使用 LANCZOS 插值保持清晰度
+    img_resized = img.resize(input_size, Image.Resampling.LANCZOS)
+
+    # 图片预处理：归一化到 [0, 1] -> 转换为 CHW 格式 -> 添加 batch 维度
+    img_np = np.array(img_resized, dtype=np.float32) / 255.0
+    img_np = img_np.transpose(2, 0, 1)  # HWC -> CHW
+    img_np = np.expand_dims(img_np, axis=0)  # 添加 batch 维度
+
+    # 执行 ONNX 推理
+    ort_inputs = {session.get_inputs()[0].name: img_np}
+    outputs = session.run(None, ort_inputs)
+    output = outputs[0]
+
+    # 解析模型输出
+    # 输出格式: [batch, 5, anchors] -> 转置为 [anchors, 5]
+    # 每个 anchor 包含 [cx, cy, w, h, confidence]
+    detections = []
+    if output.ndim == 3:
+        output = output[0].T  # 取第一个 batch 并转置
+
+    # 遍历所有预测框，过滤低置信度的结果
+    for detection in output:
+        cx, cy, w, h, confidence = detection[0], detection[1], detection[2], detection[3], detection[4]
+        if confidence > 0.25:  # 置信度阈值
+            # 将中心点坐标 (cx, cy) 和宽高 (w, h) 转换为左上角和右下角坐标 (x1, y1, x2, y2)
+            # 同时将坐标从模型输入尺寸映射回原始图片尺寸
+            x1 = (cx - w / 2) * (orig_w / input_size[0])
+            y1 = (cy - h / 2) * (orig_h / input_size[1])
+            x2 = (cx + w / 2) * (orig_w / input_size[0])
+            y2 = (cy + h / 2) * (orig_h / input_size[1])
+
+            detections.append({
+                'class': 'quekou',  # 缺口类别
+                'box': [x1, y1, x2, y2],
+                'confidence': float(confidence)
+            })
+
+    # 使用 NMS（非极大值抑制）去除重叠的检测框
+    # YOLO 模型会对同一目标产生多个重叠框，NMS 可以保留最优的一个
+    if len(detections) > 1:
+        boxes = np.array([d['box'] for d in detections])
+        scores = np.array([d['confidence'] for d in detections])
+        # score_threshold: 置信度阈值，nms_threshold: IoU 阈值（重叠度超过此值则抑制）
+        indices = cv2.dnn.NMSBoxes(boxes.tolist(), scores.tolist(), score_threshold=0.25, nms_threshold=0.5)
+
+        if len(indices) > 0:
+            # 兼容不同版本的 NMSBoxes 返回值格式
+            indices = indices.flatten() if hasattr(indices, 'flatten') else np.array(indices).flatten()
+            detections = [detections[i] for i in indices]
+
+    # 坐标取整并移除置信度字段
+    for det in detections:
+        det['box'] = [int(coord) for coord in det['box']]
+        del det['confidence']
+
+    # 返回最优检测框的坐标，未检测到则返回空列表
+    if len(detections) > 0:
+        return detections[0]['box']
+    return []
+
+
+def IconClick_Icon(manager, img_base64: str, model_path: str = '', use_gpu: bool = False):
+    """
+    识别极验图标点选验证码中的图标
+
+    使用 GeetestIconClick_Icon.pt YOLO 模型检测极验图标点选验证码图片中的所有图标，
+    返回每个图标的类别名称、位置坐标（左上角和右下角）和置信度。
+
+    极验图标点选验证码是一种常见的行为验证，用户需要按照给定的顺序
+    点击图片上的多个图标。该函数可以识别图片中所有可用图标及其位置，
+    结合图标排序逻辑即可完成自动点选。
+
+    Args:
+        manager: ModelManager 实例，用于管理 YOLO 模型
+        img_base64: base64 编码的验证码图片字符串
+        model_path: 自定义模型路径，默认为空时使用内置 GeetestIconClick_Detection_Icon-YOLO.pt
+        use_gpu: 是否使用 GPU 进行推理
+
+    Returns:
+        list: 检测到的图标列表，每个元素包含:
+            - class: 图标类别名称 (str)
+            - box: 图标位置 [x1, y1, x2, y2] (左上角和右下角坐标)
+            - confidence: 检测置信度 (float, 0-1)
+              未检测到任何图标则返回空列表
+    """
+    # 获取模型路径，优先使用自定义路径，否则使用内置 GeetestIconClick_Detection_Icon-YOLO.pt
+    model_path = model_path or get_model_path('GeetestIconClick_Detection_Icon-YOLO.pt')
+    model = manager.get_yolo_model(model_path, use_gpu)
+
+    # 解码 base64 图片并转换为 RGB 格式（YOLO 模型需要 RGB 输入）
+    image = decode_base64_to_image(img_base64).convert("RGB")
+
+    # 执行 YOLO 模型推理
+    results = model(image)
+
+    # 解析检测结果
+    detections = []
+    for box in results[0].boxes:
+        # 获取边界框坐标 (xyxy 格式: 左上角 x, 左上角 y, 右下角 x, 右下角 y)
+        coords = box.xyxy[0].tolist()
+        rounded_box = [round(coord, 2) for coord in coords]
+
+        # 获取类别名称（从模型的 names 字典中根据类别索引获取）
+        class_name = results[0].names[int(box.cls[0])]
+
+        # 获取检测置信度
+        confidence = round(float(box.conf[0]), 4)
+
+        detections.append({
+            'class': class_name,
+            'box': rounded_box,
+            'confidence': confidence
+        })
+
+    return detections
+
+def IconClick_Similarity(manager, img1_base64: str, img2_base64: str, model_path: str = '', use_gpu: bool = False):
+    session= manager.get_onnx_session(model_path, use_gpu) 
+    input_meta = session.get_inputs()[0]
+    input_name = input_meta.name
+    if len(input_meta.shape) == 4 and isinstance(input_meta.shape[2], int) and isinstance(input_meta.shape[3], int):
+        input_size = (input_meta.shape[3], input_meta.shape[2])
+    else:
+        input_size = (224, 224)
+    def preprocess(b64):
+        # base64 解码 -> RGB 转换 -> 缩放到模型输入尺寸
+        img = decode_base64_to_image(b64).convert("RGB").resize(input_size, Image.Resampling.LANCZOS)
+        # 归一化到 [0, 1] -> HWC 转 CHW -> 添加 batch 维度 (1, C, H, W)
+        arr = np.array(img, dtype=np.float32) / 255.0
+        arr = (arr - np.array([0.485, 0.456, 0.406], dtype=np.float32)) / np.array([0.229, 0.224, 0.225], dtype=np.float32)
+        arr = arr.transpose(2, 0, 1)[np.newaxis, ...]  # (1, 3, 36, 36)
+        emb = session.run(None, {"input": arr})[0]
+        return torch.from_numpy(emb.squeeze(0))
+
+    def extract_embedding(b64):
+        tensor = preprocess(b64)
+        emb = session.run(None, {input_name: tensor})[0].flatten()
+        norm = np.linalg.norm(emb)
+        if norm > 0:
+            emb = emb / norm
+        return emb
+
+    emb1 = preprocess(img1_base64)
+    emb2 = preprocess(img2_base64)
+    sim = F.cosine_similarity(
+        emb1.unsqueeze(0), emb2.unsqueeze(0)
+    ).item()
+    threshold = 0.8
+    is_match = sim >= threshold
+    if sim > 0.9:
+        confidence = "high"
+    elif sim >= threshold:
+        confidence = "medium"
+    else:
+        confidence = "low"
+
+    return {
+        "similarity": round(sim, 4),
+        "is_match": is_match,
+        "confidence": confidence
+    }

feibo_anticap-3.3.6/AntiCAP/modules/math_solver.py

@@ -0,0 +1,62 @@
+import numpy as np
+import re
+from ..utils.common import get_model_path, decode_base64_to_image, resize_with_padding, decode
+
+def solve_math(manager, img_base64: str, math_model_path: str = '', use_gpu: bool = False):
+    math_model_path = math_model_path or get_model_path('[AntiCAP]-CRNN_Math.onnx')
+
+    session = manager.get_onnx_session(math_model_path, use_gpu)
+    input_name = session.get_inputs()[0].name
+
+
+    IMG_H = 70
+    IMG_W = 200
+    CHARS = "0123456789+-*/÷×=?"
+    
+    image = decode_base64_to_image(img_base64).convert('RGB')
+    
+
+    image = resize_with_padding(image, (IMG_W, IMG_H))
+    
+    img_np = np.array(image).astype(np.float32) / 255.0
+    img_np = np.transpose(img_np, (2, 0, 1)) # [C, H, W]
+    
+
+    img_np = (img_np - 0.5) / 0.5
+    
+
+    img_np = np.expand_dims(img_np, axis=0) # [1, C, H, W]
+
+    try:
+        ort_outs = session.run(None, {input_name: img_np})
+        preds = ort_outs[0] # Output 0
+    except Exception as e:
+        print(f"[AntiCAP] Inference error: {e}")
+        return None
+
+
+    char_map_inv = {i + 1: c for i, c in enumerate(CHARS)}
+    result_str = decode(preds, char_map_inv)[0]
+    
+    if not result_str:
+        return None
+
+
+    expr = result_str
+    expr = expr.replace('×', '*').replace('÷', '/')
+    expr = expr.replace('？', '?')
+    expr = expr.replace('=', '')
+
+
+    expr = re.sub(r'[^0-9\+\-\*/]', '', expr)
+
+    if not expr:
+        return None
+
+
+    try:
+        result = eval(expr, {"__builtins__": None}, {})
+        return result
+    except Exception as e:
+        print(f"[AntiCAP] 表达式解析出错: {expr}, 错误: {e}")
+        return None

feibo_anticap-3.3.6/AntiCAP/modules/ocr.py

@@ -0,0 +1,46 @@
+import numpy as np
+from PIL import Image
+
+from ..utils.common import get_model_path, decode_base64_to_image
+
+def solve_ocr(manager, img_base64: str, use_gpu: bool = False, png_fix: bool = False, probability=False):
+    model_path = get_model_path('[Dddd]-OCR.onnx')
+    charset_path = get_model_path('[Dddd]-CharSets.txt')
+
+    charset = manager.get_charset(charset_path)
+    session = manager.get_onnx_session(model_path, use_gpu)
+
+    image = decode_base64_to_image(img_base64)
+
+    image = image.resize((int(image.size[0] * (64 / image.size[1])), 64), Image.Resampling.LANCZOS).convert('L')
+    image = np.array(image).astype(np.float32)
+    image = np.expand_dims(image, axis=0) / 255.
+    image = (image - 0.5) / 0.5
+
+    ort_inputs = {'input1': np.array([image]).astype(np.float32)}
+    ort_outs = session.run(None, ort_inputs)
+
+    result = []
+    last_item = 0
+
+    if not probability:
+        argmax_result = np.squeeze(np.argmax(ort_outs[0], axis=2))
+        for item in argmax_result:
+            if item == last_item:
+                continue
+            else:
+                last_item = item
+            if item != 0:
+                result.append(charset[item])
+
+        return ''.join(result)
+    else:
+        ort_outs = ort_outs[0]
+        ort_outs = np.exp(ort_outs) / np.sum(np.exp(ort_outs), axis=2, keepdims=True)
+        ort_outs_probability = np.squeeze(ort_outs).tolist()
+
+        result = {
+            'charsets': charset,
+            'probability': ort_outs_probability
+        }
+        return result