feat 产品图打光模型部署

fix

app/service/generate_image/service_generate_image.py

@@ -25,6 +25,7 @@ from app.schemas.generate_image import GenerateImageModel
 from app.service.generate_image.utils.adjust_contrast import adjust_contrast
 from app.service.generate_image.utils.image_processing import remove_background, stain_detection, generate_category_recognition, autoLevels, luminance_adjust, face_detect_pic
 from app.service.generate_image.utils.upload_sd_image import upload_png_sd, upload_stain_png_sd
+from app.service.utils.oss_client import get_image
 
 logger = logging.getLogger()
 
@@ -36,7 +37,7 @@ class GenerateImage:
             self.channel = self.connection.channel()
         # self.connection = pika.BlockingConnection(pika.ConnectionParameters(**RABBITMQ_PARAMS))
         # self.channel = self.connection.channel()
-        self.minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
+        # self.minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
         self.grpc_client = grpcclient.InferenceServerClient(url=GI_MODEL_URL)
         self.redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
         if request_data.mode == "img2img":
@@ -63,10 +64,13 @@ class GenerateImage:
         # Read data from response.
         # read image use cv2
         try:
-            response = self.minio_client.get_object(image_url.split('/')[0], image_url[image_url.find('/') + 1:])
-            image_file = BytesIO(response.data)
-            image_array = np.asarray(bytearray(image_file.read()), dtype=np.uint8)
-            image_cv2 = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+            # response = self.minio_client.get_object(image_url.split('/')[0], image_url[image_url.find('/') + 1:])
+            # image_file = BytesIO(response.data)
+            # image_array = np.asarray(bytearray(image_file.read()), dtype=np.uint8)
+            # image_cv2 = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+            # image_rbg = cv2.cvtColor(image_cv2, cv2.COLOR_BGR2RGB)
+
+            image_cv2 = get_image(object_name=image_url, data_type="cv2")
             image_rbg = cv2.cvtColor(image_cv2, cv2.COLOR_BGR2RGB)
             image = cv2.resize(image_rbg, (1024, 1024))
         except minio.error.S3Error:
@@ -189,7 +193,8 @@ if __name__ == '__main__':
         prompt='skeleton sitting by the side of a river looking soulful, concert poster, 4k, artistic',
         image_url="",
         mode='txt2img',
-        category="test"
+        category="test",
+        gender="male"
     )
     server = GenerateImage(rd)
     print(server.get_result())

app/service/generate_image/service_generate_product_image.py

@@ -18,10 +18,10 @@ import numpy as np
 from PIL import Image, ImageOps
 from minio import Minio
 from tritonclient.utils import np_to_triton_dtype
-
 from app.core.config import *
-from app.schemas.generate_image import GenerateImageModel, GenerateProductImageModel
+from app.schemas.generate_image import GenerateProductImageModel
 from app.service.generate_image.utils.upload_sd_image import upload_SDXL_image
+from app.service.utils.oss_client import oss_get_image
 
 logger = logging.getLogger()
 
@@ -33,69 +33,29 @@ class GenerateProductImage:
             self.channel = self.connection.channel()
         # self.connection = pika.BlockingConnection(pika.ConnectionParameters(**RABBITMQ_PARAMS))
         # self.channel = self.connection.channel()
-        self.minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
+        # self.minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
         self.grpc_client = grpcclient.InferenceServerClient(url=GPI_MODEL_URL)
         self.redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
         self.category = "product_image"
         self.batch_size = 1
         self.prompt = request_data.prompt
-        # TODO aida design 结果图背景改为白色
-        self.image, self.image_size = self.get_image(request_data.image_url)
-        # TODO image 填充并resize成512*768
-
+        self.image, self.image_size = pre_processing_image(request_data.image_url)
         self.tasks_id = request_data.tasks_id
         self.user_id = self.tasks_id[self.tasks_id.rfind('-') + 1:]
         self.gen_product_data = {'tasks_id': self.tasks_id, 'status': 'PENDING', 'message': "pending", 'image_url': ''}
         self.redis_client.set(self.tasks_id, json.dumps(self.gen_product_data))
         self.redis_client.expire(self.tasks_id, 600)
 
-    def get_image(self, image_url):
-        response = self.minio_client.get_object(image_url.split('/')[0], image_url[image_url.find('/') + 1:])
-        image_bytes = io.BytesIO(response.read())
-
-        # 转换为PIL图像对象
-        image = Image.open(image_bytes)
-        target_height = 768
-        target_width = 512
-
-        aspect_ratio = image.width / image.height
-        new_width = int(target_height * aspect_ratio)
-
-        resized_image = image.resize((new_width, target_height))
-        left = (target_width - resized_image.width) // 2
-        top = (target_height - resized_image.height) // 2
-        right = target_width - resized_image.width - left
-        bottom = target_height - resized_image.height - top
-        image = ImageOps.expand(resized_image, (left, top, right, bottom), fill="white")
-        image_size = image.size
-        if image.mode in ('RGBA', 'LA') or (image.mode == 'P' and 'transparency' in image.info):
-            # 创建白色背景
-            background = Image.new("RGB", image.size, (255, 255, 255))
-            # 将图片粘贴到白色背景上
-            background.paste(image, mask=image.split()[3])
-            image = np.array(background)
-            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-
-            # image_file = BytesIO(response.data)
-            # image_array = np.asarray(bytearray(image_file.read()), dtype=np.uint8)
-            # image_cv2 = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
-            # image = cv2.cvtColor(image_cv2, cv2.COLOR_BGR2RGB)
-            # image = cv2.resize(image_rbg, (1024, 1024))
-        return image, image_size
-
     def callback(self, result, error):
         if error:
             self.gen_product_data['status'] = "FAILURE"
             self.gen_product_data['message'] = str(error)
-            # self.gen_product_data['data'] = str(error)
             self.redis_client.set(self.tasks_id, json.dumps(self.gen_product_data))
         else:
             # pil图像转成numpy数组
             image = result.as_numpy("generated_inpaint_image")
             image_result = Image.fromarray(np.squeeze(image.astype(np.uint8))).resize(self.image_size)
-
-            image_url = upload_SDXL_image(image_result, user_id=self.user_id, category=f"{self.category}", object_name=f"{self.tasks_id}.png")
-            # logger.info(f"upload image SUCCESS ： {image_url}")
+            image_url = upload_SDXL_image(image_result, user_id=self.user_id, category=f"{self.category}", file_name=f"{self.tasks_id}.png")
             self.gen_product_data['status'] = "SUCCESS"
             self.gen_product_data['message'] = "success"
             self.gen_product_data['image_url'] = str(image_url)
@@ -105,13 +65,6 @@ class GenerateProductImage:
         status_data = self.redis_client.get(self.tasks_id)
         return json.loads(status_data), status_data
 
-    def infer(self, inputs):
-        return self.grpc_client.async_infer(
-            model_name=GPI_MODEL_NAME,
-            inputs=inputs,
-            callback=self.callback
-        )
-
     def get_result(self):
         try:
             prompts = [self.prompt] * self.batch_size
@@ -129,11 +82,10 @@ class GenerateProductImage:
             input_image.set_data_from_numpy(image_obj)
             inputs = [input_text, input_image]
 
-            ctx = self.infer(inputs)
+            ctx = self.grpc_client.async_infer(model_name=GPI_MODEL_NAME, inputs=inputs, callback=self.callback)
             time_out = 600
             while time_out > 0:
                 gen_product_data, _ = self.read_tasks_status()
-                # logger.info(gen_product_data)
                 if gen_product_data['status'] in ["REVOKED", "FAILURE"]:
                     ctx.cancel()
                     break
@@ -141,7 +93,6 @@ class GenerateProductImage:
                     break
                 time_out -= 1
                 time.sleep(0.1)
-                # logger.info(time_out, gen_product_data)
             gen_product_data, _ = self.read_tasks_status()
             return gen_product_data
         except Exception as e:
@@ -153,7 +104,6 @@ class GenerateProductImage:
             dict_gen_product_data, str_gen_product_data = self.read_tasks_status()
             if DEBUG is False:
                 self.channel.basic_publish(exchange='', routing_key=GPI_RABBITMQ_QUEUES, body=str_gen_product_data)
-            # self.channel.basic_publish(exchange='', routing_key=GEN_PRODUCT_IMAGE_RABBITMQ_QUEUES, body=str_gen_product_data)
             logger.info(f" [x] Sent to： {GPI_RABBITMQ_QUEUES} data：@@@@  {json.dumps(dict_gen_product_data, indent=4)}")
 
 
@@ -165,11 +115,36 @@ def infer_cancel(tasks_id):
     return data
 
 
+def pre_processing_image(image_url):
+    image = oss_get_image(bucket=image_url.split('/')[0], object_name=image_url[image_url.find('/') + 1:], data_type="PIL")
+
+    # resize 图片内尺寸 并贴到768-512的纯白图像上
+    target_height = 768
+    target_width = 512
+    aspect_ratio = image.width / image.height
+    new_width = int(target_height * aspect_ratio)
+    resized_image = image.resize((new_width, target_height))
+    left = (target_width - resized_image.width) // 2
+    top = (target_height - resized_image.height) // 2
+    right = target_width - resized_image.width - left
+    bottom = target_height - resized_image.height - top
+    image = ImageOps.expand(resized_image, (left, top, right, bottom), fill="white")
+    image_size = image.size
+    if image.mode in ('RGBA', 'LA') or (image.mode == 'P' and 'transparency' in image.info):
+        # 创建白色背景
+        background = Image.new("RGB", image.size, (255, 255, 255))
+        # 将图片粘贴到白色背景上
+        background.paste(image, mask=image.split()[3])
+        image = np.array(background)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    return image, image_size
+
+
 if __name__ == '__main__':
     rd = GenerateProductImageModel(
         tasks_id="123-89",
         prompt="",
-        # prompt="best quality, masterpiece. detailed, high-res, simple background, studio photography, extremely detailed, updo, detailed face, face, close-up, HDR, UHD, 8K realistic, Highly detailed, simple background, Studio lighting",
+        # prompt=" the best quality, masterpiece. detailed, high-res, simple background, studio photography, extremely detailed, updo, detailed face, face, close-up, HDR, UHD, 8K realistic, Highly detailed, simple background, Studio lighting",
         image_url="aida-results/result_00097282-ebb2-11ee-a822-b48351119060.png",
     )
     server = GenerateProductImage(rd)

app/service/generate_image/service_generate_relight_image.py

@@ -22,6 +22,7 @@ from tritonclient.utils import np_to_triton_dtype
 from app.core.config import *
 from app.schemas.generate_image import GenerateRelightImageModel
 from app.service.generate_image.utils.upload_sd_image import upload_SDXL_image
+from app.service.utils.oss_client import oss_get_image
 
 logger = logging.getLogger()
 
@@ -31,43 +32,34 @@ class GenerateRelightImage:
         if DEBUG is False:
             self.connection = pika.BlockingConnection(pika.ConnectionParameters(**RABBITMQ_PARAMS))
             self.channel = self.connection.channel()
-        self.minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
+        # self.minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
         self.grpc_client = grpcclient.InferenceServerClient(url=GRI_MODEL_URL)
         self.redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
         self.category = "relight_image"
         self.batch_size = 1
         self.prompt = request_data.prompt
-        self.seed = "12345"
+        self.seed = "1"
         self.negative_prompt = 'lowres, bad anatomy, bad hands, cropped, worst quality'
         self.direction = "Right Light"
-        # TODO aida design 结果图背景改为白色
-        self.image = self.get_image(request_data.image_url)
-        # TODO image 填充并resize成512*768
-
+        self.image_url = request_data.image_url
+        self.image = oss_get_image(bucket=self.image_url.split('/')[0], object_name=self.image_url[self.image_url.find('/') + 1:], data_type="cv2")
         self.tasks_id = request_data.tasks_id
         self.user_id = self.tasks_id[self.tasks_id.rfind('-') + 1:]
         self.gen_product_data = {'tasks_id': self.tasks_id, 'status': 'PENDING', 'message': "pending", 'image_url': ''}
         self.redis_client.set(self.tasks_id, json.dumps(self.gen_product_data))
         self.redis_client.expire(self.tasks_id, 600)
 
-    def get_image(self, image_url):
-        response = self.minio_client.get_object(image_url.split('/')[0], image_url[image_url.find('/') + 1:])
-        image = cv2.imdecode(np.frombuffer(response.data, np.uint8), 1)
-        return image
-
     def callback(self, result, error):
         if error:
             self.gen_product_data['status'] = "FAILURE"
             self.gen_product_data['message'] = str(error)
-            # self.gen_product_data['data'] = str(error)
             self.redis_client.set(self.tasks_id, json.dumps(self.gen_product_data))
         else:
             # pil图像转成numpy数组
             image = result.as_numpy("generated_inpaint_image")
             image_result = Image.fromarray(np.squeeze(image.astype(np.uint8)))
 
-            image_url = upload_SDXL_image(image_result, user_id=self.user_id, category=f"{self.category}", object_name=f"{self.tasks_id}.png")
-            # logger.info(f"upload image SUCCESS ： {image_url}")
+            image_url = upload_SDXL_image(image_result, user_id=self.user_id, category=f"{self.category}", file_name=f"{self.tasks_id}.png")
             self.gen_product_data['status'] = "SUCCESS"
             self.gen_product_data['message'] = "success"
             self.gen_product_data['image_url'] = str(image_url)
@@ -77,13 +69,6 @@ class GenerateRelightImage:
         status_data = self.redis_client.get(self.tasks_id)
         return json.loads(status_data), status_data
 
-    def infer(self, inputs):
-        return self.grpc_client.async_infer(
-            model_name=GRI_MODEL_NAME,
-            inputs=inputs,
-            callback=self.callback
-        )
-
     def get_result(self):
         try:
             prompts = [self.prompt] * self.batch_size
@@ -114,11 +99,10 @@ class GenerateRelightImage:
 
             inputs = [input_text, input_natext, input_image, input_seed, input_direction]
 
-            ctx = self.infer(inputs)
+            ctx = self.grpc_client.async_infer(model_name=GRI_MODEL_NAME, inputs=inputs, callback=self.callback)
             time_out = 600
             while time_out > 0:
                 gen_product_data, _ = self.read_tasks_status()
-                # logger.info(gen_product_data)
                 if gen_product_data['status'] in ["REVOKED", "FAILURE"]:
                     ctx.cancel()
                     break
@@ -126,7 +110,6 @@ class GenerateRelightImage:
                     break
                 time_out -= 1
                 time.sleep(0.1)
-                # logger.info(time_out, gen_product_data)
             gen_product_data, _ = self.read_tasks_status()
             return gen_product_data
         except Exception as e:
@@ -138,7 +121,6 @@ class GenerateRelightImage:
             dict_gen_product_data, str_gen_product_data = self.read_tasks_status()
             if DEBUG is False:
                 self.channel.basic_publish(exchange='', routing_key=GRI_RABBITMQ_QUEUES, body=str_gen_product_data)
-            # self.channel.basic_publish(exchange='', routing_key=GEN_PRODUCT_IMAGE_RABBITMQ_QUEUES, body=str_gen_product_data)
             logger.info(f" [x] Sent to： {GRI_RABBITMQ_QUEUES} data：@@@@  {json.dumps(dict_gen_product_data, indent=4)}")
 
 
@@ -154,7 +136,7 @@ if __name__ == '__main__':
     rd = GenerateRelightImageModel(
         tasks_id="123-89",
         # prompt="beautiful woman, detailed face, sunshine, outdoor, warm atmosphere",
-        prompt="",
+        prompt="Colorful black",
         image_url='aida-users/89/product_image/123-89.png'
     )
     server = GenerateRelightImage(rd)

app/service/generate_image/service_generate_single_logo.py

@@ -31,8 +31,6 @@ class GenerateSingleLogoImage:
         if DEBUG is False:
             self.connection = pika.BlockingConnection(pika.ConnectionParameters(**RABBITMQ_PARAMS))
             self.channel = self.connection.channel()
-        # self.connection = pika.BlockingConnection(pika.ConnectionParameters(**RABBITMQ_PARAMS))
-        # self.channel = self.connection.channel()
         self.minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
         self.grpc_client = grpcclient.InferenceServerClient(url=GSL_MODEL_URL)
         self.redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
@@ -51,23 +49,15 @@ class GenerateSingleLogoImage:
         status_data = self.redis_client.get(self.tasks_id)
         return json.loads(status_data), status_data
 
-    def infer(self, inputs):
-        return self.grpc_client.async_infer(
-            model_name=GSL_MODEL_NAME,
-            inputs=inputs,
-            callback=self.callback
-        )
-
     def callback(self, result, error):
         if error:
             self.gen_single_logo_data['status'] = "FAILURE"
             self.gen_single_logo_data['message'] = str(error)
-            # self.generate_data['data'] = str(error)
             self.redis_client.set(self.tasks_id, json.dumps(self.gen_single_logo_data))
         else:
             image = result.as_numpy("generated_image")
             image_result = Image.fromarray(np.squeeze(image.astype(np.uint8)))
-            image_url = upload_SDXL_image(image_result, user_id=self.user_id, category=f"{self.category}", object_name=f"{self.tasks_id}.png")
+            image_url = upload_SDXL_image(image_result, user_id=self.user_id, category=f"{self.category}", file_name=f"{self.tasks_id}.png")
             self.gen_single_logo_data['status'] = "SUCCESS"
             self.gen_single_logo_data['message'] = "success"
             self.gen_single_logo_data['image_url'] = str(image_url)
@@ -81,25 +71,19 @@ class GenerateSingleLogoImage:
             input_text = grpcclient.InferInput("prompt", text_obj.shape, np_to_triton_dtype(text_obj.dtype))
             input_text.set_data_from_numpy(text_obj)
 
-            # negative_prompts
             text_obj_neg = np.array(self.negative_prompts, dtype="object").reshape((-1, 1))
-            # print('text obj neg: ', text_obj_neg)
             input_text_neg = grpcclient.InferInput("negative_prompt", text_obj_neg.shape, np_to_triton_dtype(text_obj_neg.dtype))
             input_text_neg.set_data_from_numpy(text_obj_neg)
 
-            # seed
             seed = np.array(self.seed, dtype="object").reshape((-1, 1))
             input_seed = grpcclient.InferInput("seed", seed.shape, np_to_triton_dtype(seed.dtype))
             input_seed.set_data_from_numpy(seed)
-
             inputs = [input_text, input_text_neg, input_seed]
-
-            ctx = self.infer(inputs)
+            ctx = self.grpc_client.async_infer(model_name=GSL_MODEL_NAME, inputs=inputs, callback=self.callback)
             time_out = 600
             generate_data = None
             while time_out > 0:
                 generate_data, _ = self.read_tasks_status()
-                # logger.info(generate_data)
                 if generate_data['status'] in ["REVOKED", "FAILURE"]:
                     ctx.cancel()
                     break
@@ -107,7 +91,6 @@ class GenerateSingleLogoImage:
                     break
                 time_out -= 1
                 time.sleep(0.1)
-                # logger.info(time_out, generate_data)
             return generate_data
         except Exception as e:
             raise Exception(str(e))
@@ -115,7 +98,6 @@ class GenerateSingleLogoImage:
             dict_generate_data, str_generate_data = self.read_tasks_status()
             if DEBUG is False:
                 self.channel.basic_publish(exchange='', routing_key=GI_RABBITMQ_QUEUES, body=str_generate_data)
-            # self.channel.basic_publish(exchange='', routing_key=GI_RABBITMQ_QUEUES, body=str_generate_data)
             logger.info(f" [x] Sent {json.dumps(dict_generate_data, indent=4)}")
 
 

app/service/generate_image/utils/upload_sd_image.py

@@ -16,8 +16,11 @@ from PIL import Image
 from minio import Minio
 
 from app.core.config import *
+from app.service.utils.oss_client import oss_upload_image
 
 minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
+
+
 # s3 = boto3.client('s3', aws_access_key_id=S3_ACCESS_KEY, aws_secret_access_key=S3_AWS_SECRET_ACCESS_KEY, region_name=S3_REGION_NAME)
 
 
@@ -34,36 +37,34 @@ minio_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET
 #     except Exception as e:
 #         print(f'上传到 S3 失败: {e}')
 
-def upload_SDXL_image(image, user_id, category, object_name):
+def upload_SDXL_image(image, user_id, category, file_name):
     try:
         image_data = io.BytesIO()
         image.save(image_data, format='PNG')
         image_data.seek(0)
         image_bytes = image_data.read()
-        minio_req = minio_client.put_object(
-            GI_MINIO_BUCKET,
-            f'{user_id}/{category}/{object_name}',
-            io.BytesIO(image_bytes),
-            len(image_bytes),
-            content_type='image/jpeg'
-        )
-        image_url = f"aida-users/{minio_req.object_name}"
+
+        # minio_req = minio_client.put_object(
+        #     GI_MINIO_BUCKET,
+        #     f'{user_id}/{category}/{file_name}',
+        #     io.BytesIO(image_bytes),
+        #     len(image_bytes),
+        #     content_type='image/jpeg'
+        # )
+        object_name = f'{user_id}/{category}/{file_name}'
+        req = oss_upload_image(bucket=GI_MINIO_BUCKET, object_name=object_name, image_bytes=image_bytes)
+        image_url = f"aida-users/{object_name}"
         return image_url
     except Exception as e:
         logging.warning(f"upload_png_mask runtime exception : {e}")
 
 
-def upload_png_sd(image, user_id, category, object_name):
+def upload_png_sd(image, user_id, category, file_name):
     try:
         _, img_byte_array = cv2.imencode('.jpg', image)
-        minio_req = minio_client.put_object(
-            GI_MINIO_BUCKET,
-            f'{user_id}/{category}/{object_name}',
-            io.BytesIO(img_byte_array),
-            len(img_byte_array),
-            content_type='image/jpeg'
-        )
-        image_url = f"aida-users/{minio_req.object_name}"
+        object_name = f'{user_id}/{category}/{file_name}'
+        req = oss_upload_image(bucket=GI_MINIO_BUCKET, object_name=object_name, image_bytes=img_byte_array)
+        image_url = f"aida-users/{object_name}"
         return image_url
     except Exception as e:
         logging.warning(f"upload_png_mask runtime exception : {e}")

app/service/utils/oss_client.py

@@ -0,0 +1,70 @@
+import io
+import logging
+from io import BytesIO
+
+import boto3
+import cv2
+import numpy as np
+from PIL import Image
+from minio import Minio
+
+from app.core.config import *
+
+logger = logging.getLogger()
+
+
+#  获取图片
+def oss_get_image(bucket, object_name, data_type):
+    image_object = None
+
+    try:
+        if OSS == "minio":
+            oss_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
+            image_data = oss_client.get_object(bucket_name=bucket, object_name=object_name)
+        else:
+            oss_client = boto3.client('s3', aws_access_key_id=S3_ACCESS_KEY, aws_secret_access_key=S3_AWS_SECRET_ACCESS_KEY, region_name=S3_REGION_NAME)
+            image_data = oss_client.get_object(Bucket=bucket, Key=object_name)['Body']
+
+        if data_type == "cv2":
+            image_bytes = image_data.read()
+            image_array = np.frombuffer(image_bytes, np.uint8)  # 转成8位无符号整型
+            image_object = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+        else:
+            data_bytes = BytesIO(image_data.read())
+            image_object = Image.open(data_bytes)
+    except Exception as e:
+        logger.warning(f"{OSS} | 获取图片出现异常 ######: {e}")
+    return image_object
+
+
+def oss_upload_image(bucket, object_name, image_bytes):
+    req = None
+    try:
+        if OSS == "minio":
+            oss_client = Minio(MINIO_URL, access_key=MINIO_ACCESS, secret_key=MINIO_SECRET, secure=MINIO_SECURE)
+            req = oss_client.put_object(bucket_name=bucket, object_name=object_name, data=io.BytesIO(image_bytes), length=len(image_bytes), content_type='image/png')
+        else:
+            oss_client = boto3.client('s3', aws_access_key_id=S3_ACCESS_KEY, aws_secret_access_key=S3_AWS_SECRET_ACCESS_KEY, region_name=S3_REGION_NAME)
+            req = oss_client.put_object(Bucket=AIDA_CLOTHING, Key=object_name, Body=image_bytes, ContentType='image/png')
+    except Exception as e:
+        logger.warning(f"{OSS} | 上传图片出现异常 ######: {e}")
+    return req
+
+
+if __name__ == '__main__':
+    # url = "aida-results/result_0002186a-e631-11ee-86a6-b48351119060.png"
+    # url = "aida-collection-element/11523/Moodboard/f60af0d2-94c2-48f9-90ff-74b8e8a481b5.jpg"
+    # url = "aida-sys-image/images/female/outwear/0628000054.jpg"
+    # url = "aida-users/89/product_image/string-89.png"
+    # url = "aida-users/89/single_logo/123-89.png"
+    # url = 'aida-users/89/relight_image/123-89.png'
+    # url = 'aida-users/89/relight_image/123-89.png'
+    url = 'aida-users/89/relight_image/123-89.png'
+    read_type = "PIL"
+    if read_type == "cv2":
+        img = oss_get_image(bucket=url.split('/')[0], object_name=url[url.find('/') + 1:], data_type=read_type)
+        cv2.imshow("", img)
+        cv2.waitKey(0)
+    else:
+        img = oss_get_image(bucket=url.split('/')[0], object_name=url[url.find('/') + 1:], data_type=read_type)
+        img.show()