feat（新功能）: design batch 代码 更新

fix（修复bug）:
docs（文档变更）:
refactor（重构）:
test(增加测试):

app/service/design_batch/design_batch_celery.py

@@ -5,9 +5,9 @@ from celery import Celery
 from minio import Minio
 
 from app.core.config import *
-from app.service.design_batch.item import BodyItem, TopItem, BottomItem
+from app.service.design_batch.item import BodyItem, TopItem, BottomItem, AccessoriesItem
 from app.service.design_batch.utils.MQ import publish_status
-from app.service.design_batch.utils.organize import organize_body, organize_clothing
+from app.service.design_batch.utils.organize import organize_body, organize_clothing, organize_accessories
 from app.service.design_batch.utils.save_json import oss_upload_json
 from app.service.design_batch.utils.synthesis_item import update_base_size_priority, synthesis, synthesis_single
 
@@ -19,6 +19,8 @@ logging.getLogger('pika').setLevel(logging.WARNING)
 logger = logging.getLogger()
 minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
 
+print("start")
+
 
 def process_item(item, basic):
     # 处理project中单个item
@@ -28,9 +30,14 @@ def process_item(item, basic):
     elif item['type'].lower() in ['blouse', 'outwear', 'dress', 'tops']:
         top_server = TopItem(data=item, basic=basic, minio_client=minio_client)
         item_data = top_server.process()
-    else:
+    elif item['type'].lower() in ['skirt', 'trousers', 'bottoms']:
         bottom_server = BottomItem(data=item, basic=basic, minio_client=minio_client)
         item_data = bottom_server.process()
+    elif item['type'].lower() in ['accessories']:
+        bottom_server = AccessoriesItem(data=item, basic=basic, minio_client=minio_client)
+        item_data = bottom_server.process()
+    else:
+        raise NotImplementedError(f"Item type {item['type']} not implemented")
     return item_data
 
 
@@ -40,6 +47,10 @@ def process_layer(item, layers):
         body_layer = organize_body(item)
         layers.append(body_layer)
         return item['body_image'].size
+    elif item['name'] == 'accessories':
+        front_layer, back_layer = organize_accessories(item)
+        layers.append(front_layer)
+        layers.append(back_layer)
     else:
         front_layer, back_layer = organize_clothing(item)
         layers.append(front_layer)
@@ -48,6 +59,9 @@ def process_layer(item, layers):
 
 @celery_app.task
 def batch_design(objects_data, tasks_id, json_name):
+    print(objects_data)
+    print(tasks_id)
+    print(json_name)
     object_response = []
     threads = []
     active_threads = 0
@@ -121,6 +135,7 @@ def batch_design(objects_data, tasks_id, json_name):
     for t in threads:
         t.join()
     logger.debug(object_response)
+    print(object_response)
     oss_upload_json(minio_client, object_response, json_name)
     publish_status(tasks_id, "ok", json_name)
     return object_response

app/service/design_batch/item.py

@@ -1,4 +1,4 @@
-from app.service.design_batch.pipeline import *
+from app.service.design_fast.pipeline import LoadImage, KeyPoint, Segmentation, Color, PrintPainting, Scaling, Split, LoadBodyImage, ContourDetection
 
 
 class BaseItem:
@@ -9,6 +9,27 @@ class BaseItem:
         self.result.update(basic)
 
 
+class AccessoriesItem(BaseItem):
+    def __init__(self, data, basic, minio_client):
+        super().__init__(data, basic)
+        self.Accessories_pipeline = [
+            LoadImage(minio_client),
+            # KeyPoint(),
+            ContourDetection(),
+            # Segmentation(minio_client),
+            # BackPerspective(minio_client),
+            Color(minio_client),
+            PrintPainting(minio_client),
+            Scaling(),
+            Split(minio_client)
+        ]
+
+    def process(self):
+        for item in self.Accessories_pipeline:
+            self.result = item(self.result)
+        return self.result
+
+
 class TopItem(BaseItem):
     def __init__(self, data, basic, minio_client):
         super().__init__(data, basic)
@@ -16,6 +37,7 @@ class TopItem(BaseItem):
             LoadImage(minio_client),
             KeyPoint(),
             Segmentation(minio_client),
+            # BackPerspective(minio_client),
             Color(minio_client),
             PrintPainting(minio_client),
             Scaling(),
@@ -35,7 +57,8 @@ class BottomItem(BaseItem):
             LoadImage(minio_client),
             KeyPoint(),
             ContourDetection(),
-            # Segmentation(),
+            Segmentation(minio_client),
+            # BackPerspective(minio_client),
             Color(minio_client),
             PrintPainting(minio_client),
             Scaling(),

app/service/design_batch/pipeline/__init__.py

@@ -1,3 +1,4 @@
+from .back_perspective import BackPerspective
 from .color import Color
 from .contour_detection import ContourDetection
 from .keypoint import KeyPoint
@@ -13,6 +14,7 @@ __all__ = [
     'KeyPoint',
     'ContourDetection',
     'Segmentation',
+    'BackPerspective',
     'Color',
     'PrintPainting',
     'Scaling',

app/service/design_batch/pipeline/back_perspective.py

@@ -0,0 +1,79 @@
+import cv2
+import numpy as np
+
+from app.service.design_fast.utils.design_ensemble import get_seg_result
+from app.service.utils.new_oss_client import oss_upload_image
+
+
+class BackPerspective:
+    def __init__(self, minio_client):
+        self.minio_client = minio_client
+
+    def __call__(self, result):
+
+        # 如果sketch为系统图 查看是否有对应的 背后视角图
+        if result['path'].split('/')[0] == 'aida-sys-image':
+            file_path = result['path'].replace("images", 'images_back', 1)
+            if self.is_file_exists(bucket_name='aida-sys-image', file_name=file_path[file_path.find('/') + 1:]):
+                result['back_perspective_url'] = file_path
+                return result
+            else:
+                seg_result = get_seg_result("1", result['image'])[0]
+        elif result['name'] in ['blouse', 'outwear', 'dress', 'tops']:
+            seg_result = result['seg_result']
+        else:
+            seg_result = get_seg_result("1", result['image'])[0]
+
+        m = self.thicken_contours_and_display(seg_result, thickness=10, color=(0, 0, 0))
+        back_sketch = result['image'].copy()
+        back_sketch[m > 100] = 255
+        # 上传背后视角图
+        _, img_encoded = cv2.imencode(".jpg", back_sketch)
+
+        resp = oss_upload_image(self.minio_client, bucket='test', object_name=result['path'], image_bytes=img_encoded.tobytes())
+        result['back_perspective_url'] = f"{resp.bucket_name}/{resp.object_name}"
+        return result
+
+    def thicken_contours_and_display(self, mask, thickness=10, color=(0, 0, 0)):
+        mask = mask.astype(np.uint8) * 255
+        # 查找轮廓
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        # 创建一个彩色副本用于绘制轮廓
+        mask_color = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
+
+        def thicken_contour_inward(contour, thick):
+            # 创建一个空白的黑色图像与原始掩码大小相同
+            blank = np.zeros_like(mask)
+            # 在空白图像上绘制白色的轮廓
+            cv2.drawContours(blank, [contour], -1, 255, thickness=thick)
+            # 找到轮廓的中心（可以用重心等方法近似）
+            M = cv2.moments(contour)
+            cx = int(M['m10'] / M['m00'])
+            cy = int(M['m01'] / M['m00'])
+            # 进行距离变换，离中心越近的值越小
+            dist_transform = cv2.distanceTransform(255 - blank, cv2.DIST_L2, 5)
+            # 根据距离变换的值来决定是否保留像素，离中心近的像素更容易被保留
+            result = np.zeros_like(mask)
+            for i in range(dist_transform.shape[0]):
+                for j in range(dist_transform.shape[1]):
+                    if dist_transform[i, j] < thick:
+                        result[i, j] = 255
+            return result
+
+        for contour in contours:
+            thickened_contour = thicken_contour_inward(contour, thickness)
+            mask_color[thickened_contour > 0] = color
+
+        _, binary_result = cv2.threshold(mask_color, 127, 255, cv2.THRESH_BINARY)
+
+        # 转换为掩码形式
+        mask_result = cv2.cvtColor(binary_result, cv2.COLOR_BGR2GRAY)
+        return mask_result
+
+    def is_file_exists(self, bucket_name, file_name):
+        try:
+            self.minio_client.stat_object(bucket_name, file_name)
+            return True
+        except Exception:
+            return False

app/service/design_batch/pipeline/color.py

@@ -14,14 +14,39 @@ class Color:
 
     def __call__(self, result):
         dim_image_h, dim_image_w = result['image'].shape[0:2]
+        # 渐变色
         if "gradient" in result.keys() and result['gradient'] != "":
             bucket_name = result['gradient'].split('/')[0]
             object_name = result['gradient'][result['gradient'].find('/') + 1:]
             pattern = self.get_gradient(bucket_name=bucket_name, object_name=object_name)
             resize_pattern = cv2.resize(pattern, (dim_image_w, dim_image_h), interpolation=cv2.INTER_AREA)
+        # 无色
+        elif "color" not in result.keys() or result['color'] == "":
+            result['final_image'] = result['pattern_image'] = result['single_image'] = result['image']
+            result['alpha'] = 100 / 255.0
+            return result
+        # 正常颜色
         else:
             pattern = self.get_pattern(result['color'])
             resize_pattern = cv2.resize(pattern, (dim_image_w, dim_image_h), interpolation=cv2.INTER_AREA)
+
+        if "partial_color" in result.keys() and result['partial_color'] != "":
+            bucket_name = result['partial_color'].split('/')[0]
+            object_name = result['partial_color'][result['partial_color'].find('/') + 1:]
+            partial_color = oss_get_image(oss_client=self.minio_client, bucket=bucket_name, object_name=object_name, data_type="cv2")
+            h, w = partial_color.shape[0:2]
+            resize_pattern = cv2.resize(resize_pattern, (w, h), interpolation=cv2.INTER_AREA)
+            # 分离出 png 图的 alpha 通道
+            alpha_channel = partial_color[:, :, 3]
+            # 提取 png 图的 RGB 通道
+            png_rgb = partial_color[:, :, :3]
+            # 创建一个与 cv 图大小相同的掩码，用于指示哪些像素需要替换
+            mask = alpha_channel > 0
+            # 将掩码扩展为 3 通道，以便与 cv 图进行逐元素操作
+            mask_3ch = np.stack([mask] * 3, axis=-1)
+            # 根据掩码将 png 图的颜色覆盖到 cv 图上
+            resize_pattern[mask_3ch] = png_rgb[mask_3ch]
+            resize_pattern = cv2.resize(resize_pattern, (dim_image_w, dim_image_h), interpolation=cv2.INTER_AREA)
         closed_mo = np.expand_dims(result['mask'], axis=2).repeat(3, axis=2)
         gray_mo = np.expand_dims(result['gray'], axis=2).repeat(3, axis=2)
         get_image_fir = resize_pattern * (closed_mo / 255) * (gray_mo / 255)

app/service/design_batch/pipeline/keypoint.py

@@ -4,7 +4,8 @@ import numpy as np
 from pymilvus import MilvusClient
 
 from app.core.config import *
-from app.service.design_batch.utils.design_ensemble import get_keypoint_result
+from app.service.design_fast.utils.design_ensemble import get_keypoint_result
+from app.service.utils.decorator import ClassCallRunTime, RunTime
 
 logger = logging.getLogger(__name__)
 
@@ -16,14 +17,15 @@ class KeyPoint:
     def get_name(cls):
         return cls.name
 
+    @ClassCallRunTime
     def __call__(self, result):
         if result['name'] in ['blouse', 'skirt', 'dress', 'outwear', 'trousers', 'tops', 'bottoms']:  # 查询是否有数据 且类别相同 相同则直接读 不同则推理后更新
             # result['clothes_keypoint'] = self.infer_keypoint_result(result)
             site = 'up' if result['name'] in ['blouse', 'outwear', 'dress', 'tops'] else 'down'
             # keypoint_cache = search_keypoint_cache(result["image_id"], site)
-            keypoint_cache = self.keypoint_cache(result, site)
+            # keypoint_cache = self.keypoint_cache(result, site)
+            keypoint_cache = False
             # 取消向量查询 直接过模型推理
-            # keypoint_cache = False
             if keypoint_cache is False:
                 keypoint_infer_result, site = self.infer_keypoint_result(result)
                 result['clothes_keypoint'] = self.save_keypoint_cache(result["image_id"], keypoint_infer_result, site)
@@ -87,7 +89,7 @@ class KeyPoint:
             logger.info(f"save keypoint cache milvus error : {e}")
             return dict(zip(KEYPOINT_RESULT_TABLE_FIELD_SET, result.reshape(12, 2).astype(int).tolist()))
 
-    # @ RunTime
+    @RunTime
     def keypoint_cache(self, result, site):
         try:
             client = MilvusClient(uri=MILVUS_URL, token=MILVUS_TOKEN, db_name=MILVUS_ALIAS)

app/service/design_batch/pipeline/loading.py

@@ -1,6 +1,9 @@
+import io
 import logging
 
 import cv2
+import numpy as np
+from PIL import Image
 
 from app.service.utils.new_oss_client import oss_get_image
 
@@ -71,6 +74,8 @@ class LoadImage:
             keypoint = 'head_point'
         elif name == 'earring':
             keypoint = 'ear_point'
+        elif name == 'accessories':
+            keypoint = "accessories"
         else:
             raise KeyError(f"{name} does not belong to item category list: blouse, outwear, dress, trousers, skirt, "
                            f"bag, shoes, hairstyle, earring.")

app/service/design_batch/pipeline/print_painting.py

@@ -15,8 +15,25 @@ class PrintPainting:
         single_print = result['print']['single']
         overall_print = result['print']['overall']
         element_print = result['print']['element']
+        partial_path = result['print']['partial'] if 'partial' in result['print'] else None
         result['single_image'] = None
         result['print_image'] = None
+        # TODO 给result['pattern_image'] resize 到resize_scale的大小
+        # TODO 给result['mask'] resize 到resize_scale的大小
+
+        if result['resize_scale'][0] == 1.0 and result['resize_scale'][1] == 1.0:
+            pass
+        else:
+            height, width = result['pattern_image'].shape[:2]
+            new_width = int(width * result['resize_scale'][0])
+            new_height = int(height * result['resize_scale'][1])
+
+            result['pattern_image'] = cv2.resize(result['pattern_image'], (new_width, new_height))
+            result['final_image'] = cv2.resize(result['final_image'], (new_width, new_height))
+            result['mask'] = cv2.resize(result['mask'], (new_width, new_height))
+            result['gray'] = cv2.resize(result['gray'], (new_width, new_height))
+
+            print(1)
         if overall_print['print_path_list']:
             painting_dict = {'dim_image_h': result['pattern_image'].shape[0], 'dim_image_w': result['pattern_image'].shape[1]}
             result['print_image'] = result['pattern_image']
@@ -39,7 +56,7 @@ class PrintPainting:
             for i in range(len(single_print['print_path_list'])):
                 image, image_mode = self.read_image(single_print['print_path_list'][i])
                 if image_mode == "RGBA":
-                    new_size = (int(image.width * single_print['print_scale_list'][i]), int(image.height * single_print['print_scale_list'][i]))
+                    new_size = (int(result['pattern_image'].shape[1] * single_print['print_scale_list'][i][0]), int(result['pattern_image'].shape[0] * single_print['print_scale_list'][i][1]))
 
                     mask = image.split()[3]
                     resized_source = image.resize(new_size)
@@ -62,9 +79,12 @@ class PrintPainting:
                     mask = np.expand_dims(mask, axis=2)
                     mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
                     mask = cv2.bitwise_not(mask)
+
+                    mask = cv2.resize(mask, (int(result['final_image'].shape[1] * single_print['print_scale_list'][i][0]), int(result['final_image'].shape[0] * single_print['print_scale_list'][i][1])))
+                    image = cv2.resize(image, (int(result['final_image'].shape[1] * single_print['print_scale_list'][i][0]), int(result['final_image'].shape[0] * single_print['print_scale_list'][i][1])))
                     # 旋转后的坐标需要重新算
-                    rotate_mask, _ = self.img_rotate(mask, single_print['print_angle_list'][i], single_print['print_scale_list'][i])
-                    rotate_image, rotated_new_size = self.img_rotate(image, single_print['print_angle_list'][i], single_print['print_scale_list'][i])
+                    rotate_mask, _ = self.img_rotate(mask, single_print['print_angle_list'][i])
+                    rotate_image, rotated_new_size = self.img_rotate(image, single_print['print_angle_list'][i])
                     # x, y = int(result['print']['location'][i][0] - rotated_new_size[0] - (rotate_mask.shape[0] - image.shape[0]) / 2), int(result['print']['location'][i][1] - rotated_new_size[1] - (rotate_mask.shape[1] - image.shape[1]) / 2)
                     x, y = int(single_print['location'][i][0] - rotated_new_size[0]), int(single_print['location'][i][1] - rotated_new_size[1])
 
@@ -143,7 +163,7 @@ class PrintPainting:
             for i in range(len(element_print['element_path_list'])):
                 image, image_mode = self.read_image(element_print['element_path_list'][i])
                 if image_mode == "RGBA":
-                    new_size = (int(image.width * element_print['element_scale_list'][i]), int(image.height * element_print['element_scale_list'][i]))
+                    new_size = (int(result['final_image'].shape[1] * element_print['element_scale_list'][i][0]), int(result['final_image'].shape[0] * element_print['element_scale_list'][i][1]))
 
                     mask = image.split()[3]
                     resized_source = image.resize(new_size)
@@ -165,9 +185,11 @@ class PrintPainting:
                     mask = np.expand_dims(mask, axis=2)
                     mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
                     mask = cv2.bitwise_not(mask)
+                    mask = cv2.resize(mask, (int(result['final_image'].shape[1] * single_print['print_scale_list'][i][0]), int(result['final_image'].shape[0] * single_print['print_scale_list'][i][1])))
+                    image = cv2.resize(image, (int(result['final_image'].shape[1] * single_print['print_scale_list'][i][0]), int(result['final_image'].shape[0] * single_print['print_scale_list'][i][1])))
                     # 旋转后的坐标需要重新算
-                    rotate_mask, _ = self.img_rotate(mask, element_print['element_angle_list'][i], element_print['element_scale_list'][i])
-                    rotate_image, rotated_new_size = self.img_rotate(image, element_print['element_angle_list'][i], element_print['element_scale_list'][i])
+                    rotate_mask, _ = self.img_rotate(mask, element_print['element_angle_list'][i])
+                    rotate_image, rotated_new_size = self.img_rotate(image, element_print['element_angle_list'][i])
                     # x, y = int(result['print']['location'][i][0] - rotated_new_size[0] - (rotate_mask.shape[0] - image.shape[0]) / 2), int(result['print']['location'][i][1] - rotated_new_size[1] - (rotate_mask.shape[1] - image.shape[1]) / 2)
                     x, y = int(element_print['location'][i][0] - rotated_new_size[0]), int(element_print['location'][i][1] - rotated_new_size[1])
 
@@ -241,6 +263,45 @@ class PrintPainting:
             temp_fg = np.expand_dims(result['mask'], axis=2).repeat(3, axis=2)
             tmp2 = (result['final_image'] * (temp_fg / 255)).astype(np.uint8)
             result['single_image'] = cv2.add(tmp1, tmp2)
+
+        if partial_path:
+            print_background = np.zeros((result['pattern_image'].shape[0], result['pattern_image'].shape[1], 3), dtype=np.uint8)
+            mask_background = np.zeros((result['pattern_image'].shape[0], result['pattern_image'].shape[1], 3), dtype=np.uint8)
+            image, image_mode = self.read_image(partial_path)
+            if image_mode == "RGBA":
+                new_size = (result['pattern_image'].shape[1], result['pattern_image'].shape[0])
+
+                mask = image.split()[3]
+                resized_source = image.resize(new_size)
+                resized_source_mask = mask.resize(new_size)
+
+                # rotated_resized_source = resized_source.rotate(-partial_print['print_angle_list'][i])
+                # rotated_resized_source_mask = resized_source_mask.rotate(-partial_print['print_angle_list'][i])
+
+                source_image_pil = Image.fromarray(cv2.cvtColor(print_background, cv2.COLOR_BGR2RGB))
+                source_image_pil_mask = Image.fromarray(cv2.cvtColor(mask_background, cv2.COLOR_BGR2RGB))
+
+                source_image_pil.paste(resized_source, (0, 0), resized_source)
+                source_image_pil_mask.paste(resized_source_mask, (0, 0), resized_source_mask)
+
+                print_background = cv2.cvtColor(np.array(source_image_pil), cv2.COLOR_RGBA2BGR)
+                mask_background = cv2.cvtColor(np.array(source_image_pil_mask), cv2.COLOR_RGBA2BGR)
+                ret, mask_background = cv2.threshold(mask_background, 124, 255, cv2.THRESH_BINARY)
+            print_mask = cv2.bitwise_and(result['mask'], cv2.cvtColor(mask_background, cv2.COLOR_BGR2GRAY))
+            img_fg = cv2.bitwise_or(print_background, print_background, mask=print_mask)
+            # TODO element  丢失信息
+            three_channel_image = cv2.merge([cv2.bitwise_not(print_mask), cv2.bitwise_not(print_mask), cv2.bitwise_not(print_mask)])
+            img_bg = cv2.bitwise_and(result['final_image'], three_channel_image)
+            # mask_mo = np.expand_dims(print_mask, axis=2).repeat(3, axis=2)
+            # gray_mo = np.expand_dims(result['gray'], axis=2).repeat(3, axis=2)
+            # img_fg = (img_fg * (mask_mo / 255) * (gray_mo / 255)).astype(np.uint8)
+            result['final_image'] = cv2.add(img_bg, img_fg)
+            canvas = np.full_like(result['final_image'], 255)
+            temp_bg = np.expand_dims(cv2.bitwise_not(result['mask']), axis=2).repeat(3, axis=2)
+            tmp1 = (canvas * (temp_bg / 255)).astype(np.uint8)
+            temp_fg = np.expand_dims(result['mask'], axis=2).repeat(3, axis=2)
+            tmp2 = (result['final_image'] * (temp_fg / 255)).astype(np.uint8)
+            result['single_image'] = cv2.add(tmp1, tmp2)
         return result
 
     @staticmethod
@@ -360,10 +421,10 @@ class PrintPainting:
         return print_image
 
     def get_print(self, print_dict):
-        if 'print_scale_list' not in print_dict.keys() or print_dict['print_scale_list'][0] < 0.3:
+        if 'print_scale_list' not in print_dict.keys() or print_dict['print_scale_list'][0][0] < 0.3:
             print_dict['scale'] = 0.3
         else:
-            print_dict['scale'] = print_dict['print_scale_list'][0]
+            print_dict['scale'] = print_dict['print_scale_list'][0][0]
 
         bucket_name = print_dict['print_path_list'][0].split("/", 1)[0]
         object_name = print_dict['print_path_list'][0].split("/", 1)[1]
@@ -386,8 +447,9 @@ class PrintPainting:
         # y_offset = random.randint(0, image.shape[1] - image_size_w)
 
         # 1.拿到偏移量后和resize后的print宽高取余 得到真正偏移量
-        x_offset = print_w - int(location[0][1] % print_w)
-        y_offset = print_w - int(location[0][0] % print_h)
+        # 偏移量增加2分之print.w 使坐标位于图中间  如果要位于左上角删除+ print_w // 2 即可
+        x_offset = print_w - int(location[0][1] % print_w) + print_w // 2
+        y_offset = print_h - int(location[0][0] % print_h) + print_h // 2
 
         # y_offset = int(location[0][0])
         # x_offset = int(location[0][1])
@@ -409,7 +471,7 @@ class PrintPainting:
         return high, low
 
     @staticmethod
-    def img_rotate(image, angel, scale):
+    def img_rotate(image, angel):
         """顺时针旋转图像任意角度
 
         Args:
@@ -424,7 +486,7 @@ class PrintPainting:
         center = (w // 2, h // 2)
         # if type(angel) is not int:
         #     angel = 0
-        M = cv2.getRotationMatrix2D(center, -angel, scale)
+        M = cv2.getRotationMatrix2D(center, -angel, 1)
         # 调整旋转后的图像长宽
         rotated_h = int((w * np.abs(M[0, 1]) + (h * np.abs(M[0, 0]))))
         rotated_w = int((h * np.abs(M[0, 1]) + (w * np.abs(M[0, 0]))))
@@ -433,7 +495,7 @@ class PrintPainting:
         # 旋转图像
         rotated_img = cv2.warpAffine(image, M, (rotated_w, rotated_h))
 
-        return rotated_img, ((rotated_img.shape[1] - image.shape[1] * scale) // 2, (rotated_img.shape[0] - image.shape[0] * scale) // 2)
+        return rotated_img, ((rotated_img.shape[1] - image.shape[1]) // 2, (rotated_img.shape[0] - image.shape[0]) // 2)
         # return rotated_img, (0, 0)
 
     @staticmethod
@@ -442,8 +504,11 @@ class PrintPainting:
         angle: 旋转的角度
         crop: 是否需要进行裁剪，布尔向量
         """
+        if not isinstance(crop, bool):
+            raise ValueError("The 'crop' parameter must be a boolean.")
+
         crop_image = lambda img, x0, y0, w, h: img[y0:y0 + h, x0:x0 + w]
-        w, h = img.shape[:2]
+        h, w = img.shape[:2]
         # 旋转角度的周期是360°
         angle %= 360
         # 计算仿射变换矩阵
@@ -455,7 +520,7 @@ class PrintPainting:
         if crop:
             # 裁剪角度的等效周期是180°
             angle_crop = angle % 180
-            if angle > 90:
+            if angle_crop > 90:
                 angle_crop = 180 - angle_crop
             # 转化角度为弧度
             theta = angle_crop * np.pi / 180

app/service/design_batch/pipeline/scale.py

@@ -46,4 +46,16 @@ class Scaling:
             result['scale'] = result['scale_bag']
         elif result['keypoint'] == 'ear_point':
             result['scale'] = result['scale_earrings']
+        elif result['keypoint'] == 'accessories':
+            # 由于没有识别配饰keypoint的模型  所以统一将配饰的两个关键点设定为 (0,0) (0,img.width)
+            # 模特的关键点设定为(0,0) (0,320/2) 距离比例简写为 160 / img.width
+            distance_clo = result['img_shape'][1]
+            distance_bdy = 320 / 2
+
+            if distance_clo == 0:
+                result['scale'] = 1
+            else:
+                result['scale'] = distance_bdy / distance_clo
+        else:
+            result['scale'] = 1
         return result

app/service/design_batch/pipeline/segmentation.py

@@ -5,7 +5,8 @@ import cv2
 import numpy as np
 
 from app.core.config import SEG_CACHE_PATH
-from app.service.design_batch.utils.design_ensemble import get_seg_result
+from app.service.design_fast.utils.design_ensemble import get_seg_result
+from app.service.utils.decorator import ClassCallRunTime
 from app.service.utils.new_oss_client import oss_get_image
 
 logger = logging.getLogger()
@@ -15,6 +16,7 @@ class Segmentation:
     def __init__(self, minio_client):
         self.minio_client = minio_client
 
+    @ClassCallRunTime
     def __call__(self, result):
         if "seg_mask_url" in result.keys() and result['seg_mask_url'] != "":
             seg_mask = oss_get_image(oss_client=self.minio_client, bucket=result['seg_mask_url'].split('/')[0], object_name=result['seg_mask_url'][result['seg_mask_url'].find('/') + 1:], data_type="cv2")
@@ -31,24 +33,37 @@ class Segmentation:
             result['back_mask'] = np.array(green_mask, dtype=np.uint8) * 255
             result['mask'] = result['front_mask'] + result['back_mask']
         else:
-            # 本地查询seg 缓存是否存在
-            _, seg_result = self.load_seg_result(result["image_id"])
-            result['seg_result'] = seg_result
-            if not _:
+            # preview 过模型 不缓存
+            if "preview_submit" in result.keys() and result['preview_submit'] == "preview":
                 # 推理获得seg 结果
-                seg_result = get_seg_result(result["image_id"], result['image'])[0]
+                seg_result = get_seg_result(result["image_id"], result['image'])
+            # submit 过模型 缓存
+            elif "preview_submit" in result.keys() and result['preview_submit'] == "submit":
+                # 推理获得seg 结果
+                seg_result = get_seg_result(result["image_id"], result['image'])
                 self.save_seg_result(seg_result, result['image_id'])
+            #  null  正常流程 加载本地缓存 无缓存则过模型
+            else:
+                # 本地查询seg 缓存是否存在
+                _, seg_result = self.load_seg_result(result["image_id"])
+                # 判断缓存和实际图片size是否相同
+                if not _ or result["image"].shape[:2] != seg_result.shape:
+                    # 推理获得seg 结果
+                    seg_result = get_seg_result(result["image_id"], result['image'])
+                    self.save_seg_result(seg_result, result['image_id'])
+            result['seg_result'] = seg_result
+
             # 处理前片后片
-            temp_front = seg_result == 1.0
+            temp_front = seg_result == 1
             result['front_mask'] = (255 * (temp_front + 0).astype(np.uint8))
-            temp_back = seg_result == 2.0
+            temp_back = seg_result == 2
             result['back_mask'] = (255 * (temp_back + 0).astype(np.uint8))
             result['mask'] = result['front_mask'] + result['back_mask']
         return result
 
     @staticmethod
     def save_seg_result(seg_result, image_id):
-        file_path = f"seg_cache/{image_id}.npy"
+        file_path = f"{SEG_CACHE_PATH}{image_id}.npy"
         try:
             np.save(file_path, seg_result)
             logger.debug(f"保存成功 ：{os.path.abspath(file_path)}")
@@ -57,7 +72,7 @@ class Segmentation:
 
     @staticmethod
     def load_seg_result(image_id):
-        file_path = f"seg_cache/{image_id}.npy"
+        file_path = f"{SEG_CACHE_PATH}{image_id}.npy"
         # logger.info(f"load seg file name is :{SEG_CACHE_PATH}{image_id}.npy")
         try:
             seg_result = np.load(file_path)

app/service/design_batch/pipeline/split.py

@@ -7,10 +7,11 @@ from PIL import Image
 from cv2 import cvtColor, COLOR_BGR2RGBA
 
 from app.core.config import AIDA_CLOTHING
-from app.service.design_batch.utils.conversion_image import rgb_to_rgba
-from app.service.design_batch.utils.upload_image import upload_png_mask
+from app.service.design_fast.utils.conversion_image import rgb_to_rgba
+from app.service.design_fast.utils.transparent import sketch_to_transparent
+from app.service.design_fast.utils.upload_image import upload_png_mask
 from app.service.utils.generate_uuid import generate_uuid
-from app.service.utils.new_oss_client import oss_upload_image
+from app.service.utils.new_oss_client import oss_upload_image, oss_get_image
 
 
 class Split(object):
@@ -20,51 +21,95 @@ class Split(object):
     def __call__(self, result):
         try:
 
-            if result['name'] in ('outwear', 'dress', 'blouse', 'skirt', 'trousers', 'tops', 'bottoms'):
-                front_mask = result['front_mask']
-                back_mask = result['back_mask']
+            if result['name'] in ('outwear', 'dress', 'blouse', 'skirt', 'trousers', 'tops', 'bottoms', 'accessories'):
+
+                if result['resize_scale'][0] == 1.0 and result['resize_scale'][1] == 1.0:
+                    front_mask = result['front_mask']
+                    back_mask = result['back_mask']
+                else:
+                    height, width = result['front_mask'].shape[:2]
+                    new_width = int(width * result['resize_scale'][0])
+                    new_height = int(height * result['resize_scale'][1])
+
+                    front_mask = cv2.resize(result['front_mask'], (new_width, new_height))
+                    back_mask = cv2.resize(result['back_mask'], (new_width, new_height))
+
                 rgba_image = rgb_to_rgba(result['final_image'], front_mask + back_mask)
-                new_size = (int(rgba_image.shape[1] * result["scale"] * result["resize_scale"][0]), int(rgba_image.shape[0] * result["scale"] * result["resize_scale"][1]))
+                new_size = (int(rgba_image.shape[1] * result["scale"]), int(rgba_image.shape[0] * result["scale"]))
                 rgba_image = cv2.resize(rgba_image, new_size)
                 result_front_image = np.zeros_like(rgba_image)
                 front_mask = cv2.resize(front_mask, new_size)
                 result_front_image[front_mask != 0] = rgba_image[front_mask != 0]
                 result_front_image_pil = Image.fromarray(cvtColor(result_front_image, COLOR_BGR2RGBA))
+                if 'transparent' in result.keys():
+                    #  用户自选区域transparent
+                    transparent = result['transparent']
+                    if transparent['mask_url'] is not None and transparent['mask_url'] != "":
+                        # 预处理用户自选区mask
+                        seg_mask = oss_get_image(oss_client=self.minio_client, bucket=transparent['mask_url'].split('/')[0], object_name=transparent['mask_url'][transparent['mask_url'].find('/') + 1:], data_type="cv2")
+                        seg_mask = cv2.resize(seg_mask, new_size, interpolation=cv2.INTER_NEAREST)
+                        # 转换颜色空间为 RGB（OpenCV 默认是 BGR）
+                        image_rgb = cv2.cvtColor(seg_mask, cv2.COLOR_BGR2RGB)
+
+                        r, g, b = cv2.split(image_rgb)
+                        blue_mask = b > r
+
+                        # 创建红色和绿色掩码
+                        transparent_mask = np.array(blue_mask, dtype=np.uint8) * 255
+                        result_front_image_pil = sketch_to_transparent(result_front_image_pil, transparent_mask, transparent["scale"])
+                    else:
+                        result_front_image_pil = sketch_to_transparent(result_front_image_pil, front_mask, transparent["scale"])
                 result['front_image'], result["front_image_url"], _ = upload_png_mask(self.minio_client, result_front_image_pil, f'{generate_uuid()}', mask=None)
 
                 height, width = front_mask.shape
                 mask_image = np.zeros((height, width, 3))
                 mask_image[front_mask != 0] = [0, 0, 255]
 
-                if result["name"] in ('blouse', 'dress', 'outwear', 'tops'):
-                    result_back_image = np.zeros_like(rgba_image)
-                    back_mask = cv2.resize(back_mask, new_size)
-                    result_back_image[back_mask != 0] = rgba_image[back_mask != 0]
-                    result_back_image_pil = Image.fromarray(cvtColor(result_back_image, COLOR_BGR2RGBA))
-                    result['back_image'], result["back_image_url"], _ = upload_png_mask(self.minio_client, result_back_image_pil, f'{generate_uuid()}', mask=None)
-                    mask_image[back_mask != 0] = [0, 255, 0]
+                # if result["name"] in ('blouse', 'dress', 'outwear', 'tops'):
+                #     result_back_image = np.zeros_like(rgba_image)
+                #     back_mask = cv2.resize(back_mask, new_size)
+                #     result_back_image[back_mask != 0] = rgba_image[back_mask != 0]
+                #     result_back_image_pil = Image.fromarray(cvtColor(result_back_image, COLOR_BGR2RGBA))
+                #     result['back_image'], result["back_image_url"], _ = upload_png_mask(self.minio_client, result_back_image_pil, f'{generate_uuid()}', mask=None)
+                #     mask_image[back_mask != 0] = [0, 255, 0]
+                #
+                #     rbga_mask = rgb_to_rgba(mask_image, front_mask + back_mask)
+                #     mask_pil = Image.fromarray(cvtColor(rbga_mask.astype(np.uint8), COLOR_BGR2RGBA))
+                #     image_data = io.BytesIO()
+                #     mask_pil.save(image_data, format='PNG')
+                #     image_data.seek(0)
+                #     image_bytes = image_data.read()
+                #     req = oss_upload_image(oss_client=self.minio_client, bucket=AIDA_CLOTHING, object_name=f"mask/mask_{generate_uuid()}.png", image_bytes=image_bytes)
+                #     result['mask_url'] = req.bucket_name + "/" + req.object_name
+                # else:
+                #     rbga_mask = rgb_to_rgba(mask_image, front_mask)
+                #     mask_pil = Image.fromarray(cvtColor(rbga_mask.astype(np.uint8), COLOR_BGR2RGBA))
+                #     image_data = io.BytesIO()
+                #     mask_pil.save(image_data, format='PNG')
+                #     image_data.seek(0)
+                #     image_bytes = image_data.read()
+                #     req = oss_upload_image(oss_client=self.minio_client, bucket=AIDA_CLOTHING, object_name=f"mask/mask_{generate_uuid()}.png", image_bytes=image_bytes)
+                #     result['mask_url'] = req.bucket_name + "/" + req.object_name
+                #     result['back_image'] = None
+                #     result["back_image_url"] = None
+                #     # result["back_mask_url"] = None
+                #     # result['back_mask_image'] = None
 
-                    rbga_mask = rgb_to_rgba(mask_image, front_mask + back_mask)
-                    mask_pil = Image.fromarray(cvtColor(rbga_mask.astype(np.uint8), COLOR_BGR2RGBA))
-                    image_data = io.BytesIO()
-                    mask_pil.save(image_data, format='PNG')
-                    image_data.seek(0)
-                    image_bytes = image_data.read()
-                    req = oss_upload_image(oss_client=self.minio_client, bucket=AIDA_CLOTHING, object_name=f"mask/mask_{generate_uuid()}.png", image_bytes=image_bytes)
-                    result['mask_url'] = req.bucket_name + "/" + req.object_name
-                else:
-                    rbga_mask = rgb_to_rgba(mask_image, front_mask)
-                    mask_pil = Image.fromarray(cvtColor(rbga_mask.astype(np.uint8), COLOR_BGR2RGBA))
-                    image_data = io.BytesIO()
-                    mask_pil.save(image_data, format='PNG')
-                    image_data.seek(0)
-                    image_bytes = image_data.read()
-                    req = oss_upload_image(oss_client=self.minio_client, bucket=AIDA_CLOTHING, object_name=f"mask/mask_{generate_uuid()}.png", image_bytes=image_bytes)
-                    result['mask_url'] = req.bucket_name + "/" + req.object_name
-                    result['back_image'] = None
-                    result["back_image_url"] = None
-                    # result["back_mask_url"] = None
-                    # result['back_mask_image'] = None
+                result_back_image = np.zeros_like(rgba_image)
+                back_mask = cv2.resize(back_mask, new_size)
+                result_back_image[back_mask != 0] = rgba_image[back_mask != 0]
+                result_back_image_pil = Image.fromarray(cvtColor(result_back_image, COLOR_BGR2RGBA))
+                result['back_image'], result["back_image_url"], _ = upload_png_mask(self.minio_client, result_back_image_pil, f'{generate_uuid()}', mask=None)
+                mask_image[back_mask != 0] = [0, 255, 0]
+
+                rbga_mask = rgb_to_rgba(mask_image, front_mask + back_mask)
+                mask_pil = Image.fromarray(cvtColor(rbga_mask.astype(np.uint8), COLOR_BGR2RGBA))
+                image_data = io.BytesIO()
+                mask_pil.save(image_data, format='PNG')
+                image_data.seek(0)
+                image_bytes = image_data.read()
+                req = oss_upload_image(oss_client=self.minio_client, bucket=AIDA_CLOTHING, object_name=f"mask/mask_{generate_uuid()}.png", image_bytes=image_bytes)
+                result['mask_url'] = req.bucket_name + "/" + req.object_name
             # 创建中间图层
             result_pattern_image_rgba = rgb_to_rgba(result['pattern_image'], result['mask'])
             result_pattern_image_pil = Image.fromarray(cvtColor(result_pattern_image_rgba, COLOR_BGR2RGBA))

app/service/design_batch/utils/organize.py

@@ -33,8 +33,8 @@ def organize_clothing(layer):
                        mask=cv2.resize(layer['mask'], layer["front_image"].size),
                        gradient_string=layer['gradient_string'] if 'gradient_string' in layer.keys() else "",
                        pattern_image_url=layer['pattern_image_url'],
-                       pattern_image=layer['pattern_image']
-
+                       pattern_image=layer['pattern_image'],
+                       # back_perspective_url=layer['back_perspective_url'] if 'back_perspective_url' in layer.keys() else ""
                        )
     # 后片数据
     back_layer = dict(priority=-layer.get("priority", 0) if layer.get("layer_order", False) else PRIORITY_DICT.get(f'{layer["name"].lower()}_back', None),
@@ -50,6 +50,46 @@ def organize_clothing(layer):
                       mask=cv2.resize(layer['mask'], layer["front_image"].size),
                       gradient_string=layer['gradient_string'] if 'gradient_string' in layer.keys() else "",
                       pattern_image_url=layer['pattern_image_url'],
+                      # back_perspective_url=layer['back_perspective_url'] if 'back_perspective_url' in layer.keys() else ""
+                      )
+    return front_layer, back_layer
+
+
+def organize_accessories(layer):
+    # 起始坐标
+    start_point = (0, 0)
+    # 前片数据
+    front_layer = dict(priority=layer['priority'] if layer.get("layer_order", False) else PRIORITY_DICT.get(f'{layer["name"].lower()}_front', None),
+                       name=f'{layer["name"].lower()}_front',
+                       image=layer["front_image"],
+                       # mask_image=layer['front_mask_image'],
+                       image_url=layer['front_image_url'],
+                       mask_url=layer['mask_url'],
+                       sacle=layer['scale'],
+                       clothes_keypoint=(0, 0),
+                       position=start_point,
+                       resize_scale=layer["resize_scale"],
+                       mask=cv2.resize(layer['mask'], layer["front_image"].size),
+                       gradient_string=layer['gradient_string'] if 'gradient_string' in layer.keys() else "",
+                       pattern_image_url=layer['pattern_image_url'],
+                       pattern_image=layer['pattern_image'],
+                       # back_perspective_url=layer['back_perspective_url'] if 'back_perspective_url' in layer.keys() else ""
+                       )
+    # 后片数据
+    back_layer = dict(priority=-layer.get("priority", 0) if layer.get("layer_order", False) else PRIORITY_DICT.get(f'{layer["name"].lower()}_back', None),
+                      name=f'{layer["name"].lower()}_back',
+                      image=layer["back_image"],
+                      # mask_image=layer['back_mask_image'],
+                      image_url=layer['back_image_url'],
+                      mask_url=layer['mask_url'],
+                      sacle=layer['scale'],
+                      clothes_keypoint=(0, 0),
+                      position=start_point,
+                      resize_scale=layer["resize_scale"],
+                      mask=cv2.resize(layer['mask'], layer["front_image"].size),
+                      gradient_string=layer['gradient_string'] if 'gradient_string' in layer.keys() else "",
+                      pattern_image_url=layer['pattern_image_url'],
+                      # back_perspective_url=layer['back_perspective_url'] if 'back_perspective_url' in layer.keys() else ""
                       )
     return front_layer, back_layer