面的居中不计算分数

app/services/defect_service.py

@@ -162,15 +162,24 @@ class DefectInferenceService:
             return {}
 
     # inference_type: center, face, corner_edge
-    def re_inference_from_json(self, inference_type: str, center_json: dict, defect_json: dict):
+    def re_inference_from_json(self, inference_type: str, center_json: dict, defect_json: dict) -> dict:
         inference_type_list = ["center", "face", "corner_edge"]
         if inference_type not in inference_type_list:
             logger.error(f"inference_type 只能为{inference_type_list}, 输入为{inference_type}")
             raise ValueError(f"inference_type 只能为{inference_type_list}, 输入为{inference_type}")
 
+        processor = DefectProcessor(pixel_resolution=settings.PIXEL_RESOLUTION)
+
+        # 对于面的图, 不计算居中相关, 这里得到的center_json 应该为 {}
+        if inference_type == "face":
+            area_json = processor.re_analyze_from_json(defect_json)
+            face_json_result = formate_face_data(area_json)
+            logger.info("面缺陷面积计算结束")
+
+            return face_json_result
+
         inner_result = center_json['box_result']['inner_box']
         outer_result = center_json['box_result']['outer_box']
-        processor = DefectProcessor(pixel_resolution=settings.PIXEL_RESOLUTION)
 
         if inference_type == "center":
             inner_points = inner_result['shapes'][0]['points']
@@ -181,12 +190,6 @@ class DefectInferenceService:
                                                 inner_result, outer_result,
                                                 inner_rect_box, outer_rect_box)
             return center_result
-        elif inference_type == "face":
-            area_json = processor.re_analyze_from_json(defect_json)
-            face_json_result = formate_face_data(area_json)
-            logger.info("面缺陷面积计算结束")
-
-            return face_json_result
         elif inference_type == "corner_edge":
 
             area_json: dict = processor.re_analyze_from_json(defect_json)

app/services/score_service.py

@@ -67,13 +67,14 @@ class ScoreService:
         else:
             card_defect_type = "face"
 
-        center_score_data = self.card_scorer.calculate_centering_score(card_aspect, center_data, True)
-
         if card_defect_type == 'corner_edge':
+            center_score_data = self.card_scorer.calculate_centering_score(card_aspect, center_data, True)
+
             # 先计算角的分数, 会把分数写入json, 然后传入刚写好的, 继续写边的分数
             corner_score_data = self.card_scorer.calculate_defect_score('corner', card_aspect, defect_data, True)
             defect_score_data = self.card_scorer.calculate_defect_score('edge', card_aspect, corner_score_data, True)
         elif card_defect_type == 'face':
+            center_score_data = {}
             defect_score_data = self.card_scorer.calculate_defect_score('face', card_aspect, defect_data, True)
         else:
             return {}
@@ -93,44 +94,44 @@ class ScoreService:
         center_json_data = json_data["result"]['center_result']
         defect_json_data = json_data["result"]['defect_result']
 
-        logger.info("开始进行居中信息重计算")
-        center_data = self.defect_service.re_inference_from_json(inference_type="center",
-                                                                 center_json=center_json_data,
-                                                                 defect_json=defect_json_data)
-
-        logger.info("开始进行缺陷信息重计算")
+        # 边角和面 类型分类
         if score_type == 'front_corner_edge' or score_type == 'back_corner_edge':
             inference_type = "corner_edge"
         else:
             inference_type = "face"
 
+        # 正反面类型分类
+        if score_type == 'front_corner_edge' or score_type == 'front_face':
+            card_aspect = "front"
+        else:
+            card_aspect = "back"
+
+        logger.info("开始进行缺陷信息重计算")
         defect_data = self.defect_service.re_inference_from_json(inference_type=inference_type,
                                                                  center_json=center_json_data,
                                                                  defect_json=defect_json_data)
 
         logger.info("开始重新计算分数")
-        if score_type == 'front_corner_edge' or score_type == 'front_face':
-            card_aspect = "front"
-        else:
-            card_aspect = "back"
-        if score_type == 'front_corner_edge' or score_type == 'back_corner_edge':
-            card_defect_type = "corner_edge"
-        else:
-            card_defect_type = "face"
+        if inference_type == 'corner_edge':
+            logger.info("开始进行居中信息重计算")
+            center_data = self.defect_service.re_inference_from_json(inference_type="center",
+                                                                     center_json=center_json_data,
+                                                                     defect_json=defect_json_data)
 
-        center_score_data = self.card_scorer.calculate_centering_score(card_aspect, center_data, True)
+            center_score_data = self.card_scorer.calculate_centering_score(card_aspect, center_data, True)
 
-        if card_defect_type == 'corner_edge':
             # 先计算角的分数, 会把分数写入json, 然后传入刚写好的, 继续写边的分数
             corner_score_data = self.card_scorer.calculate_defect_score('corner', card_aspect, defect_data, True)
             defect_score_data = self.card_scorer.calculate_defect_score('edge', card_aspect, corner_score_data, True)
-        elif card_defect_type == 'face':
+        elif inference_type == 'face':
+            # 面类型不计算居中
+            center_score_data = {}
             defect_score_data = self.card_scorer.calculate_defect_score('face', card_aspect, defect_data, True)
         else:
             return {}
 
         result_json = self.card_scorer.formate_one_card_result(center_score_data, defect_score_data,
-                                                               card_defect_type=card_defect_type,
+                                                               card_defect_type=inference_type,
                                                                card_aspect=card_aspect)
 
         temp_score_json_path = settings.TEMP_WORK_DIR / f're_{score_type}_score.json'

app/utils/score_inference/CardScorer.py

@@ -164,11 +164,13 @@ class CardScorer:
 
             # 计算各部分的最后分数
             # 计算居中
-            center_score = center_result['deduct_score']
-            center_weight = card_config['center']
-            final_center_score = center_score * center_weight
+            final_center_score = None
 
             if card_defect_type == "corner_edge":
+                center_score = center_result['deduct_score']
+                center_weight = card_config['center']
+                final_center_score = center_score * center_weight
+
                 corner_score = defect_result[f"{card_aspect}_corner_deduct_score"]
                 edge_score = defect_result[f"{card_aspect}_edge_deduct_score"]
 
@@ -176,22 +178,21 @@ class CardScorer:
                 edge_weight = card_config['edge']
 
                 final_defect_score = corner_score * corner_weight + edge_score * edge_weight
+                _used_compute_deduct_score = final_center_score + final_defect_score
+                card_score = self.base_score + final_center_score + final_defect_score
             else:
                 face_score = defect_result[f"{card_aspect}_face_deduct_score"]
                 face_weight = card_config['face']
 
                 final_defect_score = face_score * face_weight
-            # 添加一个用于计算4个卡总分的扣分分数, 根据环光的居中计算总分
-            if card_defect_type == "corner_edge":
-                _used_compute_deduct_score = final_center_score + final_defect_score
-            else:
                 _used_compute_deduct_score = final_defect_score
 
-            card_score = self.base_score + final_center_score + final_defect_score
+                card_score = self.base_score + final_defect_score
 
         except Exception as e:
             logger.error(f"formate_one_card_result 从json获取分数失败: {e}")
             raise e
+
         data = {
             "result": {
                 "center_result": center_result,