CardScoreDataServer/app/utils/card_score_calculate.py

from app.utils.scheme import ImageType, CardImageResponse
from app.core.logger import get_logger
from typing import List, Dict, Any

logger = get_logger(__name__)


def calculate_scores_from_images(images: List[CardImageResponse]) -> Dict[str, Any]:
    """
    根据图片计算分数。
    已更新为新的类型名称: front_coaxial, front_ring 等。
    """
    scores = {
        "detection_score": None,
        "modified_score": None,
        "detection_score_detail": {
            "detection_center_score": None,
            "detection_corner_score": None,
            "detection_edge_score": None,
            "detection_face_score": None
        },
        "modified_score_detail": {
            "modified_center_score": None,
            "modified_corner_score": None,
            "modified_edge_score": None,
            "modified_face_score": None
        },
        "is_edited": False,
    }

    # 过滤掉灰度图，只计算主4张图
    valid_images = [img for img in images if img.image_type in [
        ImageType.front_coaxial, ImageType.back_coaxial,
        ImageType.front_ring, ImageType.back_ring
    ]]

    if len(valid_images) != 4:
        return scores

    try:
        # ---------- detection_score ----------
        detection_score = 10.0
        detection_center_score = 10.0
        detection_corner_score = 10.0
        detection_edge_score = 10.0
        detection_face_score = 10.0

        for img in valid_images:
            try:
                add_val = img.detection_json.get("result", {}).get("_used_compute_deduct_score", 0)
                detection_score += float(add_val or 0)

                if img.image_type == ImageType.front_ring:
                    center_reduct_val = img.detection_json.get("result", {}).get("center_result", {}).get(
                        "deduct_score", 0)
                    corner_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "front_corner_deduct_score", 0)
                    edge_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "front_edge_deduct_score", 0)
                    face_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "front_face_deduct_score", 0)

                    detection_center_score += float(center_reduct_val or 0)
                    detection_corner_score += float(corner_reduct_val or 0)
                    detection_edge_score += float(edge_reduct_val or 0)
                    detection_face_score += float(face_reduct_val or 0)

                elif img.image_type == ImageType.back_ring:
                    center_reduct_val = img.detection_json.get("result", {}).get("center_result", {}).get(
                        "deduct_score", 0)
                    corner_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "back_corner_deduct_score", 0)
                    edge_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "back_edge_deduct_score", 0)
                    face_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "back_face_deduct_score", 0)

                    detection_center_score += float(center_reduct_val or 0)
                    detection_corner_score += float(corner_reduct_val or 0)
                    detection_edge_score += float(edge_reduct_val or 0)
                    detection_face_score += float(face_reduct_val or 0)

                elif img.image_type == ImageType.front_coaxial:
                    face_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "front_face_deduct_score", 0)
                    detection_face_score += float(face_reduct_val or 0)

                elif img.image_type == ImageType.back_coaxial:  # 原 back_face
                    face_reduct_val = img.detection_json.get("result", {}).get("defect_result", {}).get(
                        "back_face_deduct_score", 0)
                    detection_face_score += float(face_reduct_val or 0)

            except Exception as e:
                logger.warning(f"解析 detection_json 分数失败 (image_id={img.id}): {e}")

        scores["detection_score"] = detection_score
        scores["detection_score_detail"] = {
            "detection_center_score": detection_center_score,
            "detection_corner_score": detection_corner_score,
            "detection_edge_score": detection_edge_score,
            "detection_face_score": detection_face_score,
        }

        # ---------- modified_score ----------
        modified_score = 10.0
        modified_center_score = 10.0
        modified_corner_score = 10.0
        modified_edge_score = 10.0
        modified_face_score = 10.0

        is_edited = any(img.modified_json is not None for img in valid_images)
        scores["is_edited"] = is_edited

        if is_edited:
            for img in valid_images:
                src = img.modified_json if img.modified_json is not None else img.detection_json
                try:
                    add_val = src.get("result", {}).get("_used_compute_deduct_score", 0)
                    modified_score += float(add_val or 0)

                    if img.image_type == ImageType.front_ring:
                        center_reduct_val = src.get("result", {}).get("center_result", {}).get("deduct_score", 0)
                        corner_reduct_val = src.get("result", {}).get("defect_result", {}).get(
                            "front_corner_deduct_score", 0)
                        edge_reduct_val = src.get("result", {}).get("defect_result", {}).get("front_edge_deduct_score",
                                                                                             0)
                        face_reduct_val = src.get("result", {}).get("defect_result", {}).get("front_face_deduct_score",
                                                                                             0)

                        modified_center_score += float(center_reduct_val or 0)
                        modified_corner_score += float(corner_reduct_val or 0)
                        modified_edge_score += float(edge_reduct_val or 0)
                        modified_face_score += float(face_reduct_val or 0)
                    elif img.image_type == ImageType.back_ring:
                        center_reduct_val = src.get("result", {}).get("center_result", {}).get("deduct_score", 0)
                        corner_reduct_val = src.get("result", {}).get("defect_result", {}).get(
                            "back_corner_deduct_score", 0)
                        edge_reduct_val = src.get("result", {}).get("defect_result", {}).get("back_edge_deduct_score",
                                                                                             0)
                        face_reduct_val = src.get("result", {}).get("defect_result", {}).get("back_face_deduct_score",
                                                                                             0)

                        modified_center_score += float(center_reduct_val or 0)
                        modified_corner_score += float(corner_reduct_val or 0)
                        modified_edge_score += float(edge_reduct_val or 0)
                        modified_face_score += float(face_reduct_val or 0)
                    elif img.image_type == ImageType.front_coaxial:
                        face_reduct_val = src.get("result", {}).get("defect_result", {}).get("front_face_deduct_score",
                                                                                             0)
                        modified_face_score += float(face_reduct_val or 0)
                    elif img.image_type == ImageType.back_coaxial:
                        face_reduct_val = src.get("result", {}).get("defect_result", {}).get("back_face_deduct_score",
                                                                                             0)
                        modified_face_score += float(face_reduct_val or 0)

                except Exception as e:
                    logger.warning(f"解析 modified_json 分数失败 (image_id={img.id}): {e}")

            scores["modified_score"] = modified_score
            scores["modified_score_detail"] = {
                "modified_center_score": modified_center_score,
                "modified_corner_score": modified_corner_score,
                "modified_edge_score": modified_edge_score,
                "modified_face_score": modified_face_score,
            }

    except Exception as e:
        logger.error(f"计算分数过程异常: {e}")

    return scores