Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,6 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+hivision_modnet.onnx filter=lfs diff=lfs merge=lfs -text
+hivision_modnet.onnx.1 filter=lfs diff=lfs merge=lfs -text
+hivisionai/hycv/mtcnn_onnx/weights/onet.onnx filter=lfs diff=lfs merge=lfs -text
+hivisionai/hycv/mtcnn_onnx/weights/pnet.onnx filter=lfs diff=lfs merge=lfs -text
+hivisionai/hycv/mtcnn_onnx/weights/rnet.onnx filter=lfs diff=lfs merge=lfs -text
+sources/demoImage.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+*.pyc

EulerZ.py

@@ -0,0 +1,51 @@
+"""
+@author: cuny
+@file: EulerX.py
+@time: 2022/4/1 13:54
+@description: 
+寻找三维z轴旋转角roll,实现：
+1. 输入一张三通道图片（四通道、单通道将默认转为三通道）
+2. 输出人脸在x轴的转角roll，顺时针为正方向，角度制
+"""
+import cv2
+import numpy as np
+from math import asin, pi  # -pi/2 ~ pi/2
+
+
+# 获得人脸的关键点信息
+def get_facePoints(src: np.ndarray, fd68):
+    if len(src.shape) == 2:
+        src = cv2.cvtColor(src, cv2.COLOR_GRAY2BGR)
+    elif src.shape[2] == 4:
+        src = cv2.cvtColor(src, cv2.COLOR_BGRA2BGR)
+    status, dets, landmarks, _ = fd68.facePointsEuler(src)
+
+    if status == 0:
+        return 0, None, None
+    elif status == 2:
+        return 2, None, None
+    else:
+        return 1, dets, np.fliplr(landmarks)
+
+
+def eulerZ(landmark: np.matrix):
+    # 我们规定顺时针为正方向
+    def get_pi_2(r):
+        pi_2 = pi / 2.
+        if r >= 0.0:
+            return pi_2
+        else:
+            return -pi_2
+    orbit_points = np.array([[landmark[21, 0], landmark[21, 1]], [landmark[71, 0], landmark[71, 1]],
+                                   [landmark[25, 0], landmark[25, 1]], [landmark[67, 0], landmark[67, 1]]])
+    # [[cos  a],[sin a],[point_x],[point_y]]
+    # 前面两项是有关直线与Y正半轴夹角a的三角函数，所以对于眼睛部分来讲sin a应该接近1
+    # "我可以认为"cv2.fitLine的y轴正方向为竖直向下，且生成的拟合直线的方向为从起点指向终点
+    # 与y轴的夹角为y轴夹角与直线方向的夹角，方向从y指向直线，逆时针为正方向
+    # 所以最后对于鼻梁的计算结果需要取个负号
+    orbit_line = cv2.fitLine(orbit_points, cv2.DIST_L2, 0, 0.01, 0.01)
+    orbit_a = asin(orbit_line[1][0])
+    nose_points = np.array([[landmark[55, 0], landmark[55, 1]], [landmark[69, 0], landmark[69, 1]]])
+    nose_line = cv2.fitLine(nose_points, cv2.DIST_L2, 0, 0.01, 0.01)
+    nose_a = asin(nose_line[1][0])
+    return (orbit_a + nose_a) * (180.0 / (2 * pi))

README.md

@@ -1,12 +1,133 @@
 ---
 title: HivisionIDPhotos
-emoji: ⚡
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.42.0
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 3.40.1
+---
+<div align="center">
+<h1><img src="https://linimages.oss-cn-beijing.aliyuncs.com/hivision_photo_logo.png" width=80>HivisionIDPhoto</h1>
+
+
+English / [中文](README_CN.md)
+
+[![GitHub](https://img.shields.io/static/v1?label=Github&message=GitHub&color=black)](https://github.com/xiaolin199912/HivisionIDPhotos)
+[![SwanHub Demo](https://swanhub.co/git/repo/SwanHub%2FAuto-README/file/preview?ref=main&path=swanhub.svg)](https://swanhub.co/ZeYiLin/HivisionIDPhotos/demo)
+[![zhihu](https://img.shields.io/static/v1?label=知乎&message=zhihu&color=blue)](https://zhuanlan.zhihu.com/p/638254028)
+
+<img src="./sources/demoImage.png" width=900>
+
+</div>
+
+
+# 🤩Project Update
+
+- Online Demo: [![SwanHub Demo](https://swanhub.co/git/repo/SwanHub%2FAuto-README/file/preview?ref=main&path=swanhub.svg)](https://swanhub.co/ZeYiLin/HivisionIDPhotos/demo)
+- 2023.7.15: A Python library is planned for release！
+- 2023.6.20: Updated **Forecast Size Selection**
+- 2023.6.19: Updated **Layout photo**
+- 2023.6.13: Updated **center gradient color**
+- 2023.6.11: Updated **top and bottom gradient color**
+- 2023.6.8: Updated **custom size**
+- 2023.6.4: Updated **custom background color and face detection bug notification**
+- 2023.5.10: Updated **change background without changing size**
+  <br>
+
+
+# Overview
+
+> 🚀Thank you for your interest in our work. You may also want to check out our other achievements in the field of image processing. Please feel free to contact us at zeyi.lin@swanhub.co.
+
+HivisionIDPhoto aims to develop a practical intelligent algorithm for producing ID photos. It uses a complete set of model workflows to recognize various user photo scenarios, perform image segmentation, and generate ID photos. 
+
+**HivisionIDPhoto can:**
+
+1. Perform lightweight image segmentation
+2. Generate standard ID photos and six-inch layout photos according to different size specifications
+3. Provide beauty features (waiting)
+4. Provide intelligent formal wear replacement (waiting)
+
+<div align="center">
+<img src="sources/gradio-image.jpeg" width=900>
+</div>
+
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+If HivisionIDPhoto is helpful to you, please star this repo or recommend it to your friends to solve the problem of emergency ID photo production!
+
+
+# 🔧Environment Dependencies and Installation
+
+- Python >= 3.7 (Recommend to use [Anaconda](https://www.anaconda.com/download/#linux) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html))
+- onnxruntime
+- OpenCV
+- Option: Linux, Windows, MacOS
+
+### Installation
+
+1. Clone repo
+
+```bash
+git lfs install && git clone https://swanhub.co/ZeYiLin/HivisionIDPhotos.git
+cd  HivisionIDPhotos
+```
+
+2. Install dependent packages
+
+```
+pip install numpy
+pip install opencv-python
+pip install onnxruntime
+pip install gradio
+```
+
+
+
+# ⚡️Quick Inference
+
+### 1. Download Pre-trained Models
+
+**SwanHub：**
+
+The model and code are downloaded through git-lfs.
+
+```
+git lfs install
+git clone https://swanhub.co/ZeYiLin/HivisionIDPhotos.git
+```
+
+**GitHub：**
+
+```
+git clone https://github.com/xiaolin199912/HivisionIDPhotos.git
+```
+
+|        Model         | Parameters |    Dir    |                        Download Link                         |
+| :------------------: | :--------: | :-------: | :----------------------------------------------------------: |
+| hivision_modnet.onnx |    25 M    | `./` | [Download](https://github.com/xiaolin199912/HivisionIDPhotos/releases/download/pretrained-model/hivision_modnet.onnx) |
+
+### **2. Inference!**
+
+Run a Gradio Demo：
+
+```
+python app.py
+```
+
+Running the program will generate a local web page where you can complete ID photo operations and interactions.
+
+
+# Reference Projects
+
+1. MTCNN: https://github.com/ipazc/mtcnn
+2. MTCNN-ONNX：https://swanhub.co/ZeYiLin/MTCNN-ONNX
+3. ModNet: https://github.com/ZHKKKe/MODNet
+
+
+# 📧Contact 
+
+If you have any questions, please email Zeyi.lin@swanhub.co
+
+
+Copyright © 2023, ZeYiLin. All Rights Reserved.
+

README_CN.md

@@ -0,0 +1,102 @@
+<div align="center">
+<h1><img src="https://linimages.oss-cn-beijing.aliyuncs.com/hivision_photo_logo.png" width=80>HivisionIDPhoto</h1>
+
+[English](README.md) / 中文
+
+[![GitHub](https://img.shields.io/static/v1?label=GitHub&message=GitHub&color=black)](https://github.com/xiaolin199912/HivisionIDPhotos)
+[![SwanHub Demo](https://img.shields.io/static/v1?label=在线体验&message=SwanHub%20Demo&color=blue)](https://swanhub.co/ZeYiLin/HivisionIDPhotos/demo)
+[![zhihu](https://img.shields.io/static/v1?label=知乎&message=知乎&color=blue)](https://zhuanlan.zhihu.com/p/638254028)
+
+<img src="sources/demoImage.png" width=900>
+</div>
+
+
+# 🤩项目更新
+- 在线体验: [![SwanHub Demo](https://img.shields.io/static/v1?label=Demo&message=SwanHub%20Demo&color=blue)](https://swanhub.co/ZeYiLin/HivisionIDPhotos/demo)
+- 2023.6.20: 更新**预设尺寸菜单**
+- 2023.6.19: 更新**排版照**
+- 2023.6.13: 更新**中心渐变色**
+- 2023.6.11: 更新**上下渐变色**
+- 2023.6.8: 更新**自定义尺寸**
+- 2023.6.4: 更新**自定义底色、人脸检测Bug通知**
+- 2023.5.10: 更新**不改尺寸只换底**
+
+# Overview
+
+> 🚀谢谢你对我们的工作感兴趣。您可能还想查看我们在图像领域的其他成果，欢迎来信:zeyi.lin@swanhub.co.
+
+HivisionIDPhoto旨在开发一种实用的证件照智能制作算法。
+
+它利用一套完善的模型工作流程，实现对多种用户拍照场景的识别、抠图与证件照生成。
+
+
+**HivisionIDPhoto可以做到:**
+
+1. 轻量级抠图
+2. 根据不同尺寸规格生成不同的标准证件照、六寸排版照
+3. 美颜（waiting）
+4. 智能换正装（waiting）
+
+<div align="center">
+<img src="sources/gradio-image.jpeg" width=900>
+</div>
+
+
+---
+
+如果HivisionIDPhoto对你有帮助，请star这个repo或推荐给你的朋友，解决证件照应急制作问题！
+
+
+# 🔧环境安装与依赖
+
+- Python >= 3.7 (Recommend to use [Anaconda](https://www.anaconda.com/download/#linux) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html))
+- onnxruntime
+- OpenCV
+- Option: Linux, Windows, MacOS
+
+### Installation
+
+1. Clone repo
+
+```bash
+git lfs install && git clone https://swanhub.co/ZeYiLin/HivisionIDPhotos.git
+cd  HivisionIDPhotos
+```
+
+2. Install dependent packages
+
+```
+pip install numpy
+pip install opencv-python
+pip install onnxruntime
+pip install gradio
+```
+
+
+
+# ⚡️快速推理
+
+模型与代码通过git-lfs下载。
+
+```
+git lfs install
+git clone https://swanhub.co/ZeYiLin/HivisionIDPhotos.git
+```
+
+**推理！**
+
+```
+python app.py
+```
+
+运行程序将生成一个本地Web页面，在页面中可完成证件照的操作与交互。
+
+
+# 引用项目
+
+1. MTCNN: https://github.com/ipazc/mtcnn
+2. ModNet: https://github.com/ZHKKKe/MODNet
+
+# 📧联系我们
+
+如果您有任何问题，请发邮件至 zeyi.lin@swanhub.co

app.py

@@ -0,0 +1,216 @@
+import cv2
+import gradio as gr
+import onnxruntime
+from face_judgement_align import IDphotos_create
+from hivisionai.hycv.vision import add_background
+from layoutCreate import generate_layout_photo, generate_layout_image
+import pathlib
+import numpy as np
+
+size_list_dict = {"一寸": (413, 295), "二寸": (626, 413),
+                  "教师资格证": (413, 295), "国家公务员考试": (413, 295), "初级会计考试": (413, 295)}
+color_list_dict = {"蓝色": (86, 140, 212), "白色": (255, 255, 255), "红色": (233, 51, 35)}
+
+
+# 设置Gradio examples
+def set_example_image(example: list) -> dict:
+    return gr.Image.update(value=example[0])
+
+
+# 检测RGB是否超出范围，如果超出则约束到0～255之间
+def range_check(value, min_value=0, max_value=255):
+    value = int(value)
+    if value <= min_value:
+        value = min_value
+    elif value > max_value:
+        value = max_value
+    return value
+
+
+def idphoto_inference(input_image,
+                      mode_option,
+                      size_list_option,
+                      color_option,
+                      render_option,
+                      custom_color_R,
+                      custom_color_G,
+                      custom_color_B,
+                      custom_size_height,
+                      custom_size_width,
+                      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,
+        "render_mode": render_option,
+    }
+
+    # 如果尺寸模式选择的是尺寸列表
+    if idphoto_json["size_mode"] == "尺寸列表":
+        idphoto_json["size"] = size_list_dict[size_list_option]
+    # 如果尺寸模式选择的是自定义尺寸
+    elif idphoto_json["size_mode"] == "自定义尺寸":
+        id_height = int(custom_size_height)
+        id_width = int(custom_size_width)
+        if id_height < id_width or min(id_height, id_width) < 100 or max(id_height, id_width) > 1800:
+            return {
+                img_output_standard: gr.update(value=None),
+                img_output_standard_hd: gr.update(value=None),
+                notification: gr.update(value="宽度应不大于长度；长宽不应小于100，大于1800", visible=True)}
+        idphoto_json["size"] = (id_height, id_width)
+    else:
+        idphoto_json["size"] = (None, None)
+
+    # 如果颜色模式选择的是自定义底色
+    if idphoto_json["color_mode"] == "自定义底色":
+        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]
+
+    result_image_hd, result_image_standard, typography_arr, typography_rotate, \
+    _, _, _, _, status = IDphotos_create(input_image,
+                                         mode=idphoto_json["size_mode"],
+                                         size=idphoto_json["size"],
+                                         head_measure_ratio=head_measure_ratio,
+                                         head_height_ratio=head_height_ratio,
+                                         align=False,
+                                         beauty=False,
+                                         fd68=None,
+                                         human_sess=sess,
+                                         IS_DEBUG=False,
+                                         top_distance_max=top_distance_max,
+                                         top_distance_min=top_distance_min)
+
+    # 如果检测到人脸数量不等于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)
+        }
+
+    # 如果检测到人脸数量等于1
+    else:
+        if idphoto_json["render_mode"] == "纯色":
+            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"] == "上下渐变(白)":
+            result_image_standard = np.uint8(
+                add_background(result_image_standard, bgr=idphoto_json["color_bgr"], mode="updown_gradient"))
+            result_image_hd = np.uint8(
+                add_background(result_image_hd, bgr=idphoto_json["color_bgr"], mode="updown_gradient"))
+        else:
+            result_image_standard = np.uint8(
+                add_background(result_image_standard, bgr=idphoto_json["color_bgr"], mode="center_gradient"))
+            result_image_hd = np.uint8(
+                add_background(result_image_hd, bgr=idphoto_json["color_bgr"], mode="center_gradient"))
+
+        if idphoto_json["size_mode"] == "只换底":
+            result_layout_image = gr.update(visible=False)
+        else:
+            typography_arr, typography_rotate = generate_layout_photo(input_height=idphoto_json["size"][0],
+                                                                      input_width=idphoto_json["size"][1])
+
+            result_layout_image = generate_layout_image(result_image_standard, typography_arr,
+                                                        typography_rotate,
+                                                        height=idphoto_json["size"][0],
+                                                        width=idphoto_json["size"][1])
+
+        result_messgae = {
+            img_output_standard: result_image_standard,
+            img_output_standard_hd: result_image_hd,
+            img_output_layout: result_layout_image,
+            notification: gr.update(visible=False)}
+
+    return result_messgae
+
+
+if __name__ == "__main__":
+    HY_HUMAN_MATTING_WEIGHTS_PATH = "./hivision_modnet.onnx"
+    sess = onnxruntime.InferenceSession(HY_HUMAN_MATTING_WEIGHTS_PATH)
+    size_mode = ["尺寸列表", "只换底", "自定义尺寸"]
+    size_list = ["一寸", "二寸", "教师资格证", "国家公务员考试", "初级会计考试"]
+    colors = ["蓝色", "白色", "红色", "自定义底色"]
+    render = ["纯色", "上下渐变(白)", "中心渐变(白)"]
+
+    title = "<h1 id='title'>HivisionIDPhotos</h1>"
+    description = "<h3>😎6.20更新：新增尺寸选择列表</h3>"
+    css = '''
+    h1#title, h3 {
+      text-align: center;
+    }
+    '''
+
+    demo = gr.Blocks(css=css)
+
+    with demo:
+        gr.Markdown(title)
+        gr.Markdown(description)
+        with gr.Row():
+            with gr.Column():
+                img_input = gr.Image().style(height=350)
+                mode_options = gr.Radio(choices=size_mode, label="证件照尺寸选项", value="尺寸列表", elem_id="size")
+                # 预设尺寸下拉菜单
+                with gr.Row(visible=True) as size_list_row:
+                    size_list_options = gr.Dropdown(choices=size_list, label="预设尺寸", value="一寸", elem_id="size_list")
+
+                with gr.Row(visible=False) as custom_size:
+                    custom_size_height = gr.Number(value=413, label="height", interactive=True)
+                    custom_size_wdith = gr.Number(value=295, label="width", interactive=True)
+
+                color_options = gr.Radio(choices=colors, label="背景色", value="蓝色", elem_id="color")
+                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)
+                    custom_color_B = gr.Number(value=0, label="B", interactive=True)
+
+                render_options = gr.Radio(choices=render, label="渲染方式", value="纯色", elem_id="render")
+
+                img_but = gr.Button('开始制作')
+                # 案例图片
+                example_images = gr.Dataset(components=[img_input],
+                                            samples=[[path.as_posix()]
+                                                     for path in sorted(pathlib.Path('images').rglob('*.jpg'))])
+
+            with gr.Column():
+                notification = gr.Text(label="状态", 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)
+
+
+            def change_color(colors):
+                if colors == "自定义底色":
+                    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 == "自定义尺寸":
+                    return {custom_size: gr.update(visible=True),
+                            size_list_row: gr.update(visible=False)}
+                elif size_option_item == "只换底":
+                    return {custom_size: gr.update(visible=False),
+                            size_list_row: gr.update(visible=False)}
+                else:
+                    return {custom_size: gr.update(visible=False),
+                            size_list_row: gr.update(visible=True)}
+
+        color_options.input(change_color, inputs=[color_options], outputs=[custom_color])
+        mode_options.input(change_size_mode, inputs=[mode_options], outputs=[custom_size, size_list_row])
+
+        img_but.click(idphoto_inference,
+                      inputs=[img_input, mode_options, size_list_options, color_options, render_options,
+                              custom_color_R, custom_color_G, custom_color_B,
+                              custom_size_height, custom_size_wdith],
+                      outputs=[img_output_standard, img_output_standard_hd, img_output_layout, notification],
+                      queue=True)
+        example_images.click(fn=set_example_image, inputs=[example_images], outputs=[img_input])
+
+    demo.launch(enable_queue=True)

beautyPlugin/GrindSkin.py

@@ -0,0 +1,43 @@
+"""
+@author: cuny
+@file: GrindSkin.py
+@time: 2022/7/2 14:44
+@description: 
+磨皮算法
+"""
+import cv2
+import numpy as np
+
+
+def grindSkin(src, grindDegree: int = 3, detailDegree: int = 1, strength: int = 9):
+    """
+    Dest =(Src * (100 - Opacity) + (Src + 2 * GaussBlur(EPFFilter(Src) - Src)) * Opacity) /100
+    人像磨皮方案，后续会考虑使用一些皮肤区域检测算法来实现仅皮肤区域磨皮，增加算法的精细程度——或者使用人脸关键点
+    https://www.cnblogs.com/Imageshop/p/4709710.html
+    Args:
+        src: 原图
+        grindDegree: 磨皮程度调节参数
+        detailDegree: 细节程度调节参数
+        strength: 融合程度，作为磨皮强度（0 - 10）
+
+    Returns:
+        磨皮后的图像
+    """
+    if strength <= 0:
+        return src
+    dst = src.copy()
+    opacity = min(10., strength) / 10.
+    dx = grindDegree * 5  # 双边滤波参数之一
+    fc = grindDegree * 12.5  # 双边滤波参数之一
+    temp1 = cv2.bilateralFilter(src[:, :, :3], dx, fc, fc)
+    temp2 = cv2.subtract(temp1, src[:, :, :3])
+    temp3 = cv2.GaussianBlur(temp2, (2 * detailDegree - 1, 2 * detailDegree - 1), 0)
+    temp4 = cv2.add(cv2.add(temp3, temp3), src[:, :, :3])
+    dst[:, :, :3] = cv2.addWeighted(temp4, opacity, src[:, :, :3], 1 - opacity, 0.0)
+    return dst
+
+
+if __name__ == "__main__":
+    input_image = cv2.imread("test_image/7.jpg")
+    output_image = grindSkin(src=input_image)
+    cv2.imwrite("grindSkinCompare.png", np.hstack((input_image, output_image)))

beautyPlugin/MakeBeautiful.py

@@ -0,0 +1,45 @@
+"""
+@author: cuny
+@file: MakeBeautiful.py
+@time: 2022/7/7 20:23
+@description: 
+美颜工具集合文件，作为暴露在外的插件接口
+"""
+from .GrindSkin import grindSkin
+from .MakeWhiter import MakeWhiter
+from .ThinFace import thinFace
+import numpy as np
+
+
+def makeBeautiful(input_image: np.ndarray,
+                  landmark,
+                  thinStrength: int,
+                  thinPlace: int,
+                  grindStrength: int,
+                  whiterStrength: int
+                  ) -> np.ndarray:
+    """
+    美颜工具的接口函数，用于实现美颜效果
+    Args:
+        input_image: 输入的图像
+        landmark: 瘦脸需要的人脸关键点信息，为fd68返回的第二个参数
+        thinStrength: 瘦脸强度，为0-10（如果更高其实也没什么问题），当强度为0或者更低时，则不瘦脸
+        thinPlace: 选择瘦脸区域，为0-2之间的值，越大瘦脸的点越靠下
+        grindStrength: 磨皮强度，为0-10（如果更高其实也没什么问题），当强度为0或者更低时，则不磨皮
+        whiterStrength: 美白强度，为0-10（如果更高其实也没什么问题），当强度为0或者更低时，则不美白
+    Returns:
+        output_image 输出图像
+    """
+    try:
+        _, _, _ = input_image.shape
+    except ValueError:
+        raise TypeError("输入图像必须为3通道或者4通道!")
+    # 三通道或者四通道图像
+    # 首先进行瘦脸
+    input_image = thinFace(input_image, landmark, place=thinPlace, strength=thinStrength)
+    # 其次进行磨皮
+    input_image = grindSkin(src=input_image, strength=grindStrength)
+    # 最后进行美白
+    makeWhiter = MakeWhiter()
+    input_image = makeWhiter.run(input_image, strength=whiterStrength)
+    return input_image

beautyPlugin/MakeWhiter.py

@@ -0,0 +1,108 @@
+"""
+@author: cuny
+@file: MakeWhiter.py
+@time: 2022/7/2 14:28
+@description: 
+美白算法
+"""
+import os
+import cv2
+import math
+import numpy as np
+local_path = os.path.dirname(__file__)
+
+
+class MakeWhiter(object):
+    class __LutWhite:
+        """
+        美白的内部类
+        """
+
+        def __init__(self, lut):
+            cube64rows = 8
+            cube64size = 64
+            cube256size = 256
+            cubeScale = int(cube256size / cube64size)  # 4
+
+            reshapeLut = np.zeros((cube256size, cube256size, cube256size, 3))
+            for i in range(cube64size):
+                tmp = math.floor(i / cube64rows)
+                cx = int((i - tmp * cube64rows) * cube64size)
+                cy = int(tmp * cube64size)
+                cube64 = lut[cy:cy + cube64size, cx:cx + cube64size]  # cube64 in lut(512*512 (512=8*64))
+                _rows, _cols, _ = cube64.shape
+                if _rows == 0 or _cols == 0:
+                    continue
+                cube256 = cv2.resize(cube64, (cube256size, cube256size))
+                i = i * cubeScale
+                for k in range(cubeScale):
+                    reshapeLut[i + k] = cube256
+            self.lut = reshapeLut
+
+        def imageInLut(self, src):
+            arr = src.copy()
+            bs = arr[:, :, 0]
+            gs = arr[:, :, 1]
+            rs = arr[:, :, 2]
+            arr[:, :] = self.lut[bs, gs, rs]
+            return arr
+
+    def __init__(self, lutImage: np.ndarray = None):
+        self.__lutWhiten = None
+        if lutImage is not None:
+            self.__lutWhiten = self.__LutWhite(lutImage)
+
+    def setLut(self, lutImage: np.ndarray):
+        self.__lutWhiten = self.__LutWhite(lutImage)
+
+    @staticmethod
+    def generate_identify_color_matrix(size: int = 512, channel: int = 3) -> np.ndarray:
+        """
+        用于生成一张初始的查找表
+        Args:
+            size: 查找表尺寸，默认为512
+            channel: 查找表通道数，默认为3
+
+        Returns:
+            返回生成的查找表图像
+        """
+        img = np.zeros((size, size, channel), dtype=np.uint8)
+        for by in range(size // 64):
+            for bx in range(size // 64):
+                for g in range(64):
+                    for r in range(64):
+                        x = r + bx * 64
+                        y = g + by * 64
+                        img[y][x][0] = int(r * 255.0 / 63.0 + 0.5)
+                        img[y][x][1] = int(g * 255.0 / 63.0 + 0.5)
+                        img[y][x][2] = int((bx + by * 8.0) * 255.0 / 63.0 + 0.5)
+        return cv2.cvtColor(img, cv2.COLOR_RGB2BGR).clip(0, 255).astype('uint8')
+
+    def run(self, src: np.ndarray, strength: int) -> np.ndarray:
+        """
+        美白图像
+        Args:
+            src: 原图
+            strength: 美白强度，0 - 10
+        Returns:
+            美白后的图像
+        """
+        dst = src.copy()
+        strength = min(10, int(strength)) / 10.
+        if strength <= 0:
+            return dst
+        self.setLut(cv2.imread(f"{local_path}/lut_image/3.png", -1))
+        _, _, c = src.shape
+        img = self.__lutWhiten.imageInLut(src[:, :, :3])
+        dst[:, :, :3] = cv2.addWeighted(src[:, :, :3], 1 - strength, img, strength, 0)
+        return dst
+
+
+if __name__ == "__main__":
+    # makeLut = MakeWhiter()
+    # cv2.imwrite("lutOrigin.png", makeLut.generate_identify_color_matrix())
+    input_image = cv2.imread("test_image/7.jpg", -1)
+    lut_image = cv2.imread("lut_image/3.png")
+    makeWhiter = MakeWhiter(lut_image)
+    output_image = makeWhiter.run(input_image, 10)
+    cv2.imwrite("makeWhiterCompare.png", np.hstack((input_image, output_image)))

beautyPlugin/ThinFace.py

@@ -0,0 +1,267 @@
+"""
+@author: cuny
+@file: ThinFace.py
+@time: 2022/7/2 15:50
+@description:
+瘦脸算法，用到了图像局部平移法
+先使用人脸关键点检测，然后再使用图像局部平移法
+需要注意的是，这部分不会包含dlib人脸关键点检测，因为考虑到模型载入的问题
+"""
+import cv2
+import math
+import numpy as np
+
+
+class TranslationWarp(object):
+    """
+    本类包含瘦脸算法，由于瘦脸算法包含了很多个版本，所以以类的方式呈现
+    前两个算法没什么好讲的，网上资料很多
+    第三个采用numpy内部的自定义函数处理，在处理速度上有一些提升
+    最后采用cv2.map算法，处理速度大幅度提升
+    """
+
+    # 瘦脸
+    @staticmethod
+    def localTranslationWarp(srcImg, startX, startY, endX, endY, radius):
+        # 双线性插值法
+        def BilinearInsert(src, ux, uy):
+            w, h, c = src.shape
+            if c == 3:
+                x1 = int(ux)
+                x2 = x1 + 1
+                y1 = int(uy)
+                y2 = y1 + 1
+                part1 = src[y1, x1].astype(np.float64) * (float(x2) - ux) * (float(y2) - uy)
+                part2 = src[y1, x2].astype(np.float64) * (ux - float(x1)) * (float(y2) - uy)
+                part3 = src[y2, x1].astype(np.float64) * (float(x2) - ux) * (uy - float(y1))
+                part4 = src[y2, x2].astype(np.float64) * (ux - float(x1)) * (uy - float(y1))
+                insertValue = part1 + part2 + part3 + part4
+                return insertValue.astype(np.int8)
+
+        ddradius = float(radius * radius)  # 圆的半径
+        copyImg = srcImg.copy()  # copy后的图像矩阵
+        # 计算公式中的|m-c|^2
+        ddmc = (endX - startX) * (endX - startX) + (endY - startY) * (endY - startY)
+        H, W, C = srcImg.shape  # 获取图像的形状
+        for i in range(W):
+            for j in range(H):
+                # # 计算该点是否在形变圆的范围之内
+                # # 优化，第一步，直接判断是会在（startX,startY)的矩阵框中
+                if math.fabs(i - startX) > radius and math.fabs(j - startY) > radius:
+                    continue
+                distance = (i - startX) * (i - startX) + (j - startY) * (j - startY)
+                if distance < ddradius:
+                    # 计算出（i,j）坐标的原坐标
+                    # 计算公式中右边平方号里的部分
+                    ratio = (ddradius - distance) / (ddradius - distance + ddmc)
+                    ratio = ratio * ratio
+                    # 映射原位置
+                    UX = i - ratio * (endX - startX)
+                    UY = j - ratio * (endY - startY)
+
+                    # 根据双线性插值法得到UX，UY的值
+                    # start_ = time.time()
+                    value = BilinearInsert(srcImg, UX, UY)
+                    # print(f"双线性插值耗时;{time.time() - start_}")
+                    # 改变当前 i ，j的值
+                    copyImg[j, i] = value
+        return copyImg
+
+    # 瘦脸pro1, 限制了for循环的遍历次数
+    @staticmethod
+    def localTranslationWarpLimitFor(srcImg, startP: np.matrix, endP: np.matrix, radius: float):
+        startX, startY = startP[0, 0], startP[0, 1]
+        endX, endY = endP[0, 0], endP[0, 1]
+
+        # 双线性插值法
+        def BilinearInsert(src, ux, uy):
+            w, h, c = src.shape
+            if c == 3:
+                x1 = int(ux)
+                x2 = x1 + 1
+                y1 = int(uy)
+                y2 = y1 + 1
+                part1 = src[y1, x1].astype(np.float64) * (float(x2) - ux) * (float(y2) - uy)
+                part2 = src[y1, x2].astype(np.float64) * (ux - float(x1)) * (float(y2) - uy)
+                part3 = src[y2, x1].astype(np.float64) * (float(x2) - ux) * (uy - float(y1))
+                part4 = src[y2, x2].astype(np.float64) * (ux - float(x1)) * (uy - float(y1))
+                insertValue = part1 + part2 + part3 + part4
+                return insertValue.astype(np.int8)
+
+        ddradius = float(radius * radius)  # 圆的半径
+        copyImg = srcImg.copy()  # copy后的图像矩阵
+        # 计算公式中的|m-c|^2
+        ddmc = (endX - startX) ** 2 + (endY - startY) ** 2
+        # 计算正方形的左上角起始点
+        startTX, startTY = (startX - math.floor(radius + 1), startY - math.floor((radius + 1)))
+        # 计算正方形的右下角的结束点
+        endTX, endTY = (startX + math.floor(radius + 1), startY + math.floor((radius + 1)))
+        # 剪切srcImg
+        srcImg = srcImg[startTY: endTY + 1, startTX: endTX + 1, :]
+        # db.cv_show(srcImg)
+        # 裁剪后的图像相当于在x,y都减少了startX - math.floor(radius + 1)
+        # 原本的endX, endY在切后的坐标点
+        endX, endY = (endX - startX + math.floor(radius + 1), endY - startY + math.floor(radius + 1))
+        # 原本的startX, startY剪切后的坐标点
+        startX, startY = (math.floor(radius + 1), math.floor(radius + 1))
+        H, W, C = srcImg.shape  # 获取图像的形状
+        for i in range(W):
+            for j in range(H):
+                # 计算该点是否在形变圆的范围之内
+                # 优化，第一步，直接判断是会在（startX,startY)的矩阵框中
+                # if math.fabs(i - startX) > radius and math.fabs(j - startY) > radius:
+                #     continue
+                distance = (i - startX) * (i - startX) + (j - startY) * (j - startY)
+                if distance < ddradius:
+                    # 计算出（i,j）坐标的原坐标
+                    # 计算公式中右边平方号里的部分
+                    ratio = (ddradius - distance) / (ddradius - distance + ddmc)
+                    ratio = ratio * ratio
+                    # 映射原位置
+                    UX = i - ratio * (endX - startX)
+                    UY = j - ratio * (endY - startY)
+
+                    # 根据双线性插值法得到UX，UY的值
+                    # start_ = time.time()
+                    value = BilinearInsert(srcImg, UX, UY)
+                    # print(f"双线性插值耗时;{time.time() - start_}")
+                    # 改变当前 i ，j的值
+                    copyImg[j + startTY, i + startTX] = value
+        return copyImg
+
+    # # 瘦脸pro2,采用了numpy自定义函数做处理
+    # def localTranslationWarpNumpy(self, srcImg, startP: np.matrix, endP: np.matrix, radius: float):
+    #     startX , startY = startP[0, 0], startP[0, 1]
+    #     endX, endY = endP[0, 0], endP[0, 1]
+    #     ddradius = float(radius * radius)  # 圆的半径
+    #     copyImg = srcImg.copy()  # copy后的图像矩阵
+    #     # 计算公式中的|m-c|^2
+    #     ddmc = (endX - startX)**2 + (endY - startY)**2
+    #     # 计算正方形的左上角起始点
+    #     startTX, startTY = (startX - math.floor(radius + 1), startY - math.floor((radius + 1)))
+    #     # 计算正方形的右下角的结束点
+    #     endTX, endTY = (startX + math.floor(radius + 1), startY + math.floor((radius + 1)))
+    #     # 剪切srcImg
+    #     self.thinImage = srcImg[startTY : endTY + 1, startTX : endTX + 1, :]
+    #     # s = self.thinImage
+    #     # db.cv_show(srcImg)
+    #     # 裁剪后的图像相当于在x,y都减少了startX - math.floor(radius + 1)
+    #     # 原本的endX, endY在切后的坐标点
+    #     endX, endY = (endX - startX + math.floor(radius + 1), endY - startY + math.floor(radius + 1))
+    #     # 原本的startX, startY剪切后的坐标点
+    #     startX ,startY = (math.floor(radius + 1), math.floor(radius + 1))
+    #     H, W, C = self.thinImage.shape  # 获取图像的形状
+    #     index_m = np.arange(H * W).reshape((H, W))
+    #     triangle_ufunc = np.frompyfunc(self.process, 9, 3)
+    #     # start_ = time.time()
+    #     finalImgB, finalImgG, finalImgR = triangle_ufunc(index_m, self, W, ddradius, ddmc, startX, startY, endX, endY)
+    #     finaleImg = np.dstack((finalImgB, finalImgG, finalImgR)).astype(np.uint8)
+    #     finaleImg = np.fliplr(np.rot90(finaleImg, -1))
+    #     copyImg[startTY: endTY + 1, startTX: endTX + 1, :] = finaleImg
+    #     # print(f"图像处理耗时;{time.time() - start_}")
+    #     # db.cv_show(copyImg)
+    #     return copyImg
+
+    # 瘦脸pro3,采用opencv内置函数
+    @staticmethod
+    def localTranslationWarpFastWithStrength(srcImg, startP: np.matrix, endP: np.matrix, radius, strength: float = 100.):
+        """
+        采用opencv内置函数
+        Args:
+            srcImg: 源图像
+            startP: 起点位置
+            endP: 终点位置
+            radius: 处理半径
+            strength: 瘦脸强度，一般取100以上
+
+        Returns:
+
+        """
+        startX, startY = startP[0, 0], startP[0, 1]
+        endX, endY = endP[0, 0], endP[0, 1]
+        ddradius = float(radius * radius)
+        # copyImg = np.zeros(srcImg.shape, np.uint8)
+        # copyImg = srcImg.copy()
+
+        maskImg = np.zeros(srcImg.shape[:2], np.uint8)
+        cv2.circle(maskImg, (startX, startY), math.ceil(radius), (255, 255, 255), -1)
+
+        K0 = 100 / strength
+
+        # 计算公式中的|m-c|^2
+        ddmc_x = (endX - startX) * (endX - startX)
+        ddmc_y = (endY - startY) * (endY - startY)
+        H, W, C = srcImg.shape
+
+        mapX = np.vstack([np.arange(W).astype(np.float32).reshape(1, -1)] * H)
+        mapY = np.hstack([np.arange(H).astype(np.float32).reshape(-1, 1)] * W)
+
+        distance_x = (mapX - startX) * (mapX - startX)
+        distance_y = (mapY - startY) * (mapY - startY)
+        distance = distance_x + distance_y
+        K1 = np.sqrt(distance)
+        ratio_x = (ddradius - distance_x) / (ddradius - distance_x + K0 * ddmc_x)
+        ratio_y = (ddradius - distance_y) / (ddradius - distance_y + K0 * ddmc_y)
+        ratio_x = ratio_x * ratio_x
+        ratio_y = ratio_y * ratio_y
+
+        UX = mapX - ratio_x * (endX - startX) * (1 - K1 / radius)
+        UY = mapY - ratio_y * (endY - startY) * (1 - K1 / radius)
+
+        np.copyto(UX, mapX, where=maskImg == 0)
+        np.copyto(UY, mapY, where=maskImg == 0)
+        UX = UX.astype(np.float32)
+        UY = UY.astype(np.float32)
+        copyImg = cv2.remap(srcImg, UX, UY, interpolation=cv2.INTER_LINEAR)
+        return copyImg
+
+
+def thinFace(src, landmark, place: int = 0, strength=30.):
+    """
+    瘦脸程序接口，输入人脸关键点信息和强度，即可实现瘦脸
+    注意处理四通道图像
+    Args:
+        src: 原图
+        landmark: 关键点信息
+        place: 选择瘦脸区域，为0-4之间的值
+        strength: 瘦脸强度，输入值在0-10之间，如果小于或者等于0，则不瘦脸
+
+    Returns:
+        瘦脸后的图像
+    """
+    strength = min(100., strength * 10.)
+    if strength <= 0.:
+        return src
+    # 也可以设置瘦脸区域
+    place = max(0, min(4, int(place)))
+    left_landmark = landmark[4 + place]
+    left_landmark_down = landmark[6 + place]
+    right_landmark = landmark[13 + place]
+    right_landmark_down = landmark[15 + place]
+    endPt = landmark[58]
+    # 计算第4个点到第6个点的距离作为瘦脸距离
+    r_left = math.sqrt(
+        (left_landmark[0, 0] - left_landmark_down[0, 0]) ** 2 +
+        (left_landmark[0, 1] - left_landmark_down[0, 1]) ** 2
+    )
+
+    # 计算第14个点到第16个点的距离作为瘦脸距离
+    r_right = math.sqrt((right_landmark[0, 0] - right_landmark_down[0, 0]) ** 2 +
+                        (right_landmark[0, 1] - right_landmark_down[0, 1]) ** 2)
+    # 瘦左边脸
+    thin_image = TranslationWarp.localTranslationWarpFastWithStrength(src, left_landmark[0], endPt[0], r_left, strength)
+    # 瘦右边脸
+    thin_image = TranslationWarp.localTranslationWarpFastWithStrength(thin_image, right_landmark[0], endPt[0], r_right, strength)
+    return thin_image
+
+
+if __name__ == "__main__":
+    import os
+    from hycv.FaceDetection68.faceDetection68 import FaceDetection68
+    local_file = os.path.dirname(__file__)
+    PREDICTOR_PATH = f"{local_file}/weights/shape_predictor_68_face_landmarks.dat"  # 关键点检测模型路径
+    fd68 = FaceDetection68(model_path=PREDICTOR_PATH)
+    input_image = cv2.imread("test_image/4.jpg", -1)
+    _, landmark_, _ = fd68.facePoints(input_image)
+    output_image = thinFace(input_image, landmark_, strength=30.2)
+    cv2.imwrite("thinFaceCompare.png", np.hstack((input_image, output_image)))

beautyPlugin/__init__.py

@@ -0,0 +1,4 @@
+from .MakeBeautiful import makeBeautiful
+
+
+

cuny_tools.py

@@ -0,0 +1,621 @@
+import cv2
+import numpy as np
+from hivisionai.hycv.utils import get_box_pro
+from hivisionai.hycv.vision import cover_image, draw_picture_dots
+from math import fabs, sin, radians, cos
+
+def opencv_rotate(img, angle):
+    h, w = img.shape[:2]
+    center = (w / 2, h / 2)
+    scale = 1.0
+    # 2.1获取M矩阵
+    """
+    M矩阵
+    [
+    cosA -sinA (1-cosA)*centerX+sinA*centerY
+    sinA cosA  -sinA*centerX+(1-cosA)*centerY
+    ]
+    """
+    M = cv2.getRotationMatrix2D(center, angle, scale)
+    # 2.2 新的宽高，radians(angle) 把角度转为弧度 sin(弧度)
+    new_H = int(w * fabs(sin(radians(angle))) + h * fabs(cos(radians(angle))))
+    new_W = int(h * fabs(sin(radians(angle))) + w * fabs(cos(radians(angle))))
+    # 2.3 平移
+    M[0, 2] += (new_W - w) / 2
+    M[1, 2] += (new_H - h) / 2
+    rotate = cv2.warpAffine(img, M, (new_W, new_H), borderValue=(0, 0, 0))
+    return rotate
+
+
+def transformationNeck2(image:np.ndarray, per_to_side:float=0.8)->np.ndarray:
+    """
+    透视变换脖子函数,输入图像和四个点(矩形框)
+    矩形框内的图像可能是不完整的(边角有透明区域)
+    我们将根据透视变换将矩形框内的图像拉伸成和矩形框一样的形状.
+    算法分为几个步骤: 选择脖子的四个点 -> 选定这四个点拉伸后的坐标 -> 透视变换 -> 覆盖原图
+    """
+    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
+    height, width = a.shape
+    def locate_side(image_:np.ndarray, x_:int, y_max:int) -> int:
+        # 寻找x=y, 且 y <= y_max 上从下往上第一个非0的点,如果没找到就返回0
+        y_ = 0
+        for y_ in range(y_max - 1, -1, -1):
+            if image_[y_][x_] != 0:
+                break
+        return y_
+    def locate_width(image_:np.ndarray, y_:int, mode, left_or_right:int=None):
+        # 从y=y这个水平线上寻找两边的非零点
+        # 增加left_or_right的原因在于为下面check_jaw服务
+        if mode==1:  # 左往右
+            x_ = 0
+            if left_or_right is None:
+                left_or_right = 0
+            for x_ in range(left_or_right, width):
+                if image_[y_][x_] != 0:
+                    break
+        else:  # 右往左
+            x_ = width
+            if left_or_right is None:
+                left_or_right = width - 1
+            for x_ in range(left_or_right, -1, -1):
+                if image_[y_][x_] != 0:
+                    break
+        return x_
+    def check_jaw(image_:np.ndarray, left_, right_):
+        """
+        检查选择的点是否与截到下巴,如果截到了,就往下平移一个单位
+        """
+        f= True # True代表没截到下巴
+        # [x, y]
+        for x_cell in range(left_[0] + 1, right_[0]):
+            if image_[left_[1]][x_cell] == 0:
+                f = False
+                break
+        if f is True:
+            return left_, right_
+        else:
+            y_ = left_[1] + 2
+            x_left_ = locate_width(image_, y_, mode=1, left_or_right=left_[0])
+            x_right_ = locate_width(image_, y_, mode=2, left_or_right=right_[0])
+            left_, right_ = check_jaw(image_, [x_left_, y_], [x_right_, y_])
+        return left_, right_
+    # 选择脖子的四个点,核心在于选择上面的两个点,这两个点的确定的位置应该是"宽出来的"两个点
+    _, _ ,_, a = cv2.split(image)  # 这应该是一个四通道的图像
+    ret,a_thresh = cv2.threshold(a,127,255,cv2.THRESH_BINARY)
+    y_high, y_low, x_left, x_right = get_box_pro(image=image, model=1) # 直接返回矩阵信息
+    y_left_side = locate_side(image_=a_thresh, x_=x_left, y_max=y_low)  # 左边的点的y轴坐标
+    y_right_side = locate_side(image_=a_thresh, x_=x_right, y_max=y_low)  # 右边的点的y轴坐标
+    y = min(y_left_side, y_right_side)  # 将两点的坐标保持相同
+    cell_left_above, cell_right_above = check_jaw(a_thresh,[x_left, y], [x_right, y])
+    x_left, x_right = cell_left_above[0], cell_right_above[0]
+    # 此时我们寻找到了脖子的"宽出来的"两个点,这两个点作为上面的两个点, 接下来寻找下面的两个点
+    if per_to_side >1:
+        assert ValueError("per_to_side 必须小于1!")
+    # 在后面的透视变换中我会把它拉成矩形, 在这里我先获取四个点的高和宽
+    height_ = 150  # 这个值应该是个变化的值,与拉伸的长度有关,但是现在先规定为150
+    width_ = x_right - x_left  # 其实也就是 cell_right_above[1] - cell_left_above[1]
+    y = int((y_low - y)*per_to_side + y)  # 定位y轴坐标
+    cell_left_below, cell_right_bellow = ([locate_width(a_thresh, y_=y, mode=1), y], [locate_width(a_thresh, y_=y, mode=2), y])
+    # 四个点全齐,开始透视变换
+    # 寻找透视变换后的四个点,只需要变换below的两个点即可
+    # cell_left_below_final, cell_right_bellow_final = ([cell_left_above[1], y_low], [cell_right_above[1], y_low])
+    # 需要变换的四个点为 cell_left_above, cell_right_above, cell_left_below, cell_right_bellow
+    rect = np.array([cell_left_above, cell_right_above, cell_left_below, cell_right_bellow],
+                    dtype='float32')
+    # 变化后的坐标点
+    dst = np.array([[0, 0], [width_, 0], [0 , height_], [width_, height_]],
+                    dtype='float32')
+    # 计算变换矩阵
+    M = cv2.getPerspectiveTransform(rect, dst)
+    warped = cv2.warpPerspective(image, M, (width_, height_))
+    final = cover_image(image=warped, background=image, mode=3, x=cell_left_above[0], y=cell_left_above[1])
+    # tmp = np.zeros(image.shape)
+    # final = cover_image(image=warped, background=tmp, mode=3, x=cell_left_above[0], y=cell_left_above[1])
+    # final = cover_image(image=image, background=final, mode=3, x=0, y=0)
+    return final
+
+
+def transformationNeck(image:np.ndarray, cutNeckHeight:int, neckBelow:int,
+                       toHeight:int,per_to_side:float=0.75) -> np.ndarray:
+    """
+    脖子扩充算法, 其实需要输入的只是脖子扣出来的部分以及需要被扩充的高度/需要被扩充成的高度.
+    """
+    height, width, channels = image.shape
+    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
+    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
+    def locate_width(image_:np.ndarray, y_:int, mode, left_or_right:int=None):
+        # 从y=y这个水平线上寻找两边的非零点
+        # 增加left_or_right的原因在于为下面check_jaw服务
+        if mode==1:  # 左往右
+            x_ = 0
+            if left_or_right is None:
+                left_or_right = 0
+            for x_ in range(left_or_right, width):
+                if image_[y_][x_] != 0:
+                    break
+        else:  # 右往左
+            x_ = width
+            if left_or_right is None:
+                left_or_right = width - 1
+            for x_ in range(left_or_right, -1, -1):
+                if image_[y_][x_] != 0:
+                    break
+        return x_
+    def check_jaw(image_:np.ndarray, left_, right_):
+        """
+        检查选择的点是否与截到下巴,如果截到了,就往下平移一个单位
+        """
+        f= True # True代表没截到下巴
+        # [x, y]
+        for x_cell in range(left_[0] + 1, right_[0]):
+            if image_[left_[1]][x_cell] == 0:
+                f = False
+                break
+        if f is True:
+            return left_, right_
+        else:
+            y_ = left_[1] + 2
+            x_left_ = locate_width(image_, y_, mode=1, left_or_right=left_[0])
+            x_right_ = locate_width(image_, y_, mode=2, left_or_right=right_[0])
+            left_, right_ = check_jaw(image_, [x_left_, y_], [x_right_, y_])
+        return left_, right_
+    x_left = locate_width(image_=a_thresh, mode=1, y_=cutNeckHeight)
+    x_right = locate_width(image_=a_thresh, mode=2, y_=cutNeckHeight)
+    # 在这里我们取消了对下巴的检查,原因在于输入的imageHeight并不能改变
+    # cell_left_above, cell_right_above = check_jaw(a_thresh, [x_left, imageHeight], [x_right, imageHeight])
+    cell_left_above, cell_right_above = [x_left, cutNeckHeight], [x_right, cutNeckHeight]
+    toWidth = x_right - x_left  # 矩形宽
+    # 此时我们寻找到了脖子的"宽出来的"两个点,这两个点作为上面的两个点, 接下来寻找下面的两个点
+    if per_to_side >1:
+        assert ValueError("per_to_side 必须小于1!")
+    y_below = int((neckBelow - cutNeckHeight) * per_to_side + cutNeckHeight)  # 定位y轴坐标
+    cell_left_below = [locate_width(a_thresh, y_=y_below, mode=1), y_below]
+    cell_right_bellow = [locate_width(a_thresh, y_=y_below, mode=2), y_below]
+    # 四个点全齐,开始透视变换
+    # 需要变换的四个点为 cell_left_above, cell_right_above, cell_left_below, cell_right_bellow
+    rect = np.array([cell_left_above, cell_right_above, cell_left_below, cell_right_bellow],
+                    dtype='float32')
+    # 变化后的坐标点
+    dst = np.array([[0, 0], [toWidth, 0], [0 , toHeight], [toWidth, toHeight]],
+                    dtype='float32')
+    M = cv2.getPerspectiveTransform(rect, dst)
+    warped = cv2.warpPerspective(image, M, (toWidth, toHeight))
+    # 将变换后的图像覆盖到原图上
+    final = cover_image(image=warped, background=image, mode=3, x=cell_left_above[0], y=cell_left_above[1])
+    return final
+
+
+def bestJunctionCheck_beta(image:np.ndarray, stepSize:int=4, if_per:bool=False):
+    """
+    最优衔接点检测算法, 去寻找脖子的"拐点"
+    """
+    point_k = 1
+    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
+    height, width = a.shape
+    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
+    y_high, y_low, x_left, x_right = get_box_pro(image=image, model=1)  # 直接返回矩阵信息
+    def scan(y_:int, max_num:int=2):
+        num = 0
+        left = False
+        right = False
+        for x_ in range(width):
+            if a_thresh[y_][x_] != 0:
+                if x_ < width // 2 and left is False:
+                    num += 1
+                    left = True
+                elif x_ > width // 2 and right is False:
+                    num += 1
+                    right = True
+        return True if num >= max_num else False
+    def locate_neck_above():
+        """
+        定位脖子的尖尖脚
+        """
+        for y_ in range( y_high - 2, height):
+            if scan(y_):
+                return y_, y_
+    y_high_left, y_high_right = locate_neck_above()
+    def locate_width_pro(image_:np.ndarray, y_:int, mode):
+        """
+        这会是一个生成器,用于生成脖子两边的轮廓
+        x_, y_ 是启始点的坐标,每一次寻找都会让y_+1
+        mode==1说明是找左边的边,即,image_[y_][x_] == 0 且image_[y_][x_ + 1] !=0 时跳出;
+            否则 当image_[y_][x_] != 0 时, x_ - 1; 当image_[y_][x_] == 0 且 image_[y_][x_ + 1] ==0 时x_ + 1
+        mode==2说明是找右边的边,即,image_[y_][x_] == 0 且image_[y_][x_ - 1] !=0 时跳出
+            否则 当image_[y_][x_] != 0 时, x_ + 1; 当image_[y_][x_] == 0 且 image_[y_][x_ - 1] ==0 时x_ - 1
+        """
+        y_ += 1
+        if mode == 1:
+            x_ = 0
+            while 0 <= y_ < height and 0 <= x_ < width:
+                while image_[y_][x_] != 0 and x_ >= 0:
+                    x_ -= 1
+                while image_[y_][x_] == 0 and image_[y_][x_ + 1] == 0 and x_ < width - 2:
+                    x_ += 1
+                yield [y_, x_]
+                y_ += 1
+        elif mode == 2:
+            x_ = width-1
+            while 0 <= y_ < height and 0 <= x_ < width:
+                while image_[y_][x_] != 0  and x_ < width - 2: x_ += 1
+                while image_[y_][x_] == 0 and image_[y_][x_ - 1] == 0 and x_ >= 0: x_ -= 1
+                yield [y_, x_]
+                y_ += 1
+        yield False
+    def kGenerator(image_:np.ndarray, mode):
+        """
+        导数生成器,用来生成每一个点对应的导数
+        """
+        y_ = y_high_left if mode == 1 else y_high_right
+        c_generator = locate_width_pro(image_=image_, y_=y_, mode=mode)
+        for cell in c_generator:
+            nc = locate_width_pro(image_=image_, y_=cell[0] + stepSize, mode=mode)
+            nextCell = next(nc)
+            if nextCell is False:
+                yield False, False
+            else:
+                k = (cell[1] - nextCell[1]) / stepSize
+                yield k, cell
+    def findPt(image_:np.ndarray, mode):
+        k_generator = kGenerator(image_=image_, mode=mode)
+        k, cell = next(k_generator)
+        k_next, cell_next = next(k_generator)
+        if k is False:
+            raise ValueError("无法找到拐点!")
+        while k_next is not False:
+            k_next, cell_next = next(k_generator)
+            if (k_next < - 1 / stepSize) or k_next > point_k:
+                break
+            cell = cell_next
+        # return int(cell[0] + stepSize / 2)
+        return cell[0]
+    # 先找左边的拐点:
+    pointY_left = findPt(image_=a_thresh, mode=1)
+    # 再找右边的拐点:
+    pointY_right = findPt(image_=a_thresh, mode=2)
+    point = (pointY_left + pointY_right) // 2
+    if if_per is True:
+        point = (pointY_left + pointY_right) // 2
+        return point / (y_low - y_high)
+    pointX_left = next(locate_width_pro(image_=a_thresh, y_= point - 1, mode=1))[1]
+    pointX_right = next(locate_width_pro(image_=a_thresh, y_=point- 1, mode=2))[1]
+    return [pointX_left, point], [pointX_right, point]
+
+
+def bestJunctionCheck(image:np.ndarray, offset:int, stepSize:int=4):
+    """
+    最优点检测算算法输入一张脖子图片(无论这张图片是否已经被二值化,我都认为没有被二值化),输出一个小数(脖子最上方与衔接点位置/脖子图像长度)
+    与beta版不同的是它新增了一个阈值限定内容.
+    对于脖子而言,我我们首先可以定位到上面的部分,然后根据上面的这个点向下进行遍历检测.
+    与beta版类似,我们使用一个stepSize来用作斜率的检测
+    但是对于遍历检测而言,与beta版不同的是,我们需要对遍历的地方进行一定的限制.
+    限制的标准是,如果当前遍历的点的横坐标和起始点横坐标的插值超过了某个阈值,则认为是越界.
+    """
+    point_k = 1
+    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
+    height, width = a.shape
+    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
+    # 直接返回脖子的位置信息, 修正系数为0, get_box_pro内部也封装了二值化,所以直接输入原图
+    y_high, y_low, _, _ = get_box_pro(image=image, model=1, correction_factor=0)
+    # 真正有用的只有上下y轴的两个值...
+    # 首先当然是确定起始点的位置,我们用同样的scan扫描函数进行行遍历.
+    def scan(y_:int, max_num:int=2):
+        num = 0
+        # 设定两个值,分别代表脖子的左边和右边
+        left = False
+        right = False
+        for x_ in range(width):
+            if a_thresh[y_][x_] != 0:
+                # 检测左边
+                if x_ < width // 2 and left is False:
+                    num += 1
+                    left = True
+                # 检测右边
+                elif x_ > width // 2 and right is False:
+                    num += 1
+                    right = True
+        return True if num >= max_num else False
+    def locate_neck_above():
+        """
+        定位脖子的尖尖脚
+        """
+        # y_high就是脖子的最高点
+        for y_ in range(y_high, height):
+            if scan(y_):
+                return y_
+    y_start = locate_neck_above()  # 得到遍历的初始高度
+    if y_low - y_start < stepSize: assert ValueError("脖子太小!")
+    # 然后获取一下初始的坐标点
+    x_left, x_right = 0, width
+    for x_left_ in range(0, width):
+        if a_thresh[y_start][x_left_] != 0:
+            x_left = x_left_
+            break
+    for x_right_  in range(width -1 , -1, -1):
+        if a_thresh[y_start][x_right_] != 0:
+            x_right = x_right_
+            break
+    # 接下来我定义两个生成器,首先是脖子轮廓(向下寻找的)生成器,每进行一次next,生成器会返回y+1的脖子轮廓点
+    def contoursGenerator(image_:np.ndarray, y_:int, mode):
+        """
+        这会是一个生成器,用于生成脖子两边的轮廓
+        y_ 是启始点的y坐标,每一次寻找都会让y_+1
+        mode==1说明是找左边的边,即,image_[y_][x_] == 0 且image_[y_][x_ + 1] !=0 时跳出;
+            否则 当image_[y_][x_] != 0 时, x_ - 1; 当image_[y_][x_] == 0 且 image_[y_][x_ + 1] ==0 时x_ + 1
+        mode==2说明是找右边的边,即,image_[y_][x_] == 0 且image_[y_][x_ - 1] !=0 时跳出
+            否则 当image_[y_][x_] != 0 时, x_ + 1; 当image_[y_][x_] == 0 且 image_[y_][x_ - 1] ==0 时x_ - 1
+        """
+        y_ += 1
+        try:
+            if mode == 1:
+                x_ = 0
+                while 0 <= y_ < height and 0 <= x_ < width:
+                    while image_[y_][x_] != 0 and x_ >= 0: x_ -= 1
+                    # 这里其实会有bug,不过可以不管
+                    while x_ < width and image_[y_][x_] == 0 and image_[y_][x_ + 1] == 0: x_ += 1
+                    yield [y_, x_]
+                    y_ += 1
+            elif mode == 2:
+                x_ = width-1
+                while 0 <= y_ < height and 0 <= x_ < width:
+                    while x_ < width and image_[y_][x_] != 0: x_ += 1
+                    while x_ >= 0 and image_[y_][x_] == 0 and image_[y_][x_ - 1] == 0: x_ -= 1
+                    yield [y_, x_]
+                    y_ += 1
+        # 当处理失败则返回False
+        except IndexError:
+            yield False
+    # 然后是斜率生成器,这个生成器依赖子轮廓生成器,每一次生成轮廓后会计算斜率,另一个点的选取和stepSize有关
+    def kGenerator(image_: np.ndarray, mode):
+        """
+        导数生成器,用来生成每一个点对应的导数
+        """
+        y_ = y_start
+        # 对起始点建立一个生成器, mode=1时是左边轮廓,mode=2时是右边轮廓
+        c_generator = contoursGenerator(image_=image_, y_=y_, mode=mode)
+        for cell in c_generator:
+            # 寻找距离当前cell距离为stepSize的轮廓点
+            kc = contoursGenerator(image_=image_, y_=cell[0] + stepSize, mode=mode)
+            kCell = next(kc)
+            if kCell is False:
+                # 寻找失败
+                yield False, False
+            else:
+                # 寻找成功,返回当坐标点和斜率值
+                # 对于左边而言,斜率必然是前一个点的坐标减去后一个点的坐标
+                # 对于右边而言,斜率必然是后一个点的坐标减去前一个点的坐标
+                k = (cell[1] - kCell[1]) / stepSize if mode == 1 else (kCell[1] - cell[1]) / stepSize
+                yield k, cell
+    # 接着开始写寻找算法,需要注意的是我们是分两边选择的
+    def findPt(image_:np.ndarray, mode):
+        x_base = x_left if mode == 1 else x_right
+        k_generator = kGenerator(image_=image_, mode=mode)
+        k, cell = k_generator.__next__()
+        if k is False:
+            raise ValueError("无法找到拐点!")
+        k_next, cell_next = k_generator.__next__()
+        while k_next is not False:
+            cell = cell_next
+            if cell[1] > x_base and mode == 2:
+                x_base = cell[1]
+            elif cell[1] < x_base and mode == 1:
+                x_base = cell[1]
+            # 跳出循环的方式一:斜率超过了某个值
+            if k_next > point_k:
+                print("K out")
+                break
+            # 跳出循环的方式二:超出阈值
+            elif abs(cell[1] - x_base) > offset:
+                print("O out")
+                break
+            k_next, cell_next = k_generator.__next__()
+        if abs(cell[1] - x_base) > offset:
+            cell[0] = cell[0] - offset - 1
+        return cell[0]
+    # 先找左边的拐点:
+    pointY_left = findPt(image_=a_thresh, mode=1)
+    # 再找右边的拐点:
+    pointY_right = findPt(image_=a_thresh, mode=2)
+    point = min(pointY_right, pointY_left)
+    per = (point - y_high) / (y_low - y_high)
+    # pointX_left = next(contoursGenerator(image_=a_thresh, y_= point- 1, mode=1))[1]
+    # pointX_right = next(contoursGenerator(image_=a_thresh, y_=point - 1, mode=2))[1]
+    # return [pointX_left, point], [pointX_right, point]
+    return per
+
+
+def checkSharpCorner(image:np.ndarray):
+    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
+    height, width = a.shape
+    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
+    # 直接返回脖子的位置信息, 修正系数为0, get_box_pro内部也封装了二值化,所以直接输入原图
+    y_high, y_low, _, _ = get_box_pro(image=image, model=1, correction_factor=0)
+    def scan(y_:int, max_num:int=2):
+        num = 0
+        # 设定两个值,分别代表脖子的左边和右边
+        left = False
+        right = False
+        for x_ in range(width):
+            if a_thresh[y_][x_] != 0:
+                # 检测左边
+                if x_ < width // 2 and left is False:
+                    num += 1
+                    left = True
+                # 检测右边
+                elif x_ > width // 2 and right is False:
+                    num += 1
+                    right = True
+        return True if num >= max_num else False
+    def locate_neck_above():
+        """
+        定位脖子的尖尖脚
+        """
+        # y_high就是脖子的最高点
+        for y_ in range(y_high, height):
+            if scan(y_):
+                return y_
+    y_start = locate_neck_above()
+    return y_start
+
+
+def checkJaw(image:np.ndarray, y_start:int):
+    # 寻找"马鞍点"
+    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
+    height, width = a.shape
+    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
+    if width <=1: raise TypeError("图像太小!")
+    x_left, x_right = 0, width - 1
+    for x_left in range(width):
+        if a_thresh[y_start][x_left] != 0:
+            while a_thresh[y_start][x_left] != 0: x_left += 1
+            break
+    for x_right in range(width-1, -1, -1):
+        if a_thresh[y_start][x_right] != 0:
+            while a_thresh[y_start][x_right] != 0: x_right -= 1
+            break
+    point_list_y = []
+    point_list_x = []
+    for x in range(x_left, x_right):
+        y = y_start
+        while a_thresh[y][x] == 0: y += 1
+        point_list_y.append(y)
+        point_list_x.append(x)
+    y = max(point_list_y)
+    x = point_list_x[point_list_y.index(y)]
+    return x, y
+
+
+def checkHairLOrR(cloth_image_input_cut,
+                  input_a,
+                  neck_a,
+                  cloth_image_input_top_y,
+                  cutbar_top=0.4,
+                  cutbar_bottom=0.5,
+                  threshold=0.3):
+    """
+    本函数用于检测衣服是否被头发遮挡,当前只考虑左右是否被遮挡,即"一刀切"
+    返回int
+    0代表没有被遮挡
+    1代表左边被遮挡
+    2代表右边被遮挡
+    3代表全被遮挡了
+    约定,输入的图像是一张灰度图,且被二值化过.
+    """
+    def per_darkPoint(img:np.ndarray) -> int:
+        """
+        用于遍历相加图像上的黑点.
+        然后返回黑点数/图像面积
+        """
+        h, w = img.shape
+        sum_darkPoint = 0
+        for y in range(h):
+            for x in range(w):
+                if img[y][x] == 0:
+                    sum_darkPoint += 1
+        return sum_darkPoint / (h * w)
+
+    if threshold < 0 or threshold > 1: raise TypeError("阈值设置必须在0和1之间!")
+
+    # 裁出cloth_image_input_cut按高度40%～50%的区域-cloth_image_input_cutbar，并转换为A矩阵，做二值化
+    cloth_image_input_height = cloth_image_input_cut.shape[0]
+    _, _, _, cloth_image_input_cutbar = cv2.split(cloth_image_input_cut[
+                                                  int(cloth_image_input_height * cutbar_top):int(
+                                                      cloth_image_input_height * cutbar_bottom), :])
+    _, cloth_image_input_cutbar = cv2.threshold(cloth_image_input_cutbar, 127, 255, cv2.THRESH_BINARY)
+
+    # 裁出input_image、neck_image的A矩阵的对应区域，并做二值化
+    input_a_cutbar = input_a[cloth_image_input_top_y + int(cloth_image_input_height * cutbar_top):
+                             cloth_image_input_top_y + int(cloth_image_input_height * cutbar_bottom), :]
+    _, input_a_cutbar = cv2.threshold(input_a_cutbar, 127, 255, cv2.THRESH_BINARY)
+    neck_a_cutbar = neck_a[cloth_image_input_top_y + int(cloth_image_input_height * cutbar_top):
+                           cloth_image_input_top_y + int(cloth_image_input_height * cutbar_bottom), :]
+    _, neck_a_cutbar = cv2.threshold(neck_a_cutbar, 50, 255, cv2.THRESH_BINARY)
+
+    # 将三个cutbar合到一起-result_a_cutbar
+    input_a_cutbar = np.uint8(255 - input_a_cutbar)
+    result_a_cutbar = cv2.add(input_a_cutbar, cloth_image_input_cutbar)
+    result_a_cutbar = cv2.add(result_a_cutbar, neck_a_cutbar)
+
+    if_mask = 0
+    # 我们将图像 一刀切,分为左边和右边
+    height, width = result_a_cutbar.shape  # 一通道图像
+    left_image = result_a_cutbar[:, :width//2]
+    right_image = result_a_cutbar[:, width//2:]
+    if per_darkPoint(left_image) > threshold:
+        if_mask = 1
+    if per_darkPoint(right_image) > threshold:
+        if_mask = 3 if if_mask == 1 else 2
+    return if_mask
+
+
+def find_black(image):
+    """
+    找黑色点函数，遇到输入矩阵中的第一个黑点，返回它的y值
+    """
+    height, width = image.shape[0], image.shape[1]
+    for i in range(height):
+        for j in range(width):
+            if image[i, j] < 127:
+                return i
+    return None
+
+
+def convert_black_array(image):
+    height, width = image.shape[0], image.shape[1]
+    mask = np.zeros([height, width])
+    for j in range(width):
+        for i in range(height):
+            if image[i, j] > 127:
+                mask[i:, j] = 1
+                break
+    return mask
+
+
+def checkLongHair(neck_image, head_bottom_y, neck_top_y):
+    """
+    长发检测函数，输入为head/neck图像，通过下巴是否为最低点，来判断是否为长发
+    :return 0 : 短发
+    :return 1 : 长发
+    """
+    jaw_y = neck_top_y + checkJaw(neck_image, y_start=checkSharpCorner(neck_image))[1]
+    if jaw_y >= head_bottom_y-3:
+        return 0
+    else:
+        return 1
+
+
+def checkLongHair2(head_bottom_y, cloth_top_y):
+    if head_bottom_y > cloth_top_y+10:
+        return 1
+    else:
+        return 0
+
+
+if __name__ == "__main__":
+    for i in range(1, 8):
+        img = cv2.imread(f"./neck_temp/neck_image{i}.png", cv2.IMREAD_UNCHANGED)
+        # new = transformationNeck(image=img, cutNeckHeight=419,neckBelow=472, toHeight=150)
+        # point_list = bestJunctionCheck(img, offset=5, stepSize=3)
+        # per = bestJunctionCheck(img, offset=5, stepSize=3)
+        # # 返回一个小数的形式, 接下来我将它处理为两个点
+        point_list = []
+        # y_high_, y_low_, _, _ = get_box_pro(image=img, model=1, conreection_factor=0)
+        # _y = y_high_ + int((y_low_ - y_high_) * per)
+        # _, _, _, a_ = cv2.split(img)  # 这应该是一个四通道的图像
+        # h, w = a_.shape
+        # r, a_t = cv2.threshold(a_, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
+        # _x = 0
+        # for _x in range(w):
+        #     if a_t[_y][_x] != 0:
+        #         break
+        # point_list.append([_x, _y])
+        # for _x in range(w - 1, -1, -1):
+        #     if a_t[_y][_x] != 0:
+        #         break
+        # point_list.append([_x, _y])
+        y = checkSharpCorner(img)
+        point = checkJaw(image=img, y_start=y)
+        point_list.append(point)
+        new = draw_picture_dots(img, point_list, pen_size=2)
+        cv2.imshow(f"{i}", new)
+    cv2.waitKey(0)

error.py

@@ -0,0 +1,27 @@
+"""
+@author: cuny
+@file: error.py
+@time: 2022/4/7 15:50
+@description: 
+定义证件照制作的错误类
+"""
+from hivisionai.hyService.error import ProcessError
+
+
+class IDError(ProcessError):
+    def __init__(self, err, diary=None, face_num=-1, status_id: str = "1500"):
+        """
+        用于报错
+        Args:
+            err: 错误描述
+            diary: 函数运行日志，默认为None
+            face_num: 告诉此时识别到的人像个数，如果为-1则说明为未知错误
+        """
+        super().__init__(err)
+        if diary is None:
+            diary = {}
+        self.err = err
+        self.diary = diary
+        self.face_num = face_num
+        self.status_id = status_id
+

face_judgement_align.py

@@ -0,0 +1,578 @@
+import math
+import cv2
+import numpy as np
+from hivisionai.hycv.face_tools import face_detect_mtcnn
+from hivisionai.hycv.utils import get_box_pro, CV2Bytes
+from hivisionai.hycv.vision import resize_image_esp, IDphotos_cut, add_background, calTime, resize_image_by_min, \
+    rotate_bound_4channels
+import onnxruntime
+from EulerZ import eulerZ
+from beautyPlugin import makeBeautiful
+from error import IDError
+from imageTransform import standard_photo_resize, hollowOutFix, get_modnet_matting, draw_picture_dots, detect_distance
+from layoutCreate import generate_layout_photo
+from move_image import move
+
+testImages = []
+
+
+class LinearFunction_TwoDots(object):
+    """
+    通过两个坐标点构建线性函数
+    """
+
+    def __init__(self, dot1, dot2):
+        self.d1 = dot1
+        self.d2 = dot2
+        self.mode = "normal"
+        if self.d2.x != self.d1.x:
+            self.k = (self.d2.y - self.d1.y) / max((self.d2.x - self.d1.x), 1)
+            self.b = self.d2.y - self.k * self.d2.x
+        else:
+            self.mode = "x=1"
+
+    def forward(self, input_, mode="x"):
+        if mode == "x":
+            if self.mode == "normal":
+                return self.k * input_ + self.b
+            else:
+                return 0
+        elif mode == "y":
+            if self.mode == "normal":
+                return (input_ - self.b) / self.k
+            else:
+                return self.d1.x
+
+    def forward_x(self, x):
+        if self.mode == "normal":
+            return self.k * x + self.b
+        else:
+            return 0
+
+    def forward_y(self, y):
+        if self.mode == "normal":
+            return (y - self.b) / self.k
+        else:
+            return self.d1.x
+
+
+class Coordinate(object):
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def __str__(self):
+        return "({}, {})".format(self.x, self.y)
+
+
+@calTime
+def face_number_and_angle_detection(input_image):
+    """
+    本函数的功能是利用机器学习算法计算图像中人脸的数目与关键点，并通过关键点信息来计算人脸在平面上的旋转角度。
+    当前人脸数目!=1时，将raise一个错误信息并终止全部程序。
+    Args:
+        input_image: numpy.array(3 channels)，用户上传的原图（经过了一些简单的resize）
+
+    Returns:
+        - dets: list，人脸定位信息(x1, y1, x2, y2)
+        - rotation: int，旋转角度，正数代表逆时针偏离，负数代表顺时针偏离
+        - landmark: list，人脸关键点信息
+    """
+
+    # 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)
+
+    faces, landmarks = face_detect_mtcnn(input_image)
+    face_num = len(faces)
+
+    # 排除不合人脸数目要求（必须是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_)
+
+    # 获得人脸定位坐标
+    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})
+
+    # 获取人脸定位坐标与关键点信息
+    dets = face_rectangle[0]
+    # landmark = landmarks[0]
+    #
+    # # 人脸旋转角度计算
+    # rotation = eulerZ(landmark)
+    # return dets, rotation, landmark
+    return dets
+
+@calTime
+def image_matting(input_image, params):
+    """
+    本函数的功能为全局人像抠图。
+    Args:
+        - input_image: numpy.array(3 channels)，用户原图
+
+    Returns:
+        - origin_png_image: numpy.array(4 channels)， 抠好的图
+    """
+
+    print("抠图采用本地模型")
+    origin_png_image = get_modnet_matting(input_image, sess=params["modnet"]["human_sess"])
+
+    origin_png_image = hollowOutFix(origin_png_image)  # 抠图洞洞修补
+    return origin_png_image
+
+
+@calTime
+def rotation_ajust(input_image, rotation, a, IS_DEBUG=False):
+    """
+    本函数的功能是根据旋转角对原图进行无损旋转，并返回结果图与附带信息。
+    Args:
+        - input_image: numpy.array(3 channels), 用户上传的原图（经过了一些简单的resize、美颜）
+        - rotation: float, 人的五官偏离"端正"形态的旋转角
+        - 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图旋转的结果图
+        - L1: CLassObject, 根据旋转点连线所构造函数
+        - L2: ClassObject, 根据旋转点连线所构造函数
+        - dotL3: ClassObject, 一个特殊裁切点的坐标
+        - clockwise: int, 表示照片是顺时针偏离还是逆时针偏离
+        - drawed_dots_image: numpy.array(3 channels), 在result_jpg_image上标定了4个旋转点的结果图，用于DEBUG模式
+    """
+
+    # Step1. 数据准备
+    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)
+
+    # Step3. 附带信息计算
+    nh, nw = result_jpg_image.shape[:2]  # 旋转后的新的长宽
+    clockwise = -1 if rotation < 0 else 1  # clockwise代表时针，即1为顺时针，-1为逆时针
+    # 如果逆时针偏离：
+    if rotation < 0:
+        p1 = Coordinate(0, int(w * sin))
+        p2 = Coordinate(int(w * cos), 0)
+        p3 = Coordinate(nw, int(h * cos))
+        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))
+
+    # 如果顺时针偏离：
+    else:
+        p1 = Coordinate(int(h * sin), 0)
+        p2 = Coordinate(nw, int(w * sin))
+        p3 = Coordinate(int(w * cos), nh)
+        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)])
+    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
+
+
+@calTime
+def face_number_detection_mtcnn(input_image):
+    """
+    本函数的功能是对旋转矫正的结果图进行基于MTCNN模型的人脸检测。
+    Args:
+        - input_image: numpy.array(3 channels), 旋转矫正(rotation_adjust)的3通道结果图
+
+    Returns:
+        - faces: list, 人脸检测的结果，包含人脸位置信息
+    """
+    # 如果图像的长或宽>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
+        if len(faces) == 1:
+            for item, param in enumerate(faces[0]):
+                faces[0][item] = param * 2
+        # 如果两次人脸检测结果有偏差，则默认缩放后图像的MTCNN检测存在误差，则将原图输入再做一次MTCNN（保险措施）
+        else:
+            faces, _ = face_detect_mtcnn(input_image, filter=True)
+    # 如果图像的长或宽<1500px，则直接进行MTCNN检测
+    else:
+        faces, _ = face_detect_mtcnn(input_image, filter=True)
+
+    return faces
+
+
+@calTime
+def cutting_rect_pan(x1, y1, x2, y2, width, height, L1, L2, L3, clockwise, standard_size):
+    """
+    本函数的功能是对旋转矫正结果图的裁剪框进行修正 ———— 解决"旋转三角形"现象。
+    Args:
+        - x1: int, 裁剪框左上角的横坐标
+        - y1: int, 裁剪框左上角的纵坐标
+        - x2: int, 裁剪框右下角的横坐标
+        - y2: int, 裁剪框右下角的纵坐标
+        - width: int, 待裁剪图的宽度
+        - height:int, 待裁剪图的高度
+        - L1: CLassObject, 根据旋转点连线所构造函数
+        - L2: CLassObject, 根据旋转点连线所构造函数
+        - L3: ClassObject, 一个特殊裁切点的坐标
+        - clockwise: int, 旋转时针状态
+        - standard_size: tuple, 标准照的尺寸
+
+    Returns:
+        - x1: int, 新的裁剪框左上角的横坐标
+        - y1: int, 新的裁剪框左上角的纵坐标
+        - x2: int, 新的裁剪框右下角的横坐标
+        - y2: int, 新的裁剪框右下角的纵坐标
+        - x_bias: int, 裁剪框横坐标方向上的计算偏置量
+        - y_bias: int, 裁剪框纵坐标方向上的计算偏置量
+    """
+    # 用于计算的裁剪框坐标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_bias = 0
+    y_bias = 0
+
+    # 如果顺时针偏转
+    if clockwise == 1:
+        if y2 > L1.forward_x(x1_std):
+            y_bias = int(-(y2_std - L1.forward_x(x1_std)))
+        if y2 > L2.forward_x(x2_std):
+            x_bias = int(-(x2_std - L2.forward_y(y2_std)))
+        x2 = x2_std + x_bias
+        if x1 < L3.x:
+            x1 = L3.x
+    # 如果逆时针偏转
+    else:
+        if y2 > L1.forward_x(x1_std):
+            x_bias = int(L1.forward_y(y2_std) - x1_std)
+        if y2 > L2.forward_x(x2_std):
+            y_bias = int(-(y2_std - L2.forward_x(x2_std)))
+        x1 = x1_std + x_bias
+        if x2 > L3.x:
+            x2 = L3.x
+
+    # 计算裁剪框的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])
+    y1 = y2 - new_cut_height
+
+    return x1, y1, x2, y2, x_bias, y_bias
+
+
+@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):
+    """
+    本函数的功能为进行证件照的自适应裁剪，自适应依据Setting.json的控制参数，以及输入图像的自身情况。
+    Args:
+        - faces: list, 人脸位置信息
+        - head_measure_ratio: float, 人脸面积与全图面积的期望比值
+        - 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个旋转点的图像
+        - align: bool, 是否图像做过旋转矫正
+        - IS_DEBUG: DEBUG模式开关
+        - top_distance_max: float, 头距离顶部的最大比例
+        - top_distance_min: float, 头距离顶部的最小比例
+
+    Returns:
+        - result_image_hd: numpy.array(4 channels), 高清照
+        - result_image_standard: numpy.array(4 channels), 标准照
+        - clothing_params: json, 换装配置参数，便于后续换装功能的使用
+
+    """
+    # Step0. 旋转参数准备
+    L1 = rotation_params["L1"]
+    L2 = rotation_params["L2"]
+    L3 = rotation_params["L3"]
+    clockwise = rotation_params["clockwise"]
+    drawed_image = rotation_params["drawed_image"]
+
+    # Step1. 准备人脸参数
+    face_rect = faces[0]
+    x, y = face_rect[0], face_rect[1]
+    w, h = face_rect[2] - x + 1, face_rect[3] - y + 1
+    height, width = origin_png_image.shape[:2]
+    width_height_ratio = standard_size[0] / standard_size[1]  # 高宽比
+
+    # Step2. 计算高级参数
+    face_center = (x + w / 2, y + h / 2)  # 面部中心坐标
+    face_measure = w * h  # 面部面积
+    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))  # 裁剪框大小
+
+    # 裁剪框的定位信息
+    x1 = int(face_center[0] - crop_size[1] / 2)
+    y1 = int(face_center[1] - crop_size[0] * head_height_ratio)
+    y2 = y1 + crop_size[0]
+    x2 = x1 + crop_size[1]
+
+    # Step3. 对于旋转矫正图片的裁切处理
+    # if align:
+    #     y_top_pre, _, _, _ = get_box_pro(origin_png_image.astype(np.uint8), model=2,
+    #                                      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)
+    #     # 这里设定一个拒绝判定条件，如果裁剪框切进了人脸检测框的话，就不进行旋转
+    #     if y1 > y_top_pre:
+    #         y2 = y2 - (y1 - y_top_pre)
+    #         y1 = y_top_pre
+    #         # 如何遇到裁剪到人脸的情况，则转为不旋转裁切
+    #     if x1 > x or x2 < (x + w) or y1 > y or y2 < (y + h):
+    #         return idphoto_cutting(faces, head_measure_ratio, standard_size, head_height_ratio, origin_png_image_pre,
+    #                                origin_png_image_pre, rotation_params, align=False, IS_DEBUG=False)
+    #
+    #     if y_bias != 0:
+    #         origin_png_image = origin_png_image[:y2, :]
+    #     if x_bias > 0:  # 逆时针
+    #         origin_png_image = origin_png_image[:, x1:]
+    #         if drawed_image is not None and IS_DEBUG:
+    #             drawed_x = x1
+    #         x = x - x1
+    #         x2 = x2 - x1
+    #         x1 = 0
+    #     else:  # 顺时针
+    #         origin_png_image = origin_png_image[:, :x2]
+    #
+    #     if drawed_image is not None and IS_DEBUG:
+    #         drawed_x = drawed_x if x_bias > 0 else 0
+    #         drawed_image = draw_picture_dots(drawed_image, [(x1 + drawed_x, y1), (x1 + drawed_x, y2),
+    #                                                         (x2 + drawed_x, y1), (x2 + drawed_x, y2)],
+    #                                          pen_color=(255, 0, 0))
+    #         testImages.append(["drawed_image", drawed_image])
+
+    # 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中人像的上下左右距离信息
+    if IS_DEBUG:
+        testImages.append(["firstCut", 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
+    else:
+        status_left_right = 0
+        cut_value_top = 0
+
+    """
+        检测人头顶与照片的顶部是否在合适的距离内：
+        - 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)
+
+    # 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)
+    if IS_DEBUG:
+        testImages.append(["result_image_pre", result_image])
+
+    # 换装参数准备
+    relative_x = x - (x1 + x_left)
+    relative_y = y - (y1 + cut_value_top + status_top * move_value)
+
+    # Step7. 当照片底部存在空隙时，下拉至底部
+    result_image, y_high = move(result_image.astype(np.uint8))
+    relative_y = relative_y + y_high  # 更新换装参数
+
+    # cv2.imwrite("./temp_image.png", result_image)
+
+    # 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]))
+
+    # 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
+    }
+
+    return result_image_hd, result_image_standard, clothing_params
+
+
+@calTime
+def debug_mode_process(testImages):
+    for item, (text, imageItem) in enumerate(testImages):
+        channel = imageItem.shape[2]
+        (height, width) = imageItem.shape[:2]
+        if channel == 4:
+            imageItem = add_background(imageItem, bgr=(255, 255, 255))
+            imageItem = np.uint8(imageItem)
+        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)
+        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)
+            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):
+    """
+    证件照制作主函数
+    Args:
+        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配置对象
+        top_distance_max: float, 头距离顶部的最大比例
+        top_distance_min: float, 头距离顶部的最小比例
+    Returns:
+        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
+    """
+
+    # 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
+
+    # Step1. 人脸检测
+    # dets, rotation, landmark = face_number_and_angle_detection(input_image)
+    # dets = face_number_and_angle_detection(input_image)
+
+    # Step2. 美颜
+    # if beauty:
+    #     input_image = makeBeautiful(input_image, landmark, 2, 2, 5, 4)
+
+    # Step3. 抠图
+    origin_png_image = image_matting(input_image, matting_params)
+    if mode == "只换底":
+        return origin_png_image, origin_png_image, None, None, None, None, None, None, 1
+
+    origin_png_image_pre = origin_png_image.copy()  # 备份一下现在抠图结果图，之后在iphoto_cutting函数有用
+
+    # Step4. 旋转矫正
+    # 如果旋转角不大于2, 则不做旋转
+    # if abs(rotation) <= 2:
+    #     align = False
+    # # 否则，进行旋转矫正
+    # if align:
+    #     input_image_candidate, origin_png_image_candidate, L1, L2, L3, clockwise, drawed_image \
+    #         = rotation_ajust(input_image, rotation, cv2.split(origin_png_image)[-1], IS_DEBUG=IS_DEBUG)  # 图像旋转
+    #
+    #     origin_png_image_pre = origin_png_image.copy()
+    #     input_image = input_image_candidate.copy()
+    #     origin_png_image = origin_png_image_candidate.copy()
+    #
+    #     rotation_params["L1"] = L1
+    #     rotation_params["L2"] = L2
+    #     rotation_params["L3"] = L3
+    #     rotation_params["clockwise"] = clockwise
+    #     rotation_params["drawed_image"] = drawed_image
+
+    # Step5. MTCNN人脸检测
+    faces = face_number_detection_mtcnn(input_image)
+
+    # Step6. 证件照自适应裁剪
+    face_num = len(faces)
+    # 报错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)
+
+    # 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
+
+
+if __name__ == "__main__":
+    HY_HUMAN_MATTING_WEIGHTS_PATH = "./hivision_modnet.onnx"
+    sess = onnxruntime.InferenceSession(HY_HUMAN_MATTING_WEIGHTS_PATH)
+
+    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)
+    cv2.imwrite("result_image_hd.png", result_image_hd)

hivision_modnet.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e0cb9a2a841b426dd0daf1a788ec398dab059bc039041d62b15636c0783bc56
+size 25888609

hivision_modnet.onnx.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e0cb9a2a841b426dd0daf1a788ec398dab059bc039041d62b15636c0783bc56
+size 25888609

hivisionai/app.py

@@ -0,0 +1,452 @@
+# -*- coding: utf-8 -*-
+
+"""
+@Time     : 2022/8/27 14:17
+@Author   : cuny
+@File     : app.py
+@Software : PyCharm
+@Introduce: 
+查看包版本等一系列操作
+"""
+import os
+import sys
+import json
+import shutil
+import zipfile
+import requests
+from argparse import ArgumentParser
+from importlib.metadata import version
+try:  # 加上这个try的原因在于本地环境和云函数端的import形式有所不同
+    from qcloud_cos import CosConfig
+    from qcloud_cos import CosS3Client
+except ImportError:
+    try:
+        from qcloud_cos_v5 import CosConfig
+        from qcloud_cos_v5 import CosS3Client
+        from qcloud_cos.cos_exception import CosServiceError
+    except ImportError:
+        raise ImportError("请下载腾讯云COS相关代码包:pip install cos-python-sdk-v5")
+
+
+class HivisionaiParams(object):
+    """
+    定义一些基本常量
+    """
+    # 文件所在路径
+    # 包名称
+    package_name = "HY-sdk"
+    # 腾讯云相关变量
+    region = "ap-beijing"
+    zip_key = "HY-sdk/"  # zip存储的云端文件夹路径，这里改了publish.yml也需要更改
+    # 云端用户配置，如果在cloud_config_save不存在，就需要下载此文件
+    user_url = "https://hy-sdk-config-1305323352.cos.ap-beijing.myqcloud.com/sdk-user/user_config.json"
+    bucket = "cloud-public-static-1306602019"
+    # 压缩包类型
+    file_format = ".zip"
+    # 下载路径（.hivisionai文件夹路径）
+    download_path = os.path.expandvars('$HOME')
+    # zip文件、zip解压缩文件的存放路径
+    save_folder = f"{os.path.expandvars('$HOME')}/.hivisionai/sdk"
+    # 腾讯云配置文件存放路径
+    cloud_config_save = f"{os.path.expandvars('$HOME')}/.hivisionai/user_config.json"
+    # 项目路径
+    hivisionai_path = os.path.dirname(os.path.dirname(__file__))
+    # 使用hivisionai的路径
+    getcwd = os.getcwd()
+    # HY-func的依赖配置
+    # 每个依赖会包含三个参数，保存路径（save_path，相对于HY_func的路径）、下载url（url）
+    functionDependence = {
+        "configs":  [
+            # --------- 配置文件部分
+            # _lib
+            {
+                "url": "https://hy-sdk-config-1305323352.cos.ap-beijing.myqcloud.com/hy-func/_lib/config/aliyun-human-matting-api.json",
+                "save_path": "_lib/config/aliyun-human-matting-api.json"
+            },
+            {
+                "url": "https://hy-sdk-config-1305323352.cos.ap-beijing.myqcloud.com/hy-func/_lib/config/megvii-face-plus-api.json",
+                "save_path": "_lib/config/megvii-face-plus-api.json"
+            },
+            {
+                "url": "https://hy-sdk-config-1305323352.cos.ap-beijing.myqcloud.com/hy-func/_lib/config/volcano-face-change-api.json",
+                "save_path": "_lib/config/volcano-face-change-api.json"
+            },
+            # _service
+            {
+                "url": "https://hy-sdk-config-1305323352.cos.ap-beijing.myqcloud.com/hy-func/_service/config/func_error_conf.json",
+                "save_path": "_service/utils/config/func_error_conf.json"
+            },
+            {
+                "url": "https://hy-sdk-config-1305323352.cos.ap-beijing.myqcloud.com/hy-func/_service/config/service_config.json",
+                "save_path": "_service/utils/config/service_config.json"
+            },
+            # --------- 模型部分
+            # 模型部分存储在Notion文档当中
+            # https://www.notion.so/HY-func-cc6cc41ba6e94b36b8fa5f5d67d1683f
+        ],
+        "weights": "https://www.notion.so/HY-func-cc6cc41ba6e94b36b8fa5f5d67d1683f"
+    }
+
+
+class HivisionaiUtils(object):
+    """
+    本类为一些基本工具类，包含代码复用相关内容
+    """
+    @staticmethod
+    def get_client():
+        """获取cos客户端对象"""
+        def get_secret():
+            # 首先判断cloud_config_save下是否存在
+            if not os.path.exists(HivisionaiParams.cloud_config_save):
+                print("Downloading user_config...")
+                resp = requests.get(HivisionaiParams.user_url)
+                open(HivisionaiParams.cloud_config_save, "wb").write(resp.content)
+            config = json.load(open(HivisionaiParams.cloud_config_save, "r"))
+            return config["secret_id"], config["secret_key"]
+        # todo 接入HY-Auth-Sync
+        secret_id, secret_key = get_secret()
+        return CosS3Client(CosConfig(Region=HivisionaiParams.region, Secret_id=secret_id, Secret_key=secret_key))
+
+    def get_all_versions(self):
+        """获取云端的所有版本号"""
+        def getAllVersion_base():
+            """
+            返回cos存储桶内部的某个文件夹的内部名称
+            ps:如果需要修改默认的存储桶配置，请在代码运行的时候加入代码 s.bucket = 存储桶名称 （s是对象实例）
+            返回的内容存储在response["Content"]，不过返回的数据大小是有限制的，具体内容还是请看官方文档。
+            Returns:
+                [版本列表]
+            """
+            resp = client.list_objects(
+                Bucket=HivisionaiParams.bucket,
+                Prefix=HivisionaiParams.zip_key,
+                Marker=marker
+            )
+            versions_list.extend([x["Key"].split("/")[-1].split(HivisionaiParams.file_format)[0] for x in resp["Contents"] if int(x["Size"]) > 0])
+            if resp['IsTruncated'] == 'false':  # 接下来没有数据了,就退出
+                return ""
+            else:
+                return resp['NextMarker']
+        client = self.get_client()
+        marker = ""
+        versions_list = []
+        while True:  # 轮询
+            try:
+                marker = getAllVersion_base()
+            except KeyError as e:
+                print(e)
+                raise
+            if len(marker) == 0:  # 没有数据了
+                break
+        return versions_list
+
+    def get_newest_version(self):
+        """获取最新的版本号"""
+        versions_list = self.get_all_versions()
+        # reverse=True，降序
+        versions_list.sort(key=lambda x: int(x.split(".")[-1]), reverse=True)
+        versions_list.sort(key=lambda x: int(x.split(".")[-2]), reverse=True)
+        versions_list.sort(key=lambda x: int(x.split(".")[-3]), reverse=True)
+        return versions_list[0]
+
+    def download_version(self, v):
+        """
+        在存储桶中下载文件，将下载好的文件解压至本地
+        Args:
+            v: 版本号，x.x.x
+
+        Returns:
+            None
+        """
+        file_name = v + HivisionaiParams.file_format
+        client = self.get_client()
+        print(f"Download to {HivisionaiParams.save_folder}...")
+        try:
+            resp = client.get_object(HivisionaiParams.bucket, HivisionaiParams.zip_key + "/" + file_name)
+            contents = resp["Body"].get_raw_stream().read()
+        except CosServiceError:
+            print(f"[{file_name}.zip] does not exist, please check your version!")
+            sys.exit()
+        if not os.path.exists(HivisionaiParams.save_folder):
+            os.makedirs(HivisionaiParams.save_folder)
+        open(os.path.join(HivisionaiParams.save_folder, file_name), "wb").write(contents)
+        print("Download success!")
+
+    @staticmethod
+    def download_dependence(path=None):
+        """
+        一键下载HY-sdk所需要的所有依赖，需要注意的是，本方法必须在运行pip install之后使用（运行完pip install之后才会出现hivisionai文件夹）
+        Args:
+            path: 文件路径，精确到hivisionai文件夹的上一个目录，如果为None，则默认下载到python环境下hivisionai安装的目录
+
+        Returns:
+            下载相应内容到指定位置
+        """
+        # print("指定的下载路径：", path)  # 此时在path路径下必然存在一个hivisionai文件夹
+        # print("系统安装的hivisionai库的路径:", HivisionaiParams.hivisionai_path)
+        print("Dependence downloading...")
+        if path is None:
+            path = HivisionaiParams.hivisionai_path
+        # ----------------下载mtcnn模型文件
+        mtcnn_path = os.path.join(path, "hivisionai/hycv/mtcnn_onnx/weights")
+        base_url = "https://linimages.oss-cn-beijing.aliyuncs.com/"
+        onnx_files = ["pnet.onnx",  "rnet.onnx", "onet.onnx"]
+        print(f"Downloading mtcnn model in {mtcnn_path}")
+        if not os.path.exists(mtcnn_path):
+            os.mkdir(mtcnn_path)
+        for onnx_file in onnx_files:
+            if not os.path.exists(os.path.join(mtcnn_path, onnx_file)):
+                # download onnx model
+                onnx_url = base_url + onnx_file
+                print("Downloading Onnx Model in:", onnx_url)
+                r = requests.get(onnx_url, stream=True)
+                if r.status_code == 200:
+                    open(os.path.join(mtcnn_path, onnx_file), 'wb').write(r.content)  # 将内容写入文件
+                    print(f"Download finished -- {onnx_file}")
+                del r
+        # ----------------
+        print("Dependence download finished...")
+
+
+class HivisionaiApps(object):
+    """
+    本类为app对外暴露的接口，为了代码规整性，这里使用类来对暴露接口进行调整
+    """
+    @staticmethod
+    def show_cloud_version():
+        """查看在cos中的所有HY-sdk版本"""
+        print("Connect to COS...")
+        versions_list = hivisionai_utils.get_all_versions()
+        # reverse=True，降序
+        versions_list.sort(key=lambda x: int(x.split(".")[-1]), reverse=True)
+        versions_list.sort(key=lambda x: int(x.split(".")[-2]), reverse=True)
+        versions_list.sort(key=lambda x: int(x.split(".")[-3]), reverse=True)
+        if len(versions_list) == 0:
+            print("There is no version currently, please release it first!")
+            sys.exit()
+        versions = "The currently existing versions (Keep 10): \n"
+        for i, v in enumerate(versions_list):
+            versions += str(v) + " "
+            if i == 9:
+                break
+        print(versions)
+
+    @staticmethod
+    def upgrade(v: str, enforce: bool = False, save_cached: bool = False):
+        """
+        自动升级HY-sdk到指定版本
+        Args:
+            v: 指定的版本号，格式为x.x.x
+            enforce: 是否需要强制执行更新命令
+            save_cached: 是否保存下载的wheel文件，默认为否
+        Returns:
+            None
+        """
+        def check_format():
+            # noinspection PyBroadException
+            try:
+                major, minor, patch = v.split(".")
+                int(major)
+                int(minor)
+                int(patch)
+            except Exception as e:
+                print(f"Illegal version number!\n{e}")
+            pass
+        print("Upgrading, please wait a moment...")
+        if v == "-1":
+            v = hivisionai_utils.get_newest_version()
+        # 检查format的格式
+        check_format()
+        if v == version(HivisionaiParams.package_name) and not enforce:
+            print(f"Current version: {v} already exists, skip installation.")
+            sys.exit()
+        hivisionai_utils.download_version(v)
+        # 下载完毕（下载至save_folder），解压文件
+        target_zip = os.path.join(HivisionaiParams.save_folder, f"{v}.zip")
+        assert zipfile.is_zipfile(target_zip), "Decompression failed, and the target was not a zip file."
+        new_dir = target_zip.replace('.zip', '')  # 解压的文件名
+        if os.path.exists(new_dir):  # 判断文件夹是否存在
+            shutil.rmtree(new_dir)
+        os.mkdir(new_dir)  # 新建文件夹
+        f = zipfile.ZipFile(target_zip)
+        f.extractall(new_dir)  # 提取zip文件
+        print("Decompressed, begin to install...")
+        os.system(f'pip3 install {os.path.join(new_dir, "**.whl")}')
+        # 开始自动下载必要的模型依赖
+        hivisionai_utils.download_dependence()
+        # 安装完毕，如果save_cached为真，删除"$HOME/.hivisionai/sdk"内部的所有文件元素
+        if save_cached is True:
+            os.system(f'rm -rf {HivisionaiParams.save_folder}/**')
+
+    @staticmethod
+    def export(path):
+        """
+        输出最新版本的文件到命令运行的path目录
+        Args:
+            path: 用户输入的路径
+
+        Returns:
+            输出最新的hivisionai到path目录
+        """
+        # print(f"当前路径: {os.path.join(HivisionaiParams.getcwd, path)}")
+        # print(f"文件路径: {os.path.dirname(__file__)}")
+        export_path = os.path.join(HivisionaiParams.getcwd, path)
+        # 判断输出路径存不存在，如果不存在，就报错
+        assert os.path.exists(export_path), f"{export_path} dose not Exists!"
+        v = hivisionai_utils.get_newest_version()
+        # 下载文件到.hivisionai/sdk当中
+        hivisionai_utils.download_version(v)
+        # 下载完毕（下载至save_folder），解压文件
+        target_zip = os.path.join(HivisionaiParams.save_folder, f"{v}.zip")
+        assert zipfile.is_zipfile(target_zip), "Decompression failed, and the target was not a zip file."
+        new_dir = os.path.basename(target_zip.replace('.zip', ''))  # 解压的文件名
+        new_dir = os.path.join(export_path, new_dir)  # 解压的文件路径
+        if os.path.exists(new_dir):  # 判断文件夹是否存在
+            shutil.rmtree(new_dir)
+        os.mkdir(new_dir)  # 新建文件夹
+        f = zipfile.ZipFile(target_zip)
+        f.extractall(new_dir)  # 提取zip文件
+        print("Decompressed, begin to export...")
+        # 强制删除bin/hivisionai和hivisionai/以及HY_sdk-**
+        bin_path = os.path.join(export_path, "bin")
+        hivisionai_path = os.path.join(export_path, "hivisionai")
+        sdk_path = os.path.join(export_path, "HY_sdk-**")
+        os.system(f"rm -rf {bin_path} {hivisionai_path} {sdk_path}")
+        # 删除完毕，开始export
+        os.system(f'pip3 install {os.path.join(new_dir, "**.whl")} -t {export_path}')
+        hivisionai_utils.download_dependence(export_path)
+        # 将下载下来的文件夹删除
+        os.system(f'rm -rf {target_zip} && rm -rf {new_dir}')
+        print("Done.")
+
+    @staticmethod
+    def hy_func_init(force):
+        """
+        在HY-func目录下使用hivisionai --init，可以自动将需要的依赖下载到指定位置
+        不过对于比较大的模型——修复模型而言，需要手动下载
+        Args:
+            force: 如果force为True，则会强制重新下载所有的内容，包括修复模型这种比较大的模型
+        Returns:
+            程序执行完毕，会将一些必要的依赖也下载完毕
+        """
+        cwd = HivisionaiParams.getcwd
+        # 判断当前文件夹是否是HY-func
+        dirName = os.path.basename(cwd)
+        assert dirName == "HY-func", "请在正确的文件目录下初始化HY-func!"
+        # 需要下载的内容会存放在HivisionaiParams的functionDependence���量下
+        functionDependence = HivisionaiParams.functionDependence
+        # 下载配置文件
+        configs = functionDependence["configs"]
+        print("正在下载配置文件...")
+        for config in configs:
+            if not force and os.path.exists(config['save_path']):
+                print(f"[pass]: {os.path.basename(config['url'])}")
+                continue
+            print(f"[Download]: {config['url']}")
+            resp = requests.get(config['url'])
+            # json文件存储在text区域，但是其他的不一定
+            open(os.path.join(cwd, config['save_path']), 'w').write(resp.text)
+        # 其他文件，提示访问notion文档
+        print(f"[NOTICE]: 一切准备就绪，请访问下面的文档下载剩下的模型文件:\n{functionDependence['weights']}")
+
+    @staticmethod
+    def hy_func_deploy(functionName: str = None, functionPath: str = None):
+        """
+        在HY-func目录下使用此命令，并且随附功能函数的名称，就可以将HY-func的部署版放到桌面上
+        但是需要注意的是，本方式不适合修复功能使用，修复功能依旧需要手动制作镜像
+        Args:
+            functionName: 功能函数名称
+            functionPath: 需要注册的HY-func路径
+
+        Returns:
+            程序执行完毕，桌面会出现一个同名文件夹
+        """
+        # 为了代码撰写的方便，这里仅仅把模型文件删除，其余配置文件保留
+        # 为了实现在任意位置输入hivisionai --deploy funcName都能成功，在使用前需要在.hivisionai/user_config.json中注册
+        # print(functionName, functionPath)
+        if functionPath is not None:
+            # 更新/添加路径
+            # functionPath为相对于使用路径的路径
+            assert os.path.basename(functionPath) == "HY-func", "所指向路径非HY-func!"
+            func_path = os.path.join(HivisionaiParams.getcwd, functionPath)
+            assert os.path.join(func_path), f"路径不存在: {func_path}"
+            # functionPath的路径写到user_config当中
+            user_config = json.load(open(HivisionaiParams.cloud_config_save, 'rb'))
+            user_config["func_path"] = func_path
+            open(HivisionaiParams.cloud_config_save, 'w').write(json.dumps(user_config))
+            print("HY-func全局路径保存成功!")
+        try:
+            user_config = json.load(open(HivisionaiParams.cloud_config_save, 'rb'))
+            func_path = user_config['func_path']
+        except KeyError:
+            return print("请先使用-p命令注册全局HY-func路径!")
+        # 此时func_path必然存在
+        # print(os.listdir(func_path))
+        assert functionName in os.listdir(func_path), functionName + "功能不存在!"
+        func_path_deploy = os.path.join(func_path, functionName)
+        # 开始复制文件到指定目录
+        # 我们默认移动到Desktop目录下，如果没有此目录，需要先创建一个
+        target_dir = os.path.join(HivisionaiParams.download_path, "Desktop")
+        assert os.path.exists(target_dir), target_dir + "文件路径不存在,你需要先创建一下!"
+        # 开始移动
+        target_dir = os.path.join(target_dir, functionName)
+        print("正在复制需要部署的文件...")
+        os.system(f"rm -rf {target_dir}")
+        os.system(f'cp -rf {func_path_deploy} {target_dir}')
+        os.system(f"cp -rf {os.path.join(func_path, '_lib')} {target_dir}")
+        os.system(f"cp -rf {os.path.join(func_path, '_service')} {target_dir}")
+        # 生成最新的hivisionai
+        print("正在生成hivisionai代码包...")
+        os.system(f'hivisionai -t {target_dir}')
+        # 移动完毕，删除模型文件
+        print("移动完毕，正在删除不需要的文件...")
+        # 模型文件
+        os.system(f"rm -rf {os.path.join(target_dir, '_lib', 'weights', '**')}")
+        # hivisionai生成时的多余文件
+        os.system(f"rm -rf {os.path.join(target_dir, 'bin')} {os.path.join(target_dir, 'HY_sdk**')}")
+        print("部署文件生成成功，你可以开始部署了!")
+
+
+hivisionai_utils = HivisionaiUtils()
+
+
+def entry_point():
+    parser = ArgumentParser()
+    # 查看版本号
+    parser.add_argument("-v", "--version", action="store_true", help="View the current HY-sdk version, which does not represent the final cloud version.")
+    # 自动更新
+    parser.add_argument("-u", "--upgrade", nargs='?', const="-1", type=str, help="Automatically update HY-sdk to the latest version")
+    # 查找云端的HY-sdk版本
+    parser.add_argument("-l", "--list", action="store_true", help="Find HY-sdk versions of the cloud, and keep up to ten")
+    # 下载云端的版本到本地路径
+    parser.add_argument("-t", "--export", nargs='?', const="./", help="Add a path parameter to automatically download the latest version of sdk to this path. If there are no parameters, the default is the current path")
+    # 强制更新附带参数，当一个功能需要强制执行一遍的时候，需要附带此参数
+    parser.add_argument("-f", "--force", action="store_true", help="Enforcement of other functions, execution of a single parameter is meaningless")
+    # 初始化HY-func
+    parser.add_argument("--init", action="store_true", help="Initialization HY-func")
+    # 部署HY-func
+    parser.add_argument("-d", "--deploy", nargs='?', const="-1", type=str, help="Deploy HY-func")
+    # 涉及注册一些自定义内容的时候，需要附带此参数，并写上自定义内容
+    parser.add_argument("-p", "--param", nargs='?', const="-1", type=str, help="When registering some custom content, you need to attach this parameter and write the custom content.")
+    args = parser.parse_args()
+    if args.version:
+        print(version(HivisionaiParams.package_name))
+        sys.exit()
+    if args.upgrade:
+        HivisionaiApps.upgrade(args.upgrade, args.force)
+        sys.exit()
+    if args.list:
+        HivisionaiApps.show_cloud_version()
+        sys.exit()
+    if args.export:
+        HivisionaiApps.export(args.export)
+        sys.exit()
+    if args.init:
+        HivisionaiApps.hy_func_init(args.force)
+        sys.exit()
+    if args.deploy:
+        HivisionaiApps.hy_func_deploy(args.deploy, args.param)
+
+
+if __name__ == "__main__":
+    entry_point()

hivisionai/hyService/cloudService.py

@@ -0,0 +1,406 @@
+"""
+焕影小程序功能服务端的基本工具函数,以类的形式封装
+"""
+try:  # 加上这个try的原因在于本地环境和云函数端的import形式有所不同
+    from qcloud_cos import CosConfig
+    from qcloud_cos import CosS3Client
+except ImportError:
+    try:
+        from qcloud_cos_v5 import CosConfig
+        from qcloud_cos_v5 import CosS3Client
+    except ImportError:
+        raise ImportError("请下载腾讯云COS相关代码包:pip install cos-python-sdk-v5")
+import requests
+import datetime
+import json
+from .error import ProcessError
+import os
+local_path_ = os.path.dirname(__file__)
+
+
+class GetConfig(object):
+    @staticmethod
+    def hy_sdk_client(Id:str, Key:str):
+        # 从cos中寻找文件
+        REGION: str = 'ap-beijing'
+        TOKEN = None
+        SCHEME: str = 'https'
+        BUCKET: str = 'hy-sdk-config-1305323352'
+        client_config = CosConfig(Region=REGION,
+                                  SecretId=Id,
+                                  SecretKey=Key,
+                                  Token=TOKEN,
+                                  Scheme=SCHEME)
+        return CosS3Client(client_config), BUCKET
+
+    def load_json(self, path:str, default_download=False):
+        try:
+            if os.path.isdir(path):
+                raise ProcessError("请输入具体的配置文件路径,而非文件夹!")
+            if default_download is True:
+                print(f"\033[34m 默认强制重新下载配置文件...\033[0m")
+                raise FileNotFoundError
+            with open(path) as f:
+                config = json.load(f)
+                return config
+        except FileNotFoundError:
+            dir_name = os.path.dirname(path)
+            try:
+                os.makedirs(dir_name)
+            except FileExistsError:
+                pass
+            base_name = os.path.basename(path)
+            print(f"\033[34m 正在从COS中下载配置文件...\033[0m")
+            print(f"\033[31m 请注意,接下来会在{dir_name}路径下生成文件{base_name}...\033[0m")
+            Id = input("请输入SecretId:")
+            Key = input("请输入SecretKey:")
+            client, bucket = self.hy_sdk_client(Id, Key)
+            data_bytes = client.get_object(Bucket=bucket,Key=base_name)["Body"].get_raw_stream().read()
+            data = json.loads(data_bytes.decode("utf-8"))
+            # data["SecretId"] = Id  # 未来可以把这个加上
+            # data["SecretKey"] = Key
+            with open(path, "w") as f:
+                data_str = json.dumps(data, ensure_ascii=False)
+                # 如果 ensure_ascii 是 true (即默认值),输出保证将所有输入的非 ASCII 字符转义。
+                # 如果 ensure_ascii 是 false，这些字符会原样输出。
+                f.write(data_str)
+                f.close()
+            print(f"\033[32m 配置文件保存成功\033[0m")
+            return data
+        except json.decoder.JSONDecodeError:
+            print(f"\033[31m WARNING: 配置文件为空!\033[0m")
+            return {}
+
+    def load_file(self, cloud_path:str, local_path:str):
+        """
+        从COS中下载文件到本地,本函数将会被默认执行的,在使用的时候建议加一些限制.
+        :param cloud_path: 云端的文件路径
+        :param local_path: 将云端文件保存在本地的路径
+        """
+        if os.path.isdir(cloud_path):
+            raise ProcessError("请输入具体的云端文件路径,而非文件夹!")
+        if os.path.isdir(local_path):
+            raise ProcessError("请输入具体的本地文件路径,而非文件夹!")
+        dir_name = os.path.dirname(local_path)
+        base_name = os.path.basename(local_path)
+        try:
+            os.makedirs(dir_name)
+        except FileExistsError:
+            pass
+        cloud_name = os.path.basename(cloud_path)
+        print(f"\033[31m 请注意,接下来会在{dir_name}路径下生成文件{base_name}\033[0m")
+        Id = input("请输入SecretId:")
+        Key = input("请输入SecretKey:")
+        client, bucket = self.hy_sdk_client(Id, Key)
+        print(f"\033[34m 正在从COS中下载文件: {cloud_name}, 此过程可能耗费一些时间...\033[0m")
+        data_bytes = client.get_object(Bucket=bucket,Key=cloud_path)["Body"].get_raw_stream().read()
+        # data["SecretId"] = Id  # 未来可以把这个加上
+        # data["SecretKey"] = Key
+        with open(local_path, "wb") as f:
+            # 如果 ensure_ascii 是 true (即默认值),输出保证将所有输入的非 ASCII 字符转义。
+            # 如果 ensure_ascii 是 false，这些字符会原样输出。
+            f.write(data_bytes)
+            f.close()
+        print(f"\033[32m 文件保存成功\033[0m")
+
+
+class CosConf(GetConfig):
+    """
+    从安全的角度出发,将一些默认配置文件上传至COS中,接下来使用COS和它的子类的时候,在第一次使用时需要输入Cuny给的id和key
+    用于连接cos存储桶,下载配置文��.
+    当然,在service_default_download = False的时候,如果在运行路径下已经有conf/service_config.json文件了,
+    那么就不用再次下载了,也不用输入id和key
+    事实上这只需要运行一次,因为配置文件将会被下载至源码文件夹中
+    如果要自定义路径,请在继承的子类中编写__init__函数,将service_path定向到指定路径
+    """
+    def __init__(self) -> None:
+        # 下面这些参数是类的共享参数
+        self.__SECRET_ID: str = None  # 服务的id
+        self.__SECRET_KEY: str = None  # 服务的key
+        self.__REGION: str = None  # 服务的存储桶地区
+        self.__TOKEN: str = None  # 服务的token,目前一直是None
+        self.__SCHEME: str = None  # 服务的访问协议,默认实际上是https
+        self.__BUCKET: str = None  # 服务的存储桶
+        self.__SERVICE_CONFIG: dict = None  # 服务的配置文件
+        self.service_path: str = f"{local_path_}/conf/service_config.json"
+        # 配置文件路径,默认是函数运行的路径下的conf文件夹
+        self.service_default_download = False  # 是否在每次访问配置的时候都重新下载文件
+
+    @property
+    def service_config(self):
+        if self.__SERVICE_CONFIG is None or self.service_default_download is True:
+            self.__SERVICE_CONFIG = self.load_json(self.service_path, self.service_default_download)
+        return self.__SERVICE_CONFIG
+
+    @property
+    def client(self):
+        client_config = CosConfig(Region=self.region,
+                                  SecretId=self.secret_id,
+                                  SecretKey=self.secret_key,
+                                  Token=self.token,
+                                  Scheme=self.scheme)
+        return CosS3Client(client_config)
+
+    def get_key(self, key:str):
+        try:
+            data = self.service_config[key]
+            if data == "None":
+                return None
+            else:
+                return data
+        except KeyError:
+            print(f"\033[31m没有对应键值{key},默认返回None\033[0m")
+            return None
+
+    @property
+    def secret_id(self):
+        if self.__SECRET_ID is None:
+            self.__SECRET_ID = self.get_key("SECRET_ID")
+        return self.__SECRET_ID
+
+    @secret_id.setter
+    def secret_id(self, value:str):
+        self.__SECRET_ID = value
+
+    @property
+    def secret_key(self):
+        if self.__SECRET_KEY is None:
+            self.__SECRET_KEY = self.get_key("SECRET_KEY")
+        return self.__SECRET_KEY
+
+    @secret_key.setter
+    def secret_key(self, value:str):
+        self.__SECRET_KEY = value
+
+    @property
+    def region(self):
+        if self.__REGION is None:
+            self.__REGION = self.get_key("REGION")
+        return self.__REGION
+
+    @region.setter
+    def region(self, value:str):
+        self.__REGION = value
+
+    @property
+    def token(self):
+        # if self.__TOKEN is None:
+        #     self.__TOKEN = self.get_key("TOKEN")
+        # 这里可以注释掉
+        return self.__TOKEN
+
+    @token.setter
+    def token(self, value:str):
+        self.__TOKEN= value
+
+    @property
+    def scheme(self):
+        if self.__SCHEME is None:
+            self.__SCHEME = self.get_key("SCHEME")
+        return self.__SCHEME
+
+    @scheme.setter
+    def scheme(self, value:str):
+        self.__SCHEME = value
+
+    @property
+    def bucket(self):
+        if self.__BUCKET is None:
+            self.__BUCKET = self.get_key("BUCKET")
+        return self.__BUCKET
+
+    @bucket.setter
+    def bucket(self, value):
+        self.__BUCKET = value
+
+    def downloadFile_COS(self, key, bucket:str=None, if_read:bool=False):
+        """
+        从COS下载对象(二进制数据), 如果下载失败就返回None
+        """
+        CosBucket = self.bucket if bucket is None else bucket
+        try:
+            # 将本类的Debug继承给抛弃了
+            # self.debug_print(f"Download from {CosBucket}", font_color="blue")
+            obj = self.client.get_object(
+                Bucket=CosBucket,
+                Key=key
+            )
+            if if_read is True:
+                data = obj["Body"].get_raw_stream().read()  # byte
+                return data
+            else:
+                return obj
+        except Exception as e:
+            print(f"\033[31m下载失败! 错误描述:{e}\033[0m")
+            return None
+
+    def showFileList_COS_base(self, key, bucket, marker:str=""):
+        """
+        返回cos存储桶内部的某个文件夹的内部名称
+        :param key: cos云端的存储路径
+        :param bucket: cos存储桶名称，如果没指定名称（None）就会寻找默认的存储桶
+        :param marker: 标记,用于记录上次查询到哪里了
+        ps:如果需要修改默认的存储桶配置，请在代码运行的时候加入代码 s.bucket = 存储桶名称 （s是对象实例）
+        返回的内容存储在response["Content"]，不过返回的��据大小是有限制的，具体内容还是请看官方文档。
+        """
+        response = self.client.list_objects(
+            Bucket=bucket,
+            Prefix=key,
+            Marker=marker
+        )
+        return response
+
+    def showFileList_COS(self, key, bucket:str=None)->list:
+        """
+        实现查询存储桶中所有对象的操作，因为cos的sdk有返回数据包大小的限制，所以我们需要进行一定的改动
+        """
+        marker = ""
+        file_list = []
+        CosBucket = self.bucket if bucket is None else bucket
+        while True:  # 轮询
+            response = self.showFileList_COS_base(key, CosBucket, marker)
+            try:
+                file_list.extend(response["Contents"])
+            except KeyError as e:
+                print(e)
+                raise
+            if response['IsTruncated'] == 'false':  # 接下来没有数据了,就退出
+                break
+            marker = response['NextMarker']
+        return file_list
+
+    def uploadFile_COS(self, buffer, key, bucket:str=None):
+        """
+        从COS上传数据,需要注意的是必须得是二进制文件
+        """
+        CosBucket = self.bucket if bucket is None else bucket
+        try:
+            self.client.put_object(
+                Bucket=CosBucket,
+                Body=buffer,
+                Key=key
+            )
+            return True
+        except Exception as e:
+            print(e)
+            return False
+
+
+class FuncDiary(CosConf):
+    filter_dict = {"60a5e13da00e6e0001fd53c8": "Cuny",
+                   "612c290f3a9af4000170faad": "守望平凡",
+                   "614de96e1259260001506d6c": "林泽毅-焕影一新"}
+
+    def __init__(self, func_name: str, uid: str, error_conf_path: str = f"{local_path_}/conf/func_error_conf.json"):
+        """
+        日志类的实例化
+        Args:
+            func_name: 功能名称，影响了日志投递的路径
+        """
+        super().__init__()
+        # 配置文件路径,默认是函数运行的路径下的conf文件夹
+        self.service_path: str = os.path.join(os.path.dirname(error_conf_path), "service_config.json")
+        self.error_dict = self.load_json(path=error_conf_path)
+        self.__up: str = f"wx/invokeFunction_c/{datetime.datetime.now().strftime('%Y/%m/%d/%H')}/{func_name}/"
+        self.func_name: str = func_name
+        # 下面这个属性是的日志名称的前缀
+        self.__start_time = datetime.datetime.now().timestamp()
+        h_point = datetime.datetime.strptime(datetime.datetime.now().strftime('%Y/%m/%d/%H'), '%Y/%m/%d/%H')
+        h_point_timestamp = h_point.timestamp()
+        self.__prefix = int(self.__start_time - h_point_timestamp).__str__() + "_"
+        self.__uid = uid
+        self.__diary = None
+
+    def __str__(self):
+        return f"<{self.func_name}> DIARY for {self.__uid}"
+
+    @property
+    def content(self):
+        return self.__diary
+
+    @content.setter
+    def content(self, value: str):
+        if not isinstance(value, dict):
+            raise TypeError("content 只能是字典！")
+        if "status" in value:
+            raise KeyError("status字段已被默认占用，请在日志信息中更换字段名称!")
+        if self.__diary is None:
+            self.__diary = value
+        else:
+            raise PermissionError("为了减小日志对整体代码的影响，<content>只能被覆写一次！")
+
+    def uploadDiary_COS(self, status_id: str, suffix: str = "", bucket: str = "hy-hcy-data-logs-1306602019"):
+        if self.__diary is None:
+            self.__diary = {"status": self.error_dict[status_id]}
+        if status_id == "0000":
+            self.__up += f"True/{self.__uid}/"
+        else:
+            self.__up += f"False/{self.__uid}/"
+        interval = int(10 * (datetime.datetime.now().timestamp() - self.__start_time))
+        prefix = self.__prefix + status_id + "_" + interval.__str__()
+        self.__diary["status"] = self.error_dict[status_id]
+        name = prefix + "_" + suffix if len(suffix) != 0 else prefix
+        self.uploadFile_COS(buffer=json.dumps(self.__diary), key=self.__up + name, bucket=bucket)
+        print(f"{self}上传成功.")
+
+
+class ResponseWebSocket(CosConf):
+    # 网关推送地址
+    __HOST:str = None
+    @property
+    def sendBackHost(self):
+        if self.__HOST is None:
+            self.__HOST = self.get_key("HOST")
+        return self.__HOST
+
+    @sendBackHost.setter
+    def sendBackHost(self, value):
+        self.__HOST = value
+
+    def sendMsg_toWebSocket(self, message,connectionID:str = None):
+        if connectionID is not None:
+            retmsg = {'websocket': {}}
+            retmsg['websocket']['action'] = "data send"
+            retmsg['websocket']['secConnectionID'] = connectionID
+            retmsg['websocket']['dataType'] = 'text'
+            retmsg['websocket']['data'] = json.dumps(message)
+            requests.post(self.sendBackHost, json=retmsg)
+            print("send success!")
+        else:
+            pass
+
+    @staticmethod
+    def create_Msg(status, msg):
+        """
+        本方法用于创建一个用于发送到WebSocket客户端的数据
+        输入的信息部分,需要有如下几个参数:
+        1. id,固定为"return-result"
+        2. status,如果输入为1则status=true, 如果输入为-1则status=false
+        3. obj_key, 图片的云端路径, 这是输入的msg本身自带的
+        """
+        msg['status'] = "false" if status == -1 else 'true'  # 其实最好还是用bool
+        msg['id'] = "async-back-msg"
+        msg['type'] = "funcType"
+        msg["format"] = "imageType"
+        return msg
+
+
+# 功能服务类
+class Service(ResponseWebSocket):
+    """
+    服务的主函数,封装了cos上传/下载功能以及与api网关的一键通讯
+    将类的实例变成一个可被调用的对象,在服务运行的时候,只需要运行该对象即可
+    当然,因为是类,所以支持继承和修改
+    """
+    @classmethod
+    def process(cls, *args, **kwargs):
+        """
+        处理函数,在使用的时候请将之重构
+        """
+        pass
+
+    @classmethod
+    def __call__(cls, *args, **kwargs):
+        pass
+
+