EN demo

app.py

@@ -1,3 +1,4 @@
+import os
 import gradio as gr
 import onnxruntime
 from src.face_judgement_align import IDphotos_create
@@ -7,24 +8,33 @@ import pathlib
 import numpy as np
 from image_utils import resize_image_to_kb
 from data_utils import csv_to_size_list
+import argparse
+
 
 # 获取尺寸列表
-size_list_dict = csv_to_size_list("size_list_CN.csv")
-print(size_list_dict)
+root_dir = os.path.dirname(os.path.abspath(__file__))
+size_list_dict_CN = csv_to_size_list(os.path.join(root_dir, "size_list_CN.csv"))
+size_list_dict_EN = csv_to_size_list(os.path.join(root_dir, "size_list_EN.csv"))
 
-color_list_dict = {
+color_list_dict_CN = {
     "蓝色": (86, 140, 212),
     "白色": (255, 255, 255),
     "红色": (233, 51, 35),
 }
 
+color_list_dict_EN = {
+    "Blue": (86, 140, 212),
+    "White": (255, 255, 255),
+    "Red": (233, 51, 35),
+}
+
 
-# 设置Gradio examples
+# 设置 Gradio examples
 def set_example_image(example: list) -> dict:
     return gr.Image.update(value=example[0])
 
 
-# 检测RGB是否超出范围，如果超出则约束到0～255之间
+# 检测 RGB 是否超出范围，如果超出则约束到 0～255 之间
 def range_check(value, min_value=0, max_value=255):
     value = int(value)
     if value <= min_value:
@@ -47,12 +57,12 @@ def idphoto_inference(
     custom_size_height,
     custom_size_width,
     custom_image_kb,
+    language,
     head_measure_ratio=0.2,
     head_height_ratio=0.45,
     top_distance_max=0.12,
     top_distance_min=0.10,
 ):
-
     idphoto_json = {
         "size_mode": mode_option,
         "color_mode": color_option,
@@ -60,11 +70,45 @@ def idphoto_inference(
         "image_kb_mode": image_kb_options,
     }
 
+    text_lang_map = {
+        "中文": {
+            "Size List": "尺寸列表",
+            "Custom Size": "自定义尺寸",
+            "The width should not be greater than the length; the length and width should not be less than 100, and no more than 1800.": "宽度应不大于长度；长宽不应小于 100，大于 1800",
+            "Custom Color": "自定义底色",
+            "Custom": "自定义",
+            "The number of faces is not equal to 1": "人脸数量不等于 1",
+            "Solid Color": "纯色",
+            "Up-Down Gradient (White)": "上下渐变 (白)",
+            "Center Gradient (White)": "中心渐变 (白)",
+            "Set KB size (Download in the bottom right)": "设置 KB 大小（结果在右边最底的组件下载）",
+            "Not Set": "不设置",
+            "Only Change Background": "只换底",
+        },
+        "English": {
+            "Size List": "Size List",
+            "Custom Size": "Custom Size",
+            "The width should not be greater than the length; the length and width should not be less than 100, and no more than 1800.": "The width should not be greater than the length; the length and width should not be less than 100, and no more than 1800.",
+            "Custom Color": "Custom Color",
+            "Custom": "Custom",
+            "The number of faces is not equal to 1": "The number of faces is not equal to 1",
+            "Solid Color": "Solid Color",
+            "Up-Down Gradient (White)": "Up-Down Gradient (White)",
+            "Center Gradient (White)": "Center Gradient (White)",
+            "Set KB size (Download in the bottom right)": "Set KB size (Download in the bottom right)",
+            "Not Set": "Not Set",
+            "Only Change Background": "Only Change Background",
+        },
+    }
+
     # 如果尺寸模式选择的是尺寸列表
-    if idphoto_json["size_mode"] == "尺寸列表":
-        idphoto_json["size"] = size_list_dict[size_list_option]
+    if idphoto_json["size_mode"] == text_lang_map[language]["Size List"]:
+        if language == "中文":
+            idphoto_json["size"] = size_list_dict_CN[size_list_option]
+        else:
+            idphoto_json["size"] = size_list_dict_EN[size_list_option]
     # 如果尺寸模式选择的是自定义尺寸
-    elif idphoto_json["size_mode"] == "自定义尺寸":
+    elif idphoto_json["size_mode"] == text_lang_map[language]["Custom Size"]:
         id_height = int(custom_size_height)
         id_width = int(custom_size_width)
         if (
@@ -76,7 +120,10 @@ def idphoto_inference(
                 img_output_standard: gr.update(value=None),
                 img_output_standard_hd: gr.update(value=None),
                 notification: gr.update(
-                    value="宽度应不大于长度；长宽不应小于100，大于1800", visible=True
+                    value=text_lang_map[language][
+                        "The width should not be greater than the length; the length and width should not be less than 100, and no more than 1800."
+                    ],
+                    visible=True,
                 ),
             }
         idphoto_json["size"] = (id_height, id_width)
@@ -84,17 +131,20 @@ def idphoto_inference(
         idphoto_json["size"] = (None, None)
 
     # 如果颜色模式选择的是自定义底色
-    if idphoto_json["color_mode"] == "自定义��色":
+    if idphoto_json["color_mode"] == text_lang_map[language]["Custom Color"]:
         idphoto_json["color_bgr"] = (
             range_check(custom_color_R),
             range_check(custom_color_G),
             range_check(custom_color_B),
         )
     else:
-        idphoto_json["color_bgr"] = color_list_dict[color_option]
+        if language == "中文":
+            idphoto_json["color_bgr"] = color_list_dict_CN[color_option]
+        else:
+            idphoto_json["color_bgr"] = color_list_dict_EN[color_option]
 
-    # 如果输出KB大小选择的是自定义
-    if idphoto_json["image_kb_mode"] == "自定义":
+    # 如果输出 KB 大小选择的是自定义
+    if idphoto_json["image_kb_mode"] == text_lang_map[language]["Custom"]:
         idphoto_json["custom_image_kb"] = custom_image_kb
     else:
         idphoto_json["custom_image_kb"] = None
@@ -125,24 +175,30 @@ def idphoto_inference(
         top_distance_min=top_distance_min,
     )
 
-    # 如果检测到人脸数量不等于1
+    # 如果检测到人脸数量不等于 1
     if status == 0:
         result_messgae = {
             img_output_standard: gr.update(value=None),
             img_output_standard_hd: gr.update(value=None),
-            notification: gr.update(value="人脸数量不等于1", visible=True),
+            notification: gr.update(
+                value=text_lang_map[language]["The number of faces is not equal to 1"],
+                visible=True,
+            ),
         }
 
-    # 如果检测到人脸数量等于1
+    # 如果检测到人脸数量等于 1
     else:
-        if idphoto_json["render_mode"] == "纯色":
+        if idphoto_json["render_mode"] == text_lang_map[language]["Solid Color"]:
             result_image_standard = np.uint8(
                 add_background(result_image_standard, bgr=idphoto_json["color_bgr"])
             )
             result_image_hd = np.uint8(
                 add_background(result_image_hd, bgr=idphoto_json["color_bgr"])
             )
-        elif idphoto_json["render_mode"] == "上下渐变(白)":
+        elif (
+            idphoto_json["render_mode"]
+            == text_lang_map[language]["Up-Down Gradient (White)"]
+        ):
             result_image_standard = np.uint8(
                 add_background(
                     result_image_standard,
@@ -173,7 +229,10 @@ def idphoto_inference(
                 )
             )
 
-        if idphoto_json["size_mode"] == "只换底":
+        if (
+            idphoto_json["size_mode"]
+            == text_lang_map[language]["Only Change Background"]
+        ):
             result_layout_image = gr.update(visible=False)
         else:
             typography_arr, typography_rotate = generate_layout_photo(
@@ -189,11 +248,11 @@ def idphoto_inference(
                 width=idphoto_json["size"][1],
             )
 
-        # 如果输出KB大小选择的是自定义
+        # 如果输出 KB 大小选择的是自定义
         if idphoto_json["custom_image_kb"]:
             # 将标准照大小调整至目标大小
-            print("调整kb大小到", idphoto_json["custom_image_kb"], "kb")
-            # 输出路径为一个根据时间戳+哈希值生成的随机文件名
+            print("调整 kb 大小到", idphoto_json["custom_image_kb"], "kb")
+            # 输出路径为一个根据时间戳 + 哈希值生成的随机文件名
             import time
 
             output_image_path = f"./output/{int(time.time())}.jpg"
@@ -226,18 +285,28 @@ def idphoto_inference(
 
 
 if __name__ == "__main__":
-    # 预加载ONNX模型
-    HY_HUMAN_MATTING_WEIGHTS_PATH = "./hivision_modnet.onnx"
+    # 预加载 ONNX 模型
+    HY_HUMAN_MATTING_WEIGHTS_PATH = os.path.join(root_dir, "hivision_modnet.onnx")
     sess = onnxruntime.InferenceSession(HY_HUMAN_MATTING_WEIGHTS_PATH)
 
-    size_mode = ["尺寸列表", "只换底", "自定义尺寸"]
-    size_list = list(size_list_dict.keys())
-    colors = ["蓝色", "白色", "红色", "自定义底色"]
-    render = ["纯色", "上下渐变(白)", "中心渐变(白)"]
-    image_kb = ["不设置", "自定义"]
+    language = ["中文", "English"]
+    size_mode_CN = ["尺寸列表", "只换底", "自定义尺寸"]
+    size_mode_EN = ["Size List", "Only Change Background", "Custom Size"]
+
+    size_list_CN = list(size_list_dict_CN.keys())
+    size_list_EN = list(size_list_dict_EN.keys())
+
+    colors_CN = ["蓝色", "白色", "红色", "自定义底色"]
+    colors_EN = ["Blue", "White", "Red", "Custom Color"]
+
+    render_CN = ["纯色", "上下渐变 (白)", "中心渐变 (白)"]
+    render_EN = ["Solid Color", "Up-Down Gradient (White)", "Center Gradient (White)"]
+
+    image_kb_CN = ["不设置", "自定义"]
+    image_kb_EN = ["Not Set", "Custom"]
 
     title = "<h1 id='title'>HivisionIDPhotos</h1>"
-    description = "<h3>😎9.2更新：新增照片大小KB调整</h3>"
+    description = "<h3>😎9.2 Update: Add photo size KB adjustment</h3>"
     css = """
     h1#title, h3 {
       text-align: center;
@@ -250,21 +319,26 @@ if __name__ == "__main__":
         gr.Markdown(title)
         gr.Markdown(description)
         with gr.Row():
-            # ------------ 左半边UI ----------------
+            # ------------ 左半边 UI ----------------
             with gr.Column():
                 img_input = gr.Image().style(height=350)
+                language_options = gr.Dropdown(
+                    choices=language, label="Language", value="English", elem_id="language"
+                )
+
                 mode_options = gr.Radio(
-                    choices=size_mode,
-                    label="证件照尺寸选项",
-                    value="尺寸列表",
+                    choices=size_mode_EN,
+                    label="ID photo size options",
+                    value="Size List",
                     elem_id="size",
                 )
+
                 # 预设尺寸下拉菜单
                 with gr.Row(visible=True) as size_list_row:
                     size_list_options = gr.Dropdown(
-                        choices=size_list,
-                        label="预设尺寸",
-                        value="一寸",
+                        choices=size_list_EN,
+                        label="Default size",
+                        value="One inch",
                         elem_id="size_list",
                     )
 
@@ -278,10 +352,10 @@ if __name__ == "__main__":
 
                 # 左：背景色选项
                 color_options = gr.Radio(
-                    choices=colors, label="背景色", value="蓝色", elem_id="color"
+                    choices=colors_EN, label="Background color", value="Blue", elem_id="color"
                 )
 
-                # 左：如果选择「自定义底色」，显示RGB输入框
+                # 左：如果选择「自定义底色」，显示 RGB 输入框
                 with gr.Row(visible=False) as custom_color:
                     custom_color_R = gr.Number(value=0, label="R", interactive=True)
                     custom_color_G = gr.Number(value=0, label="G", interactive=True)
@@ -289,64 +363,149 @@ if __name__ == "__main__":
 
                 # 左：渲染方式选项
                 render_options = gr.Radio(
-                    choices=render,
-                    label="渲染方式",
-                    value="纯色",
+                    choices=render_EN,
+                    label="Rendering mode",
+                    value="Solid Color",
                     elem_id="render",
                 )
 
-                # 左：输出KB大小选项
+                # 左：输出 KB 大小选项
                 image_kb_options = gr.Radio(
-                    choices=image_kb,
-                    label="设置KB大小（结果在右边最底的组件下载）",
-                    value="不设置",
+                    choices=image_kb_EN,
+                    label="Set KB size (Download in the bottom right)",
+                    value="Not Set",
                     elem_id="image_kb",
                 )
 
-                # 自定义KB大小, 滑动条，最小10KB，最大200KB
+                # 自定义 KB 大小，滑动条，最小 10KB，最大 200KB
                 with gr.Row(visible=False) as custom_image_kb:
                     custom_image_kb_size = gr.Slider(
                         minimum=10,
                         maximum=1000,
                         value=50,
-                        label="KB大小",
+                        label="KB size",
                         interactive=True,
                     )
 
-                img_but = gr.Button("开始制作")
+                img_but = gr.Button("Start", elem_id="start")
 
                 # 案例图片
                 example_images = gr.Dataset(
                     components=[img_input],
                     samples=[
                         [path.as_posix()]
-                        for path in sorted(pathlib.Path("images").rglob("*.jpg"))
+                        for path in sorted(
+                            pathlib.Path(os.path.join(root_dir, "images")).rglob(
+                                "*.jpg"
+                            )
+                        )
                     ],
                 )
 
-            # ---------------- 右半边UI ----------------
+            # ---------------- 右半边 UI ----------------
             with gr.Column():
-                notification = gr.Text(label="状态", visible=False)
+                notification = gr.Text(label="Status", visible=False)
                 with gr.Row():
-                    img_output_standard = gr.Image(label="标准照").style(height=350)
-                    img_output_standard_hd = gr.Image(label="高清照").style(height=350)
-                img_output_layout = gr.Image(label="六寸排版照").style(height=350)
-                file_download = gr.File(label="下载调整KB大小后的照片", visible=False)
+                    img_output_standard = gr.Image(label="Standard photo").style(height=350)
+                    img_output_standard_hd = gr.Image(label="HD photo").style(height=350)
+                img_output_layout = gr.Image(label="Layout photo").style(height=350)
+                file_download = gr.File(label="Download the photo after adjusting the KB size", visible=False)
 
             # ---------------- 设置隐藏/显示组件 ----------------
+            def change_language(language):
+                # 将Gradio组件中的内容改为中文或英文
+                if language == "中文":
+                    return {
+                        size_list_options: gr.update(
+                            label="预设尺寸",
+                            choices=size_list_CN,
+                            value="一寸",
+                        ),
+                        mode_options: gr.update(
+                            label="证件照尺寸选项",
+                            choices=size_mode_CN,
+                            value="尺寸列表",
+                        ),
+                        color_options: gr.update(
+                            label="背景色",
+                            choices=colors_CN,
+                            value="蓝色",
+                        ),
+                        img_but: gr.update(value="开始制作"),
+                        render_options: gr.update(
+                            label="渲染方式",
+                            choices=render_CN,
+                            value="纯色",
+                        ),
+                        image_kb_options: gr.update(
+                            label="设置 KB 大小（结果在右边最底的组件下载）",
+                            choices=image_kb_CN,
+                            value="不设置",
+                        ),
+                        custom_image_kb_size: gr.update(label="KB 大小"),
+                        notification: gr.update(label="状态"),
+                        img_output_standard: gr.update(label="标准照"),
+                        img_output_standard_hd: gr.update(label="高清照"),
+                        img_output_layout: gr.update(label="六寸排版照"),
+                        file_download: gr.update(label="下载调整 KB 大小后的照片"),
+                    }
+                elif language == "English":
+                    return {
+                        size_list_options: gr.update(
+                            label="Default size",
+                            choices=size_list_EN,
+                            value="One inch",
+                        ),
+                        mode_options: gr.update(
+                            label="ID photo size options",
+                            choices=size_mode_EN,
+                            value="Size List",
+                        ),
+                        color_options: gr.update(
+                            label="Background color",
+                            choices=colors_EN,
+                            value="Blue",
+                        ),
+                        img_but: gr.update(value="Start"),
+                        render_options: gr.update(
+                            label="Rendering mode",
+                            choices=render_EN,
+                            value="Solid Color",
+                        ),
+                        image_kb_options: gr.update(
+                            label="Set KB size (Download in the bottom right)",
+                            choices=image_kb_EN,
+                            value="Not Set",
+                        ),
+                        custom_image_kb_size: gr.update(label="KB size"),
+                        notification: gr.update(label="Status"),
+                        img_output_standard: gr.update(label="Standard photo"),
+                        img_output_standard_hd: gr.update(label="HD photo"),
+                        img_output_layout: gr.update(label="Layout photo"),
+                        file_download: gr.update(
+                            label="Download the photo after adjusting the KB size"
+                        ),
+                    }
+
             def change_color(colors):
-                if colors == "自定义底色":
+                if colors == "自定义底色" or colors == "Custom Color":
                     return {custom_color: gr.update(visible=True)}
                 else:
                     return {custom_color: gr.update(visible=False)}
 
             def change_size_mode(size_option_item):
-                if size_option_item == "自定义尺寸":
+                if (
+                    size_option_item == "自定义尺寸"
+                    or size_option_item == "Custom Size"
+                ):
                     return {
                         custom_size: gr.update(visible=True),
                         size_list_row: gr.update(visible=False),
                     }
-                elif size_option_item == "只换底":
+                elif (
+                    size_option_item == "只换底"
+                    or size_option_item == "Only Change Background"
+                ):
                     return {
                         custom_size: gr.update(visible=False),
                         size_list_row: gr.update(visible=False),
@@ -358,12 +517,31 @@ if __name__ == "__main__":
                     }
 
             def change_image_kb(image_kb_option):
-                if image_kb_option == "自定义":
+                if image_kb_option == "自定义" or image_kb_option == "Custom":
                     return {custom_image_kb: gr.update(visible=True)}
                 else:
                     return {custom_image_kb: gr.update(visible=False)}
 
         # ---------------- 绑定事件 ----------------
+        language_options.input(
+            change_language,
+            inputs=[language_options],
+            outputs=[
+                size_list_options,
+                mode_options,
+                color_options,
+                img_but,
+                render_options,
+                image_kb_options,
+                custom_image_kb_size,
+                notification,
+                img_output_standard,
+                img_output_standard_hd,
+                img_output_layout,
+                file_download,
+            ],
+        )
+
         color_options.input(
             change_color, inputs=[color_options], outputs=[custom_color]
         )
@@ -393,6 +571,7 @@ if __name__ == "__main__":
                 custom_size_height,
                 custom_size_wdith,
                 custom_image_kb_size,
+                language_options,
             ],
             outputs=[
                 img_output_standard,
@@ -407,4 +586,13 @@ if __name__ == "__main__":
             fn=set_example_image, inputs=[example_images], outputs=[img_input]
         )
 
-    demo.launch()
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument(
+        "--port", type=int, default=7860, help="The port number of the server"
+    )
+    argparser.add_argument(
+        "--host", type=str, default="127.0.0.1", help="The host of the server"
+    )
+    args = argparser.parse_args()
+
+    demo.launch(server_name=args.host, server_port=args.port)

size_list_EN.csv

@@ -0,0 +1,16 @@
+Name,Height,Width
+One inch, 413, 295
+Two inches, 626, 413
+Small one inch, 378, 260
+Small two inches, 531, 413
+Large one inch, 567 ,390
+Large two inches,626,413 
+Five inches,1499,1050 
+Teacher qualification certificate,413,295 
+National civil service exam ,413 ,295 
+Primary accounting exam ,413 ,295 
+English CET-4 and CET-6 exams ,192 ,144 
+Computer level exam ,567 ,390  
+Graduate entrance exam ,709 ,531  
+Social security card ,441 ,358  
+Electronic driver's license ,378 ,260

src/face_judgement_align.py

@@ -3,11 +3,23 @@ import cv2
 import numpy as np
 from hivisionai.hycv.face_tools import face_detect_mtcnn
 from hivisionai.hycv.utils import get_box_pro
-from hivisionai.hycv.vision import resize_image_esp, IDphotos_cut, add_background, calTime, resize_image_by_min, \
-    rotate_bound_4channels
+from hivisionai.hycv.vision import (
+    resize_image_esp,
+    IDphotos_cut,
+    add_background,
+    calTime,
+    resize_image_by_min,
+    rotate_bound_4channels,
+)
 import onnxruntime
 from src.error import IDError
-from src.imageTransform import standard_photo_resize, hollowOutFix, get_modnet_matting, draw_picture_dots, detect_distance
+from src.imageTransform import (
+    standard_photo_resize,
+    hollowOutFix,
+    get_modnet_matting,
+    draw_picture_dots,
+    detect_distance,
+)
 from src.layoutCreate import generate_layout_photo
 from src.move_image import move
 
@@ -67,17 +79,17 @@ class Coordinate(object):
 def face_number_and_angle_detection(input_image):
     """
     本函数的功能是利用机器学习算法计算图像中人脸的数目与关键点，并通过关键点信息来计算人脸在平面上的旋转角度。
-    当前人脸数目!=1时，将raise一个错误信息并终止全部程序。
+    当前人脸数目!=1 时，将 raise 一个错误信息并终止全部程序。
     Args:
-        input_image: numpy.array(3 channels)，用户上传的原图（经过了一些简单的resize）
+        input_image: numpy.array(3 channels)，用户上传的原图（经过了一些简单的 resize）
 
     Returns:
-        - dets: list，人脸定位信息(x1, y1, x2, y2)
+        - dets: list，人脸定位信息 (x1, y1, x2, y2)
         - rotation: int，旋转角度，正数代表逆时针偏离，负数代表顺时针偏离
         - landmark: list，人脸关键点信息
     """
 
-    # face++人脸检测
+    # face++ 人脸检测
     # input_image_bytes = CV2Bytes.cv2_byte(input_image, ".jpg")
     # face_num, face_rectangle, landmarks, headpose = megvii_face_detector(input_image_bytes)
     # print(face_rectangle)
@@ -85,19 +97,25 @@ def face_number_and_angle_detection(input_image):
     faces, landmarks = face_detect_mtcnn(input_image)
     face_num = len(faces)
 
-    # 排除不合人脸数目要求（必须是1）的照片
+    # 排除不合人脸数目要求（必须是 1）的照片
     if face_num == 0 or face_num >= 2:
         if face_num == 0:
             status_id_ = "1101"
         else:
             status_id_ = "1102"
-        raise IDError(f"人脸检测出错！检测出了{face_num}张人脸", face_num=face_num, status_id=status_id_)
+        raise IDError(
+            f"人脸检测出错！检测出了{face_num}张人脸",
+            face_num=face_num,
+            status_id=status_id_,
+        )
 
     # 获得人脸定位坐标
     face_rectangle = []
     for iter, (x1, y1, x2, y2, _) in enumerate(faces):
         x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
-        face_rectangle.append({'top': x1, 'left': y1, 'width': x2 - x1, 'height': y2 - y1})
+        face_rectangle.append(
+            {"top": x1, "left": y1, "width": x2 - x1, "height": y2 - y1}
+        )
 
     # 获取人脸定位坐标与关键点信息
     dets = face_rectangle[0]
@@ -108,6 +126,7 @@ def face_number_and_angle_detection(input_image):
     # return dets, rotation, landmark
     return dets
 
+
 @calTime
 def image_matting(input_image, params):
     """
@@ -116,11 +135,13 @@ def image_matting(input_image, params):
         - input_image: numpy.array(3 channels)，用户原图
 
     Returns:
-        - origin_png_image: numpy.array(4 channels)， 抠好的图
+        - origin_png_image: numpy.array(4 channels)，抠好的图
     """
 
     print("抠图采用本地模型")
-    origin_png_image = get_modnet_matting(input_image, sess=params["modnet"]["human_sess"])
+    origin_png_image = get_modnet_matting(
+        input_image, sess=params["modnet"]["human_sess"]
+    )
 
     origin_png_image = hollowOutFix(origin_png_image)  # 抠图洞洞修补
     return origin_png_image
@@ -131,31 +152,35 @@ def rotation_ajust(input_image, rotation, a, IS_DEBUG=False):
     """
     本函数的功能是根据旋转角对原图进行无损旋转，并返回结果图与附带信息。
     Args:
-        - input_image: numpy.array(3 channels), 用户上传的原图（经过了一些简单的resize、美颜）
+        - input_image: numpy.array(3 channels), 用户上传的原图（经过了一些简单的 resize、美颜）
         - rotation: float, 人的五官偏离"端正"形态的旋转角
-        - a: numpy.array(1 channel), matting图的matte
-        - IS_DEBUG: DEBUG模式开关
+        - a: numpy.array(1 channel), matting 图的 matte
+        - IS_DEBUG: DEBUG 模式开关
 
     Returns:
         - result_jpg_image: numpy.array(3 channels), 原图旋转的结果图
-        - result_png_image: numpy.array(4 channels), matting图旋转的结果图
+        - result_png_image: numpy.array(4 channels), matting 图旋转的结果图
         - L1: CLassObject, 根据��转点连线所构造函数
         - L2: ClassObject, 根据旋转点连线所构造函数
         - dotL3: ClassObject, 一个特殊裁切点的坐标
         - clockwise: int, 表示照片是顺时针偏离还是逆时针偏离
-        - drawed_dots_image: numpy.array(3 channels), 在result_jpg_image上标定了4个旋转点的结果图，用于DEBUG模式
+        - drawed_dots_image: numpy.array(3 channels), 在 result_jpg_image 上标定了 4 个旋转点的结果图，用于 DEBUG 模式
     """
 
     # Step1. 数据准备
-    rotation = -1 * rotation  # rotation为正数->原图顺时针偏离，为负数->逆时针偏离
+    rotation = -1 * rotation  # rotation 为正数->原图顺时针偏离，为负数->逆时针偏离
     h, w = input_image.copy().shape[:2]
 
     # Step2. 无损旋转
-    result_jpg_image, result_png_image, cos, sin = rotate_bound_4channels(input_image, a, rotation)
+    result_jpg_image, result_png_image, cos, sin = rotate_bound_4channels(
+        input_image, a, rotation
+    )
 
     # Step3. 附带信息计算
     nh, nw = result_jpg_image.shape[:2]  # 旋转后的新的长宽
-    clockwise = -1 if rotation < 0 else 1  # clockwise代表时针，即1为顺时针，-1为逆时针
+    clockwise = (
+        -1 if rotation < 0 else 1
+    )  # clockwise 代表时针，即 1 为顺时针，-1 为逆时针
     # 如果逆时针偏离：
     if rotation < 0:
         p1 = Coordinate(0, int(w * sin))
@@ -164,7 +189,9 @@ def rotation_ajust(input_image, rotation, a, IS_DEBUG=False):
         p4 = Coordinate(int(h * sin), nh)
         L1 = LinearFunction_TwoDots(p1, p4)
         L2 = LinearFunction_TwoDots(p4, p3)
-        dotL3 = Coordinate(int(0.25 * p2.x + 0.75 * p3.x), int(0.25 * p2.y + 0.75 * p3.y))
+        dotL3 = Coordinate(
+            int(0.25 * p2.x + 0.75 * p3.x), int(0.25 * p2.y + 0.75 * p3.y)
+        )
 
     # 如果顺时针偏离：
     else:
@@ -174,41 +201,55 @@ def rotation_ajust(input_image, rotation, a, IS_DEBUG=False):
         p4 = Coordinate(0, int(h * cos))
         L1 = LinearFunction_TwoDots(p4, p3)
         L2 = LinearFunction_TwoDots(p3, p2)
-        dotL3 = Coordinate(int(0.75 * p4.x + 0.25 * p1.x), int(0.75 * p4.y + 0.25 * p1.y))
-
-    # Step4. 根据附带信息进行图像绘制（4个旋转点），便于DEBUG模式验证
-    drawed_dots_image = draw_picture_dots(result_jpg_image, [(p1.x, p1.y), (p2.x, p2.y), (p3.x, p3.y),
-                                                             (p4.x, p4.y), (dotL3.x, dotL3.y)])
+        dotL3 = Coordinate(
+            int(0.75 * p4.x + 0.25 * p1.x), int(0.75 * p4.y + 0.25 * p1.y)
+        )
+
+    # Step4. 根据附带信息进行图像绘制（4 个旋转点），便于 DEBUG 模式验证
+    drawed_dots_image = draw_picture_dots(
+        result_jpg_image,
+        [(p1.x, p1.y), (p2.x, p2.y), (p3.x, p3.y), (p4.x, p4.y), (dotL3.x, dotL3.y)],
+    )
     if IS_DEBUG:
         testImages.append(["drawed_dots_image", drawed_dots_image])
 
-    return result_jpg_image, result_png_image, L1, L2, dotL3, clockwise, drawed_dots_image
+    return (
+        result_jpg_image,
+        result_png_image,
+        L1,
+        L2,
+        dotL3,
+        clockwise,
+        drawed_dots_image,
+    )
 
 
 @calTime
 def face_number_detection_mtcnn(input_image):
     """
-    本函数的功能是对旋转矫正的结果图进行基于MTCNN模型的人脸检测。
+    本函数的功能是对旋转矫正的结果图进行基于 MTCNN 模型的人脸检测。
     Args:
-        - input_image: numpy.array(3 channels), 旋转矫正(rotation_adjust)的3通道结果图
+        - input_image: numpy.array(3 channels), 旋转矫正 (rotation_adjust) 的 3 通道结果图
 
     Returns:
         - faces: list, 人脸检测的结果，包含人脸位置信息
     """
-    # 如果图像的长或宽>1500px，则对图像进行1/2的resize再做MTCNN人脸检测，以加快处理速度
+    # 如果图像的长或宽>1500px，则对图像进行 1/2 的 resize 再做 MTCNN 人脸检测，以加快处理速度
     if max(input_image.shape[0], input_image.shape[1]) >= 1500:
-        input_image_resize = cv2.resize(input_image,
-                                        (input_image.shape[1] // 2, input_image.shape[0] // 2),
-                                        interpolation=cv2.INTER_AREA)
-        faces, _ = face_detect_mtcnn(input_image_resize, filter=True)  # MTCNN人脸检测
-        # 如果缩放后图像的MTCNN人脸数目检测结果等于1->两次人脸检测结果没有偏差，则对定位数据x2
+        input_image_resize = cv2.resize(
+            input_image,
+            (input_image.shape[1] // 2, input_image.shape[0] // 2),
+            interpolation=cv2.INTER_AREA,
+        )
+        faces, _ = face_detect_mtcnn(input_image_resize, filter=True)  # MTCNN 人脸检测
+        # 如果缩放后图像的 MTCNN 人脸数目检测结果等于 1->两次人脸检测结果没有偏差，则对定位数据 x2
         if len(faces) == 1:
             for item, param in enumerate(faces[0]):
                 faces[0][item] = param * 2
-        # 如果两次人脸检测结果有偏差，则默认缩放后图像的MTCNN检测存在误差，则将原图输入再做一次MTCNN（保险措施）
+        # 如果两次人脸检测结果有偏差，则默认缩放后图像的 MTCNN 检测存在误差，则将原图输入再做一次 MTCNN（保险措施）
         else:
             faces, _ = face_detect_mtcnn(input_image, filter=True)
-    # 如果图像的长或宽<1500px，则直接进行MTCNN检测
+    # 如果图像的长或宽<1500px，则直接进行 MTCNN 检测
     else:
         faces, _ = face_detect_mtcnn(input_image, filter=True)
 
@@ -216,7 +257,9 @@ def face_number_detection_mtcnn(input_image):
 
 
 @calTime
-def cutting_rect_pan(x1, y1, x2, y2, width, height, L1, L2, L3, clockwise, standard_size):
+def cutting_rect_pan(
+    x1, y1, x2, y2, width, height, L1, L2, L3, clockwise, standard_size
+):
     """
     本函数的功能是对旋转矫正结果图的裁剪框进行修正 ———— 解决"旋转三角形"现象。
     Args:
@@ -240,13 +283,13 @@ def cutting_rect_pan(x1, y1, x2, y2, width, height, L1, L2, L3, clockwise, stand
         - x_bias: int, 裁剪框横坐标方向上的计算偏置量
         - y_bias: int, 裁剪框纵坐标方向上的计算偏置量
     """
-    # 用于计算的裁剪框坐标x1_cal,x2_cal,y1_cal,y2_cal(如果裁剪框超出了图像范围，则缩小直至在范围内)
+    # 用于计算的裁剪框坐标 x1_cal,x2_cal,y1_cal,y2_cal(如果裁剪框超出了图像范围，则缩小直至在范围内)
     x1_std = x1 if x1 > 0 else 0
     x2_std = x2 if x2 < width else width
     # y1_std = y1 if y1 > 0 else 0
     y2_std = y2 if y2 < height else height
 
-    # 初始化x和y的计算偏置项x_bias和y_bias
+    # 初始化 x 和 y 的计算偏置项 x_bias 和 y_bias
     x_bias = 0
     y_bias = 0
 
@@ -269,7 +312,7 @@ def cutting_rect_pan(x1, y1, x2, y2, width, height, L1, L2, L3, clockwise, stand
         if x2 > L3.x:
             x2 = L3.x
 
-    # 计算裁剪框的y的变化
+    # 计算裁剪框的 y 的变化
     y2 = int(y2_std + y_bias)
     new_cut_width = x2 - x1
     new_cut_height = int(new_cut_width / standard_size[1] * standard_size[0])
@@ -279,25 +322,36 @@ def cutting_rect_pan(x1, y1, x2, y2, width, height, L1, L2, L3, clockwise, stand
 
 
 @calTime
-def idphoto_cutting(faces, head_measure_ratio, standard_size, head_height_ratio, origin_png_image, origin_png_image_pre,
-                    rotation_params, align=False, IS_DEBUG=False, top_distance_max=0.12, top_distance_min=0.10):
+def idphoto_cutting(
+    faces,
+    head_measure_ratio,
+    standard_size,
+    head_height_ratio,
+    origin_png_image,
+    origin_png_image_pre,
+    rotation_params,
+    align=False,
+    IS_DEBUG=False,
+    top_distance_max=0.12,
+    top_distance_min=0.10,
+):
     """
-    本函数的功能为进行证件照的自适应裁剪，自适应依据Setting.json的控制参数，以及输入图像的自身情况。
+    本函数的功能为进行证件照的自适应裁剪，自适应依据 Setting.json 的控制参数，以及输入图像的自身情况。
     Args:
         - faces: list, 人脸位置信息
         - head_measure_ratio: float, 人脸面积与全图面积的期望比值
-        - standard_size: tuple, 标准照尺寸, 如(413, 295)
+        - standard_size: tuple, 标准照尺寸，如 (413, 295)
         - head_height_ratio: float, 人脸中心处在全图高度的比例期望值
         - origin_png_image: numpy.array(4 channels), 经过一系列转换后的用户输入图
         - origin_png_image_pre：numpy.array(4 channels)，经过一系列转换（但没有做旋转矫正）的用户输入图
         - rotation_params：旋转参数字典
-            - L1: classObject, 来自rotation_ajust的L1线性函数
-            - L2: classObject, 来自rotation_ajust的L2线性函数
-            - L3: classObject, 来自rotation_ajust的dotL3点
-            - clockwise: int, (顺/逆)时针偏差
-            - drawed_image: numpy.array, 红点标定4个旋转点的图像
+            - L1: classObject, 来自 rotation_ajust 的 L1 线性函数
+            - L2: classObject, 来自 rotation_ajust 的 L2 线性函数
+            - L3: classObject, 来自 rotation_ajust 的 dotL3 点
+            - clockwise: int, (顺/逆) 时针偏差
+            - drawed_image: numpy.array, 红点标定 4 个旋转点的图像
         - align: bool, 是否图像做过旋转矫正
-        - IS_DEBUG: DEBUG模式开关
+        - IS_DEBUG: DEBUG 模式开关
         - top_distance_max: float, 头距离顶部的最大比例
         - top_distance_min: float, 头距离顶部的最小比例
 
@@ -324,11 +378,15 @@ def idphoto_cutting(faces, head_measure_ratio, standard_size, head_height_ratio,
     # Step2. 计算高级参数
     face_center = (x + w / 2, y + h / 2)  # 面部中心坐标
     face_measure = w * h  # 面部面积
-    crop_measure = face_measure / head_measure_ratio  # 裁剪框面积：为面部面积的5倍
+    crop_measure = face_measure / head_measure_ratio  # 裁剪框面积：为面部面积的 5 倍
     resize_ratio = crop_measure / (standard_size[0] * standard_size[1])  # 裁剪框缩放率
-    resize_ratio_single = math.sqrt(resize_ratio)  # 长和宽的缩放率（resize_ratio的开方）
-    crop_size = (int(standard_size[0] * resize_ratio_single),
-                 int(standard_size[1] * resize_ratio_single))  # 裁剪框大小
+    resize_ratio_single = math.sqrt(
+        resize_ratio
+    )  # 长和宽的缩放率（resize_ratio 的开方）
+    crop_size = (
+        int(standard_size[0] * resize_ratio_single),
+        int(standard_size[1] * resize_ratio_single),
+    )  # 裁剪框大小
 
     # 裁剪框的定位信息
     x1 = int(face_center[0] - crop_size[1] / 2)
@@ -339,7 +397,7 @@ def idphoto_cutting(faces, head_measure_ratio, standard_size, head_height_ratio,
     # Step3. 对于旋转矫正图片的裁切处理
     # if align:
     #     y_top_pre, _, _, _ = get_box_pro(origin_png_image.astype(np.uint8), model=2,
-    #                                      correction_factor=0)  # 获取matting结果图的顶距
+    #                                      correction_factor=0)  # 获取 matting 结果图的顶距
     #     # 裁剪参数重新计算，目标是以最小的图像损失来消除"旋转三角形"
     #     x1, y1, x2, y2, x_bias, y_bias = cutting_rect_pan(x1, y1, x2, y2, width, height, L1, L2, L3, clockwise,
     #                                                       standard_size)
@@ -374,38 +432,44 @@ def idphoto_cutting(faces, head_measure_ratio, standard_size, head_height_ratio,
     # Step4. 对照片的第一轮裁剪
     cut_image = IDphotos_cut(x1, y1, x2, y2, origin_png_image)
     cut_image = cv2.resize(cut_image, (crop_size[1], crop_size[0]))
-    y_top, y_bottom, x_left, x_right = get_box_pro(cut_image.astype(np.uint8), model=2,
-                                                   correction_factor=0)  # 得到cut_image中人像的上下左右距离信息
+    y_top, y_bottom, x_left, x_right = get_box_pro(
+        cut_image.astype(np.uint8), model=2, correction_factor=0
+    )  # 得到 cut_image 中人像的上下左右距离信息
     if IS_DEBUG:
         testImages.append(["firstCut", cut_image])
 
-    # Step5. 判定cut_image中的人像是否处于合理的位置，若不合理，则处理数据以便之后调整位置
+    # Step5. 判定 cut_image 中的人像是否处于合理的位置，若不合理，则处理数据以便之后调整位置
     # 检测人像与裁剪框左边或右边是否存在空隙
     if x_left > 0 or x_right > 0:
         status_left_right = 1
-        cut_value_top = int(((x_left + x_right) * width_height_ratio) / 2)  # 减去左右,为了保持比例,上下也要相应减少cut_value_top
+        cut_value_top = int(
+            ((x_left + x_right) * width_height_ratio) / 2
+        )  # 减去左右，为了保持比例，上下也要相应减少 cut_value_top
     else:
         status_left_right = 0
         cut_value_top = 0
 
     """
         检测人头顶与照片的顶部是否在合适的距离内：
-        - status==0: 距离合适, 无需移动
-        - status=1: 距离过大, 人像应向上移动
-        - status=2: 距离过小, 人像应向下移动
+        - status==0: 距离合适，无需移动
+        - status=1: 距离过大，人像应向上移动
+        - status=2: 距离过小，人像应向下移动
     """
-    status_top, move_value = detect_distance(y_top - cut_value_top, crop_size[0], max=top_distance_max,
-                                             min=top_distance_min)
+    status_top, move_value = detect_distance(
+        y_top - cut_value_top, crop_size[0], max=top_distance_max, min=top_distance_min
+    )
 
     # Step6. 对照片的第二轮裁剪
     if status_left_right == 0 and status_top == 0:
         result_image = cut_image
     else:
-        result_image = IDphotos_cut(x1 + x_left,
-                                    y1 + cut_value_top + status_top * move_value,
-                                    x2 - x_right,
-                                    y2 - cut_value_top + status_top * move_value,
-                                    origin_png_image)
+        result_image = IDphotos_cut(
+            x1 + x_left,
+            y1 + cut_value_top + status_top * move_value,
+            x2 - x_right,
+            y2 - cut_value_top + status_top * move_value,
+            origin_png_image,
+        )
     if IS_DEBUG:
         testImages.append(["result_image_pre", result_image])
 
@@ -421,14 +485,16 @@ def idphoto_cutting(faces, head_measure_ratio, standard_size, head_height_ratio,
 
     # Step8. 标准照与高清照转换
     result_image_standard = standard_photo_resize(result_image, standard_size)
-    result_image_hd, resize_ratio_max = resize_image_by_min(result_image, esp=max(600, standard_size[1]))
+    result_image_hd, resize_ratio_max = resize_image_by_min(
+        result_image, esp=max(600, standard_size[1])
+    )
 
-    # Step9. 参数准备-为换装服务
+    # Step9. 参数准备 - 为换装服务
     clothing_params = {
         "relative_x": relative_x * resize_ratio_max,
         "relative_y": relative_y * resize_ratio_max,
         "w": w * resize_ratio_max,
-        "h": h * resize_ratio_max
+        "h": h * resize_ratio_max,
     }
 
     return result_image_hd, result_image_standard, clothing_params
@@ -445,30 +511,48 @@ def debug_mode_process(testImages):
         if item == 0:
             testHeight = height
             result_image_test = imageItem
-            result_image_test = cv2.putText(result_image_test, text, (50, 50), cv2.FONT_HERSHEY_COMPLEX, 1.0,
-                                            (200, 100, 100), 3)
+            result_image_test = cv2.putText(
+                result_image_test,
+                text,
+                (50, 50),
+                cv2.FONT_HERSHEY_COMPLEX,
+                1.0,
+                (200, 100, 100),
+                3,
+            )
         else:
-            imageItem = cv2.resize(imageItem, (int(width * testHeight / height), testHeight))
-            imageItem = cv2.putText(imageItem, text, (50, 50), cv2.FONT_HERSHEY_COMPLEX, 1.0, (200, 100, 100),
-                                    3)
+            imageItem = cv2.resize(
+                imageItem, (int(width * testHeight / height), testHeight)
+            )
+            imageItem = cv2.putText(
+                imageItem,
+                text,
+                (50, 50),
+                cv2.FONT_HERSHEY_COMPLEX,
+                1.0,
+                (200, 100, 100),
+                3,
+            )
             result_image_test = cv2.hconcat([result_image_test, imageItem])
         if item == len(testImages) - 1:
             return result_image_test
 
 
 @calTime("主函数")
-def IDphotos_create(input_image,
-                    mode="ID",
-                    size=(413, 295),
-                    head_measure_ratio=0.2,
-                    head_height_ratio=0.45,
-                    align=False,
-                    beauty=True,
-                    fd68=None,
-                    human_sess=None,
-                    IS_DEBUG=False,
-                    top_distance_max=0.12,
-                    top_distance_min=0.10):
+def IDphotos_create(
+    input_image,
+    mode="ID",
+    size=(413, 295),
+    head_measure_ratio=0.2,
+    head_height_ratio=0.45,
+    align=False,
+    beauty=True,
+    fd68=None,
+    human_sess=None,
+    IS_DEBUG=False,
+    top_distance_max=0.12,
+    top_distance_min=0.10,
+):
     """
     证件照制作主函数
     Args:
@@ -476,26 +560,34 @@ def IDphotos_create(input_image,
         size: (h, w)
         head_measure_ratio: 头部占比？
         head_height_ratio: 头部高度占比？
-        align: 是否进行人脸矫正（roll），默认为True（是）
-        fd68: 人脸68关键点检测类，详情参见hycv.FaceDetection68.faceDetection68
-        human_sess: 人像抠图模型类，由onnx载入（不与下面两个参数连用）
-        oss_image_name: 阿里云api需要的参数，实际上是上传到oss的路径
-        user: 阿里云api的accessKey配置对象
+        align: 是否进行人脸矫正（roll），默认为 True（是）
+        fd68: 人脸 68 关键点检测类，详情参见 hycv.FaceDetection68.faceDetection688
+        human_sess: 人像抠图模型类，由 onnx 载入（不与下面两个参数连用）连用）
+        oss_image_name: 阿里云 api 需要的参数，实际上是上传到 oss 的路径
+        user: 阿里云 api 的 accessKey 配置对象
         top_distance_max: float, 头距离顶部的最大比例
         top_distance_min: float, 头距离顶部的最小比例
     Returns:
-        result_image(高清版), result_image(普清版), api请求日志，
-    排版照参数(list)，排版照是否旋转参数，照片尺寸（x， y）
+        result_image(高清版), result_image(普清版), api 请求日志，
+        排版照参数 (list)，排版照是否旋转参数，照片尺寸（x，y）
         在函数不出错的情况下，函数会因为一些原因主动抛出异常：
-        1. 无人脸（或者只有半张，dlib无法检测出来），抛出IDError异常，内部参数face_num为0
-        2. 人脸数量超过1，抛出IDError异常，内部参数face_num为2
-        3. 抠图api请求失败，抛出IDError异常，内部参数face_num为-1
+        1. 无人脸（或者只有半张，dlib 无法检测出来），抛出 IDError 异常，内部参数 face_num 为 0
+        2. 人脸数量超过 1，抛出 IDError 异常，内部参数 face_num 为 2
+        3. 抠图 api 请求失败，抛出 IDError 异常，内部参数 face_num 为 -1num 为 -1
     """
 
     # Step0. 数据准备/图像预处理
     matting_params = {"modnet": {"human_sess": human_sess}}
-    rotation_params = {"L1": None, "L2": None, "L3": None, "clockwise": None, "drawed_image": None}
-    input_image = resize_image_esp(input_image, 2000)  # 将输入图片resize到最大边长为2000
+    rotation_params = {
+        "L1": None,
+        "L2": None,
+        "L3": None,
+        "clockwise": None,
+        "drawed_image": None,
+    }
+    input_image = resize_image_esp(
+        input_image, 2000
+    )  # 将输入图片 resize 到最大边长为 2000
 
     # Step1. 人脸检测
     # dets, rotation, landmark = face_number_and_angle_detection(input_image)
@@ -507,13 +599,15 @@ def IDphotos_create(input_image,
 
     # Step3. 抠图
     origin_png_image = image_matting(input_image, matting_params)
-    if mode == "只换底":
+    if mode == "只换底" or mode == "Only Change Background":
         return origin_png_image, origin_png_image, None, None, None, None, None, None, 1
 
-    origin_png_image_pre = origin_png_image.copy()  # 备份一下现在抠图结果图，之后在iphoto_cutting函数有用
+    origin_png_image_pre = (
+        origin_png_image.copy()
+    )  # 备份一下现在抠图结果图，之后在 iphoto_cutting 函数有用
 
     # Step4. 旋转矫正
-    # 如果旋转角不大于2, 则不做旋转
+    # 如果旋转角不大于 2, 则不做旋转
     # if abs(rotation) <= 2:
     #     align = False
     # # 否则，进行旋转矫正
@@ -531,26 +625,46 @@ def IDphotos_create(input_image,
     #     rotation_params["clockwise"] = clockwise
     #     rotation_params["drawed_image"] = drawed_image
 
-    # Step5. MTCNN人脸检测
+    # Step5. MTCNN 人脸检测
     faces = face_number_detection_mtcnn(input_image)
 
     # Step6. 证件照自适应裁剪
     face_num = len(faces)
-    # 报错MTCNN检测结果不等于1的图片
+    # 报错 MTCNN 检测结果不等于 1 的图片
     if face_num != 1:
         return None, None, None, None, None, None, None, None, 0
     # 符合条件的进入下一环
     else:
-        result_image_hd, result_image_standard, clothing_params = \
-            idphoto_cutting(faces, head_measure_ratio, size, head_height_ratio, origin_png_image,
-                            origin_png_image_pre, rotation_params, align=align, IS_DEBUG=IS_DEBUG,
-                            top_distance_max=top_distance_max, top_distance_min=top_distance_min)
+        result_image_hd, result_image_standard, clothing_params = idphoto_cutting(
+            faces,
+            head_measure_ratio,
+            size,
+            head_height_ratio,
+            origin_png_image,
+            origin_png_image_pre,
+            rotation_params,
+            align=align,
+            IS_DEBUG=IS_DEBUG,
+            top_distance_max=top_distance_max,
+            top_distance_min=top_distance_min,
+        )
 
     # Step7. 排版照参数获取
-    typography_arr, typography_rotate = generate_layout_photo(input_height=size[0], input_width=size[1])
-
-    return result_image_hd, result_image_standard, typography_arr, typography_rotate, \
-           clothing_params["relative_x"], clothing_params["relative_y"], clothing_params["w"], clothing_params["h"], 1
+    typography_arr, typography_rotate = generate_layout_photo(
+        input_height=size[0], input_width=size[1]
+    )
+
+    return (
+        result_image_hd,
+        result_image_standard,
+        typography_arr,
+        typography_rotate,
+        clothing_params["relative_x"],
+        clothing_params["relative_y"],
+        clothing_params["w"],
+        clothing_params["h"],
+        1,
+    )
 
 
 if __name__ == "__main__":
@@ -559,18 +673,29 @@ if __name__ == "__main__":
 
     input_image = cv2.imread("test.jpg")
 
-    result_image_hd, result_image_standard, typography_arr, typography_rotate, \
-    _, _, _, _, _ = IDphotos_create(input_image,
-                                               size=(413, 295),
-                                               head_measure_ratio=0.2,
-                                               head_height_ratio=0.45,
-                                               align=True,
-                                               beauty=True,
-                                               fd68=None,
-                                               human_sess=sess,
-                                               oss_image_name="test_tmping.jpg",
-                                               user=None,
-                                               IS_DEBUG=False,
-                                               top_distance_max=0.12,
-                                               top_distance_min=0.10)
+    (
+        result_image_hd,
+        result_image_standard,
+        typography_arr,
+        typography_rotate,
+        _,
+        _,
+        _,
+        _,
+        _,
+    ) = IDphotos_create(
+        input_image,
+        size=(413, 295),
+        head_measure_ratio=0.2,
+        head_height_ratio=0.45,
+        align=True,
+        beauty=True,
+        fd68=None,
+        human_sess=sess,
+        oss_image_name="test_tmping.jpg",
+        user=None,
+        IS_DEBUG=False,
+        top_distance_max=0.12,
+        top_distance_min=0.10,
+    )
     cv2.imwrite("result_image_hd.png", result_image_hd)