refactor

.gitignore copy

@@ -0,0 +1,16 @@
+*.pyc
+**/__pycache__
+.idea
+.vscode/*
+.DS_Store
+app/output/*.jpg
+demo/kb_output/*.jpg
+# build outputs
+dist
+build
+# checkpoint
+*.pth
+*.pt
+*.onnx
+test/temp/*
+!test/temp/.gitkeep

.vscode/extensions.json

@@ -0,0 +1,20 @@
+{
+  "recommendations": [
+    "ms-python.black-formatter",
+    "donjayamanne.python-extension-pack",
+    "njpwerner.autodocstring",
+
+    "editorconfig.editorconfig",
+
+    "gruntfuggly.todo-tree",
+
+    "eamodio.gitlens",
+
+    "PKief.material-icon-theme",
+    "davidanson.vscode-markdownlint",
+    "usernamehw.errorlens",
+    "tamasfe.even-better-toml",
+
+    "littlefoxteam.vscode-python-test-adapter"
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,71 @@
+{
+  "workbench.iconTheme": "material-icon-theme",
+  "material-icon-theme.files.associations": {
+    ".env.mock": "Tune",
+    "requirements-dev.txt": "python-misc",
+    "requirements-media.txt": "python-misc"
+  },
+  /** 后端代码格式化部分，python格式化 */
+  "[python]": {
+    "editor.defaultFormatter": "ms-python.black-formatter",
+    "editor.formatOnSave": true
+  },
+  /** TODO tree 配置 */
+  "todo-tree.general.tags": [
+    "TODO", // 待办
+    "FIXME", // 待修复
+    "COMPAT", // 兼容性问题
+    "WARNING" // 警告
+  ],
+  "todo-tree.highlights.customHighlight": {
+    "TODO": {
+      "icon": "check",
+      "type": "tag",
+      "foreground": "#ffff00",
+      "iconColour": "#ffff"
+    },
+    "WARNING": {
+      "icon": "alert",
+      "type": "tag",
+      "foreground": "#ff0000",
+      "iconColour": "#ff0000"
+    },
+    "FIXME": {
+      "icon": "flame",
+      "type": "tag",
+      "foreground": "#ff0000",
+      "iconColour": "#ff0000"
+    },
+    "COMPAT": {
+      "icon": "flame",
+      "type": "tag",
+      "foreground": "#00ff00",
+      "iconColour": "#ffff"
+    }
+  },
+
+  /** python代码注释 */
+  "autoDocstring.docstringFormat": "numpy",
+
+  /** markdown格式检查 */
+  "markdownlint.config": {
+    // 允许使用html标签
+    "MD033": false,
+    // 允许首行不是level1标题
+    "MD041": false
+  },
+
+  /** 不显示文件夹 */
+  "files.exclude": {
+    "**/.git": true,
+    "**/.svn": true,
+    "**/.hg": true,
+    "**/CVS": true,
+    "**/.DS_Store": true,
+    "**/Thumbs.db": true,
+    "**/__pycache__": true,
+    ".idea": true
+  },
+  "python.testing.pytestEnabled": true,
+  "ros.distro": "humble"
+}

Dockerfile

@@ -1,9 +1,9 @@
 FROM ubuntu:22.04
 
 # apt换源，安装pip
-RUN echo "==> 换成阿里源，并更新..."  && \
-    sed -i s@/archive.ubuntu.com/@/mirrors.aliyun.com/@g /etc/apt/sources.list  && \
-    sed -i s@/security.ubuntu.com/@/mirrors.aliyun.com/@g /etc/apt/sources.list  && \
+RUN echo "==> 换成清华源，并更新..."  && \
+    sed -i s@/archive.ubuntu.com/@/mirrors.tuna.tsinghua.edu.cn/@g /etc/apt/sources.list  && \
+    sed -i s@/security.ubuntu.com/@/mirrors.tuna.tsinghua.edu.cn/@g /etc/apt/sources.list  && \
     apt-get clean  && \
     apt-get update
 
@@ -22,13 +22,14 @@ WORKDIR /app
 
 COPY . .
 
-RUN pip3 install -r requirements.txt
+RUN pip3 install -r requirements.txt && \
+    pip3 install -r requirements-app.txt
 
 RUN echo "==> Clean up..."  && \
     rm -rf ~/.cache/pip
 
 # 指定工作目录
 
-EXPOSE 8080
+EXPOSE 7860
 
-ENTRYPOINT ["python3", "deploy_api.py"]
+CMD [ "python3", "app.py", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -4,47 +4,59 @@ emoji: 🌖
 colorFrom: green
 colorTo: purple
 sdk: gradio
-sdk_version: 3.38.0
+sdk_version: 4.43.0
 app_file: app.py
 pinned: true
 ---
 
+
 <div align="center">
 <h1>HivisionIDPhoto</h1>
 
-[English](README_EN.md) / 中文
+[English](README_EN.md) / 中文 / [日本語](README_JP.md) / [한국어](README_KO.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)
+[![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=知乎&color=blue)](https://zhuanlan.zhihu.com/p/638254028)
+[![Spaces](https://img.shields.io/badge/🤗-Open%20in%20Spaces-blue)](https://huggingface.co/spaces/TheEeeeLin/HivisionIDPhotos)
+<a href="https://docs.qq.com/doc/DUkpBdk90eWZFS2JW" target="_blank">
+<img alt="Static Badge" src="https://img.shields.io/badge/WeChat-微信-4cb55e"></a>
+
+<a href="https://trendshift.io/repositories/11622" target="_blank"><img src="https://trendshift.io/api/badge/repositories/11622" alt="Zeyi-Lin%2FHivisionIDPhotos | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
 <img src="assets/demoImage.png" width=900>
+
 </div>
 
+<br>
+
+> **相关项目**：
+>
+> - [SwanLab](https://github.com/SwanHubX/SwanLab)：训练人像抠图模型全程用它来分析和监控，以及和实验室同学协作交流，大幅提升了训练效率。
+
+<br>
+
+# 🤩 项目更新
+
+- 在线体验： [![SwanHub Demo](https://img.shields.io/static/v1?label=Demo&message=SwanHub%20Demo&color=blue)](https://swanhub.co/ZeYiLin/HivisionIDPhotos/demo)、[![Spaces](https://img.shields.io/badge/🤗-Open%20in%20Spaces-blue)](https://huggingface.co/spaces/TheEeeeLin/HivisionIDPhotos)
 
-# 🤩项目更新
-- 在线体验: [![SwanHub Demo](https://img.shields.io/static/v1?label=Demo&message=SwanHub%20Demo&color=blue)](https://swanhub.co/ZeYiLin/HivisionIDPhotos/demo)
-- 2023.12.1: 更新**API部署（基于fastapi）**
+- 2024.9.5: 更新 [Restful API 文档](docs/api_CN.md)
+- 2024.9.2: 更新**调整照片 KB 大小**，[DockerHub](https://hub.docker.com/r/linzeyi/hivision_idphotos/tags)
+- 2023.12.1: 更新**API 部署（基于 fastapi）**
 - 2023.6.20: 更新**预设尺寸菜单**
 - 2023.6.19: 更新**排版照**
-- 2023.6.13: 更新**中心渐变色**
-- 2023.6.11: 更新**上下渐变色**
-- 2023.6.8: 更新**自定义尺寸**
-- 2023.6.4: 更新**自定义底色、人脸检测Bug通知**
-- 2023.5.10: 更新**不改尺寸只换底**
 
 # Overview
 
-> 🚀谢谢你对我们的工作感兴趣。您可能还想查看我们在图像领域的其他成果，欢迎来信:[email protected].
+> 🚀 谢谢你对我们的工作感兴趣。您可能还想查看我们在图像领域的其他成果，欢迎来信:[email protected].
 
-HivisionIDPhoto旨在开发一种实用的证件照智能制作算法。
+HivisionIDPhoto 旨在开发一种实用的证件照智能制作算法。
 
 它利用一套完善的模型工作流程，实现对多种用户拍照场景的识别、抠图与证件照生成。
 
+**HivisionIDPhoto 可以做到：**
 
-**HivisionIDPhoto可以做到:**
-
-1. 轻量级抠图
+1. 轻量级抠图（仅需 **CPU** 即可快速推理）
 2. 根据不同尺寸规格生成不同的标准证件照、六寸排版照
 3. 美颜（waiting）
 4. 智能换正装（waiting）
@@ -53,16 +65,15 @@ HivisionIDPhoto旨在开发一种实用的证件照智能制作算法。
 <img src="assets/gradio-image.jpeg" width=900>
 </div>
 
-
 ---
 
-如果HivisionIDPhoto对你有帮助，请star这个repo或推荐给你的朋友，解决证件照应急制作问题！
+如果 HivisionIDPhoto 对你有帮助，请 star 这个 repo 或推荐给你的朋友，解决证件照应急制作问题！
 
 <br>
 
-# 🔧环境安装与依赖
+# 🔧 环境安装与依赖
 
-- Python >= 3.7（项目主要测试在python 3.10）
+- Python >= 3.7（项目主要测试在 python 3.10）
 - onnxruntime
 - OpenCV
 - Option: Linux, Windows, MacOS
@@ -74,84 +85,250 @@ git clone https://github.com/Zeyi-Lin/HivisionIDPhotos.git
 cd  HivisionIDPhotos
 ```
 
-**2. 安装依赖环境**
+**2. （重要）安装依赖环境**
+
+> 建议 conda 创建一个 python3.10 虚拟环境后，执行以下命令
 
 ```bash
 pip install -r requirements.txt
+pip install -r requirements-app.txt
 ```
 
 **3. 下载权重文件**
 
-在我们的[Release](https://github.com/Zeyi-Lin/HivisionIDPhotos/releases/tag/pretrained-model)下载权重文件`hivision_modnet.onnx`，存到根目录下。
+在我们的[Release](https://github.com/Zeyi-Lin/HivisionIDPhotos/releases/tag/pretrained-model)下载权重文件`hivision_modnet.onnx` (24.7MB)，存到项目的`hivision/creator/weights`目录下。
 
 <br>
 
-# 运行Gradio Demo
+# 🚀 运行 Gradio Demo
 
 ```bash
 python app.py
 ```
 
-运行程序将生成一个本地Web页面，在页面中可完成证件照的操作与交互。
+运行程序将生成一个本地 Web 页面，在页面中可完成证件照的操作与交互。
+
+<br>
+
+# 🚀 Python 推理
+
+## 1. 证件照制作
+
+输入 1 张照片，获得 1 张标准证件照和 1 张高清证件照的 4 通道透明 png
+
+```python
+python inference.py -i demo/images/test.jpg -o ./idphoto.png --height 413 --width 295
+```
+
+## 2. 增加底色
+
+输入 1 张 4 通道透明 png，获得 1 张增加了底色的图像）
+
+```python
+python inference.py -t add_background -i ./idphoto.png -o ./idhoto_ab.jpg  -c 000000 -k 30
+```
+
+## 3. 得到六寸排版照
+
+输入 1 张 3 通道照片，获得 1 张六寸排版照
+
+```python
+python inference.py -t generate_layout_photos -i ./idhoto_ab.jpg -o ./idhoto_layout.jpg  --height 413 --width 295 -k 200
+```
 
 <br>
 
-# 部署API服务
+# ⚡️ 部署 API 服务
+
+## 启动后端
 
 ```
 python deploy_api.py
 ```
 
 
-**请求API服务（Python）**
+## 请求 API 服务 - Python Request
+
+> 请求方式请参考 [API 文档](docs/api_CN.md)，含 [cURL](docs/api_CN.md#curl-请求示例)、[Python](docs/api_CN.md#python-请求示例)、[Java](docs/api_CN.md#java-请求示例)、[Javascript](docs/api_CN.md#javascript-请求示例) 请求示例。
+
+### 1. 证件照制作
+
+输入 1 张照片，获得 1 张标准证件照和 1 张高清证件照的 4 通道透明 png
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/idphoto"
+input_image_path = "demo/images/test.jpg"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"height": 413, "width": 295}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response为一个json格式字典，包含status、image_base64_standard和image_base64_hd三项
+print(response)
+
+```
+
+### 2. 增加底色
+
+输入 1 张 4 通道透明 png，获得 1 张增加了底色的图像
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/add_background"
+input_image_path = "test.png"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"color": '638cce', 'kb': None}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response为一个json格式字典，包含status和image_base64
+print(response)
+```
+
+### 3. 得到六寸排版照
+
+输入 1 张 3 通道照片，获得 1 张六寸排版照
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/generate_layout_photos"
+input_image_path = "test.jpg"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"height": 413, "width": 295, "kb": 200}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response为一个json格式字典，包含status和image_base64
+print(response)
+```
+
+<br>
+
+# 🐳 Docker 部署
+
+## 1. 拉取或构建镜像
 
-用Python给服务发送请求：
+> 以下方式三选一
 
-证件照制作（输入1张照片，获得1张标准证件照和1张高清证件照的4通道透明png）：
+**方式一：拉取镜像：**
 
 ```bash
-python requests_api.py -u http://127.0.0.1:8080 -i test.jpg -o ./idphoto.png -s '(413,295)'
+docker pull linzeyi/hivision_idphotos:v1
+docker tag linzeyi/hivision_idphotos:v1 hivision_idphotos
 ```
 
-增加底色（输入1张4通道透明png，获得1张增加了底色的图像）：
+国内拉取加速：
 
 ```bash
-python requests_api.py -u http://127.0.0.1:8080 -t add_background -i ./idphoto.png -o ./idhoto_ab.jpg  -c '(0,0,0)'
+docker pull registry.cn-hangzhou.aliyuncs.com/swanhub/hivision_idphotos:v1
+docker tag registry.cn-hangzhou.aliyuncs.com/swanhub/hivision_idphotos:v1 hivision_idphotos
 ```
 
-得到六寸排版照（输入1张3通道照片，获得1张六寸排版照）：
+**方式二：Dockrfile 直接构建镜像：**
+
+在确保将模型权重文件[hivision_modnet.onnx](https://github.com/Zeyi-Lin/HivisionIDPhotos/releases/tag/pretrained-model)放到`hivision/creator/weights`下后，在项目根目录执行：
 
 ```bash
-python requests_api.py -u http://127.0.0.1:8080 -t generate_layout_photos -i ./idhoto_ab.jpg -o ./idhoto_layout.jpg  -s '(413,295)'
+docker build -t hivision_idphotos .
 ```
 
-<br>
+**方式三：Docker compose 构建：**
 
-# 🐳Docker部署
+确保将模型权重文件 [hivision_modnet.onnx](https://github.com/Zeyi-Lin/HivisionIDPhotos/releases/tag/pretrained-model) 放在`hivision/creator/weights`下后，在项目根目录下执行：
+
+```bash
+docker compose build
+```
 
-在确保将模型权重文件[hivision_modnet.onnx](https://github.com/Zeyi-Lin/HivisionIDPhotos/releases/tag/pretrained-model)放到根目录下后，在根目录执行：
+镜像打包完成后，运行以下命令启动 Gradio 服务：
 
 ```bash
-docker build -t hivision_idphotos .
+docker compose up -d
+```
+
+## 2. 运行 Gradio Demo
+
+等待镜像封装完毕后，运行以下指令，即可开启 Gradio Demo 服务：
+
+```bash
+docker run -p 7860:7860 hivision_idphotos
 ```
 
-等待镜像封装完毕后，运行以下指令，即可开启API服务：
+在你的本地访问 [http://127.0.0.1:7860](http://127.0.0.1:7860/) 即可使用。
+
+## 3. 运行 API 后端服务
 
 ```bash
-docker run -p 8080:8080 hivision_idphotos
+docker run -p 8080:8080 hivision_idphotos python3 deploy_api.py
 ```
 
 <br>
 
+# 🌲 友情链接
+
+- [HivisionIDPhotos-windows-GUI](https://github.com/zhaoyun0071/HivisionIDPhotos-windows-GUI)
+
+<br>
+
+# 📖 引用项目
 
-# 引用项目
+1. MTCNN:
 
-1. MTCNN: https://github.com/ipazc/mtcnn
-2. ModNet: https://github.com/ZHKKKe/MODNet
+```bibtex
+@software{ipazc_mtcnn_2021,
+    author = {ipazc},
+    title = {{MTCNN}},
+    url = {https://github.com/ipazc/mtcnn},
+    year = {2021},
+    publisher = {GitHub}
+}
+```
+
+2. ModNet:
+
+```bibtex
+@software{zhkkke_modnet_2021,
+    author = {ZHKKKe},
+    title = {{ModNet}},
+    url = {https://github.com/ZHKKKe/MODNet},
+    year = {2021},
+    publisher = {GitHub}
+}
+```
 
 <br>
 
+# 💻 开发小贴士
+
+**1. 如何修改预设尺寸？**
+
+修改[size_list_CN.csv](demo/size_list_CN.csv)后再次运行 app.py 即可，其中第一列为尺寸名，第二列为高度，第三列为宽度。
+
+<br>
+
+# 📧 联系我们
+
+如果您有任何问题，请发邮件至 [email protected]
+
+<br>
+
+# 贡献者
+
+<a href="https://github.com/Zeyi-Lin/HivisionIDPhotos/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=Zeyi-Lin/HivisionIDPhotos" />
+</a>
+
+[Zeyi-Lin](https://github.com/Zeyi-Lin)、[SAKURA-CAT](https://github.com/SAKURA-CAT)、[Feudalman](https://github.com/Feudalman)、[swpfY](https://github.com/swpfY)、[Kaikaikaifang](https://github.com/Kaikaikaifang)、[ShaohonChen](https://github.com/ShaohonChen)、[KashiwaByte](https://github.com/KashiwaByte)
+
+<br>
 
-# 📧联系我们
+# StarHistory
 
-如果您有任何问题，请发邮件至 zeyi.lin@swanhub.co
+[![Star History Chart](https://api.star-history.com/svg?repos=Zeyi-Lin/HivisionIDPhotos&type=Date)](https://star-history.com/#Zeyi-Lin/HivisionIDPhotos&Date)

README_EN.md

@@ -1,155 +0,0 @@
-<div align="center">
-<h1>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://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="assets/demoImage.png" width=900>
-</div>
-
-</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.12.1: Update **API deployment (based on fastapi)**
-- 2023.6.20: Update **Preset size menu**
-- 2023.6.19: Update **Layout photos**
-- 2023.6.13: Update **Center gradient color**
-- 2023.6.11: Update **Top and bottom gradient color**
-- 2023.6.8: Update **Custom size**
-- 2023.6.4: Update **Custom background color, face detection bug notification**
-- 2023.5.10: Update **Change the background without changing the 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 [email protected].
-
-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="assets/gradio-image.jpeg" width=900>
-</div>
-
-
----
-
-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!
-
-<br>
-
-# 🔧Environment Dependencies and Installation
-
-- Python >= 3.7（The main test of the project is in Python 3.10.）
-- onnxruntime
-- OpenCV
-- Option: Linux, Windows, MacOS
-
-### Installation
-
-1. Clone repo
-
-```bash
-git clone https://github.com/Zeyi-Lin/HivisionIDPhotos.git
-cd  HivisionIDPhotos
-```
-
-2. Install dependent packages
-
-```
-pip install -r requirements.txt
-```
-
-**3. Download Pretrain file**
-
-Download the weight file `hivision_modnet.onnx` from our [Release](https://github.com/Zeyi-Lin/HivisionIDPhotos/releases/tag/pretrained-model) and save it to the root directory.
-
-<br>
-
-# Gradio Demo
-
-```bash
-python app.py
-```
-
-Running the program will generate a local web page, where operations and interactions with ID photos can be completed.
-
-<br>
-
-# Deploy API service
-
-```
-python deploy_api.py
-```
-
-**Request API service (Python)**
-
-Use Python to send a request to the service:
-
-ID photo production (input 1 photo, get 1 standard ID photo and 1 high-definition ID photo 4-channel transparent png):
-
-```bash
-python requests_api.py -u http://127.0.0.1:8080 -i test.jpg -o ./idphoto.png -s '(413,295)'
-```
-
-Add background color (input 1 4-channel transparent png, get 1 image with added background color):
-
-```bash
-python requests_api.py -u http://127.0.0.1:8080 -t add_background -i ./idphoto.png -o ./idhoto_ab.jpg -c '(0,0,0)'
-```
-
-Get a six-inch layout photo (input a 3-channel photo, get a six-inch layout photo):
-
-```bash
-python requests_api.py -u http://127.0.0.1:8080 -t generate_layout_photos -i ./idhoto_ab.jpg -o ./idhoto_layout.jpg -s '(413,295)'
-```
-
-<br>
-
-# 🐳Docker deployment
-
-After ensuring that the model weight file [hivision_modnet.onnx](https://github.com/Zeyi-Lin/HivisionIDPhotos/releases/tag/pretrained-model) is placed in the root directory, execute in the root directory:
-
-```bash
-docker build -t hivision_idphotos .
-```
-
-After the image is packaged, run the following command to start the API service:
-
-```bash
-docker run -p 8080:8080 hivision_idphotos
-```
-
-<br>
-
-# Reference Projects
-
-1. MTCNN: https://github.com/ipazc/mtcnn
-2. ModNet: https://github.com/ZHKKKe/MODNet
-
-
-<br>
-
-# 📧Contact 
-
-If you have any questions, please email [email protected]
-
-
-Copyright © 2023, ZeYiLin. All Rights Reserved.
-

app.py

@@ -1,20 +1,21 @@
 import os
 import gradio as gr
-import onnxruntime
-from src.face_judgement_align import IDphotos_create
-from hivisionai.hycv.vision import add_background
-from src.layoutCreate import generate_layout_photo, generate_layout_image
+from hivision import IDCreator
+from hivision.error import FaceError
+from hivision.utils import add_background, resize_image_to_kb
+from hivision.creator.layout_calculator import (
+    generate_layout_photo,
+    generate_layout_image,
+)
 import pathlib
 import numpy as np
-from image_utils import resize_image_to_kb
-from data_utils import csv_to_size_list
+from demo.utils import csv_to_size_list
 import argparse
 
-
 # 获取尺寸列表
 root_dir = os.path.dirname(os.path.abspath(__file__))
-size_list_dict_CN = csv_to_size_list(os.path.join(root_dir, "size_list_CN.csv"))
-size_list_dict_EN = csv_to_size_list(os.path.join(root_dir, "size_list_EN.csv"))
+size_list_dict_CN = csv_to_size_list(os.path.join(root_dir, "demo/size_list_CN.csv"))
+size_list_dict_EN = csv_to_size_list(os.path.join(root_dir, "demo/size_list_EN.csv"))
 
 color_list_dict_CN = {
     "蓝色": (86, 140, 212),
@@ -29,11 +30,6 @@ color_list_dict_EN = {
 }
 
 
-# 设置 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)
@@ -149,35 +145,19 @@ def idphoto_inference(
     else:
         idphoto_json["custom_image_kb"] = None
 
+    creator = IDCreator()
+    change_bg_only = idphoto_json["size_mode"] in ["只换底", "Only Change Background"]
     # 生成证件照
-    (
-        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 = {
+    try:
+        result = creator(
+            input_image,
+            change_bg_only=change_bg_only,
+            size=idphoto_json["size"],
+            head_measure_ratio=head_measure_ratio,
+            head_height_ratio=head_height_ratio,
+        )
+    except FaceError:
+        result_message = {
             img_output_standard: gr.update(value=None),
             img_output_standard_hd: gr.update(value=None),
             notification: gr.update(
@@ -185,9 +165,8 @@ def idphoto_inference(
                 visible=True,
             ),
         }
-
-    # 如果检测到人脸数量等于 1
     else:
+        (result_image_hd, result_image_standard, _, _) = result
         if idphoto_json["render_mode"] == text_lang_map[language]["Solid Color"]:
             result_image_standard = np.uint8(
                 add_background(result_image_standard, bgr=idphoto_json["color_bgr"])
@@ -240,12 +219,15 @@ def idphoto_inference(
                 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_layout_image = gr.update(
+                value=generate_layout_image(
+                    result_image_standard,
+                    typography_arr,
+                    typography_rotate,
+                    height=idphoto_json["size"][0],
+                    width=idphoto_json["size"][1],
+                ),
+                visible=True,
             )
 
         # 如果输出 KB 大小选择的是自定义
@@ -255,7 +237,7 @@ def idphoto_inference(
             # 输出路径为一个根据时间戳 + 哈希值生成的随机文件名
             import time
 
-            output_image_path = f"./output/{int(time.time())}.jpg"
+            output_image_path = f"{os.path.join(os.path.dirname(__file__), 'demo/kb_output')}/{int(time.time())}.jpg"
             resize_image_to_kb(
                 result_image_standard,
                 output_image_path,
@@ -265,7 +247,7 @@ def idphoto_inference(
             output_image_path = None
 
         if output_image_path:
-            result_messgae = {
+            result_message = {
                 img_output_standard: result_image_standard,
                 img_output_standard_hd: result_image_hd,
                 img_output_layout: result_layout_image,
@@ -273,7 +255,7 @@ def idphoto_inference(
                 file_download: gr.update(visible=True, value=output_image_path),
             }
         else:
-            result_messgae = {
+            result_message = {
                 img_output_standard: result_image_standard,
                 img_output_standard_hd: result_image_hd,
                 img_output_layout: result_layout_image,
@@ -281,14 +263,10 @@ def idphoto_inference(
                 file_download: gr.update(visible=False),
             }
 
-    return result_messgae
+    return result_message
 
 
 if __name__ == "__main__":
-    # 预加载 ONNX 模型
-    HY_HUMAN_MATTING_WEIGHTS_PATH = os.path.join(root_dir, "hivision_modnet.onnx")
-    sess = onnxruntime.InferenceSession(HY_HUMAN_MATTING_WEIGHTS_PATH)
-
     language = ["中文", "English"]
     size_mode_CN = ["尺寸列表", "只换底", "自定义尺寸"]
     size_mode_EN = ["Size List", "Only Change Background", "Custom Size"]
@@ -305,40 +283,66 @@ if __name__ == "__main__":
     image_kb_CN = ["不设置", "自定义"]
     image_kb_EN = ["Not Set", "Custom"]
 
-    title = "<h1 id='title'>HivisionIDPhotos</h1>"
-    description = "<h3>😎9.2 Update: Add photo size KB adjustment</h3>"
+    # title = "<h1 id='title'>HivisionIDPhotos</h1>"
+    # description = "<h3>😎9.2 Update: Add photo size KB adjustment</h3>"
+    # css = """
+    # h1#title, h3 {
+    #   text-align: center;
+    # }
+    # """
+
     css = """
-    h1#title, h3 {
-      text-align: center;
-    }
-    """
+        #col-left {
+            margin: 0 auto;
+            max-width: 430px;
+        }
+        #col-mid {
+            margin: 0 auto;
+            max-width: 430px;
+        }
+        #col-right {
+            margin: 0 auto;
+            max-width: 430px;
+        }
+        #col-showcase {
+            margin: 0 auto;
+            max-width: 1100px;
+        }
+        #button {
+            color: blue;
+        }
+        """
+
+    def load_description(fp):
+        with open(fp, "r", encoding="utf-8") as f:
+            content = f.read()
+        return content
 
     demo = gr.Blocks(css=css)
 
     with demo:
-        gr.Markdown(title)
-        gr.Markdown(description)
+        gr.HTML(load_description(os.path.join(root_dir, "assets/title.md")))
         with gr.Row():
             # ------------ 左半边 UI ----------------
             with gr.Column():
-                img_input = gr.Image().style(height=350)
+                img_input = gr.Image(height=400)
                 language_options = gr.Dropdown(
-                    choices=language, label="Language", value="English", elem_id="language"
+                    choices=language, label="Language", value="中文", elem_id="language"
                 )
 
                 mode_options = gr.Radio(
-                    choices=size_mode_EN,
-                    label="ID photo size options",
-                    value="Size List",
+                    choices=size_mode_CN,
+                    label="证件照尺寸选项",
+                    value="尺寸列表",
                     elem_id="size",
                 )
 
                 # 预设尺寸下拉菜单
                 with gr.Row(visible=True) as size_list_row:
                     size_list_options = gr.Dropdown(
-                        choices=size_list_EN,
-                        label="Default size",
-                        value="One inch",
+                        choices=size_list_CN,
+                        label="预设尺寸",
+                        value=size_list_CN[0],
                         elem_id="size_list",
                     )
 
@@ -352,7 +356,7 @@ if __name__ == "__main__":
 
                 # 左：背景色选项
                 color_options = gr.Radio(
-                    choices=colors_EN, label="Background color", value="Blue", elem_id="color"
+                    choices=colors_CN, label="背景色", value="蓝色", elem_id="color"
                 )
 
                 # 左：如果选择「自定义底色」，显示 RGB 输入框
@@ -363,17 +367,17 @@ if __name__ == "__main__":
 
                 # 左：渲染方式选项
                 render_options = gr.Radio(
-                    choices=render_EN,
-                    label="Rendering mode",
-                    value="Solid Color",
+                    choices=render_CN,
+                    label="渲染方式",
+                    value="纯色",
                     elem_id="render",
                 )
 
                 # 左：输出 KB 大小选项
                 image_kb_options = gr.Radio(
-                    choices=image_kb_EN,
-                    label="Set KB size (Download in the bottom right)",
-                    value="Not Set",
+                    choices=image_kb_CN,
+                    label="设置 KB 大小（结果在右边最底的组件下载）",
+                    value="不设置",
                     elem_id="image_kb",
                 )
 
@@ -383,19 +387,19 @@ if __name__ == "__main__":
                         minimum=10,
                         maximum=1000,
                         value=50,
-                        label="KB size",
+                        label="KB 大小",
                         interactive=True,
                     )
 
-                img_but = gr.Button("Start", elem_id="start")
+                img_but = gr.Button("开始制作")
 
                 # 案例图片
-                example_images = gr.Dataset(
-                    components=[img_input],
-                    samples=[
+                example_images = gr.Examples(
+                    inputs=[img_input],
+                    examples=[
                         [path.as_posix()]
                         for path in sorted(
-                            pathlib.Path(os.path.join(root_dir, "images")).rglob(
+                            pathlib.Path(os.path.join(root_dir, "demo/images")).rglob(
                                 "*.jpg"
                             )
                         )
@@ -404,12 +408,12 @@ if __name__ == "__main__":
 
             # ---------------- 右半边 UI ----------------
             with gr.Column():
-                notification = gr.Text(label="Status", visible=False)
+                notification = gr.Text(label="状态", visible=False)
                 with gr.Row():
-                    img_output_standard = gr.Image(label="Standard photo").style(height=350)
-                    img_output_standard_hd = gr.Image(label="HD photo").style(height=350)
-                img_output_layout = gr.Image(label="Layout photo").style(height=350)
-                file_download = gr.File(label="Download the photo after adjusting the KB size", visible=False)
+                    img_output_standard = gr.Image(label="标准照", height=350)
+                    img_output_standard_hd = gr.Image(label="高清照", height=350)
+                img_output_layout = gr.Image(label="六寸排版照", height=350)
+                file_download = gr.File(label="下载调整 KB 大小后的照片", visible=False)
 
             # ---------------- 设置隐藏/显示组件 ----------------
             def change_language(language):
@@ -419,7 +423,7 @@ if __name__ == "__main__":
                         size_list_options: gr.update(
                             label="预设尺寸",
                             choices=size_list_CN,
-                            value="一寸",
+                            value=size_list_CN[0],
                         ),
                         mode_options: gr.update(
                             label="证件照尺寸选项",
@@ -454,7 +458,7 @@ if __name__ == "__main__":
                         size_list_options: gr.update(
                             label="Default size",
                             choices=size_list_EN,
-                            value="One inch",
+                            value=size_list_EN[0],
                         ),
                         mode_options: gr.update(
                             label="ID photo size options",
@@ -582,17 +586,13 @@ if __name__ == "__main__":
             ],
         )
 
-        example_images.click(
-            fn=set_example_image, inputs=[example_images], outputs=[img_input]
-        )
-
-    # argparser = argparse.ArgumentParser()
-    # argparser.add_argument(
-    #     "--port", type=int, default=7860, help="The port number of the server"
-    # )
-    # argparser.add_argument(
-    #     "--host", type=str, default="127.0.0.1", help="The host of the server"
-    # )
-    # args = argparser.parse_args()
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument(
+        "--port", type=int, default=7860, help="The port number of the server"
+    )
+    argparser.add_argument(
+        "--host", type=str, default="127.0.0.1", help="The host of the server"
+    )
+    args = argparser.parse_args()
 
-    demo.launch()
+    demo.launch(server_name=args.host, server_port=args.port)

app.spec

@@ -0,0 +1,44 @@
+# -*- mode: python ; coding: utf-8 -*-
+from PyInstaller.utils.hooks import collect_data_files
+
+datas = [('hivisionai', 'hivisionai'), ('hivision_modnet.onnx', '.'), ('size_list_CN.csv', '.')]
+datas += collect_data_files('gradio_client')
+datas += collect_data_files('gradio')
+
+
+a = Analysis(
+    ['app/web.py'],
+    pathex=[],
+    binaries=[],
+    datas=datas,
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='HivisionIDPhotos',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon=['assets\hivisionai.ico'],
+)

assets/title.md

@@ -0,0 +1,11 @@
+<div style="display: flex; justify-content: center; align-items: center; text-align: center; font-size: 40px;">
+  <div>
+    <b>HivisionIDPhotos</b>
+    <br>
+    <div style="display: flex; justify-content: center; align-items: center; text-align: center;">
+        <a href="https://github.com/xiaolin199912/HivisionIDPhotos"><img alt="Github" src="https://img.shields.io/static/v1?label=GitHub&message=GitHub&color=black"></a> &ensp;
+        <a href="https://docs.qq.com/doc/DUkpBdk90eWZFS2JW" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/WeChat-微信-4cb55e"></a> &ensp;
+        <a href="https://github.com/Zeyi-Lin/HivisionIDPhotos/blob/master/docs/api_EN.md" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/API_Docs-API文档-315bce"></a>
+    </div>
+  </div>
+</div>

beautyPlugin/GrindSkin.py

@@ -1,43 +0,0 @@
-"""
-@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

@@ -1,45 +0,0 @@
-"""
-@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

@@ -1,108 +0,0 @@
-"""
-@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

@@ -1,267 +0,0 @@
-"""
-@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

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

demo/size_list_EN.csv

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

data_utils.py → demo/utils.py

@@ -5,14 +5,15 @@ def csv_to_size_list(csv_file: str) -> dict:
     # 初始化一个空字典
     size_list_dict = {}
 
-    # 打开CSV文件并读取数据
-    with open(csv_file, mode="r") as file:
+    # 打开 CSV 文件并读取数据
+    with open(csv_file, mode="r", encoding="utf-8") as file:
         reader = csv.reader(file)
         # 跳过表头
         next(reader)
         # 读取数据并填充字典
         for row in reader:
             size_name, h, w = row
-            size_list_dict[size_name] = (int(h), int(w))
+            size_name_add_size = "{}\t\t({}, {})".format(size_name, h, w)
+            size_list_dict[size_name_add_size] = (int(h), int(w))
 
     return size_list_dict

deploy_api.py

@@ -1,89 +1,92 @@
 from fastapi import FastAPI, UploadFile, Form
 import onnxruntime
-from src.face_judgement_align import IDphotos_create
-from src.layoutCreate import generate_layout_photo, generate_layout_image
-from hivisionai.hycv.vision import add_background
+from hivision import IDCreator
+from hivision.error import FaceError
+from hivision.creator.layout_calculator import (
+    generate_layout_photo,
+    generate_layout_image,
+)
+from hivision.utils import add_background, resize_image_to_kb_base64, hex_to_rgb
 import base64
 import numpy as np
 import cv2
-import ast
+import os
 
 app = FastAPI()
+creator = IDCreator()
 
 
 # 将图像转换为Base64编码
-
 def numpy_2_base64(img: np.ndarray):
-    retval, buffer = cv2.imencode('.png', img)
-    base64_image = base64.b64encode(buffer).decode('utf-8')
+    retval, buffer = cv2.imencode(".png", img)
+    base64_image = base64.b64encode(buffer).decode("utf-8")
 
     return base64_image
 
 
 # 证件照智能制作接口
 @app.post("/idphoto")
-async def idphoto_inference(input_image: UploadFile,
-                            size: str = Form(...),
-                            head_measure_ratio=0.2,
-                            head_height_ratio=0.45,
-                            top_distance_max=0.12,
-                            top_distance_min=0.10):
+async def idphoto_inference(
+    input_image: UploadFile,
+    height: str = Form(...),
+    width: str = Form(...),
+    head_measure_ratio=0.2,
+    head_height_ratio=0.45,
+    top_distance_max=0.12,
+    top_distance_min=0.10,
+):
+
     image_bytes = await input_image.read()
     nparr = np.frombuffer(image_bytes, np.uint8)
     img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
 
     # 将字符串转为元组
-    size = ast.literal_eval(size)
-
-    result_image_hd, result_image_standard, typography_arr, typography_rotate, \
-        _, _, _, _, status = IDphotos_create(img,
-                                             size=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（照片无人脸 or 多人脸）
-    if status == 0:
-        result_messgae = {
-            "status": False
-        }
-
+    size = (int(height), int(width))
+    try:
+        result = creator(
+            img,
+            size=size,
+            head_measure_ratio=head_measure_ratio,
+            head_height_ratio=head_height_ratio,
+        )
+    except FaceError:
+        result_message = {"status": False}
     # 如果检测到人脸数量等于1, 则返回标准证和高清照结果（png 4通道图像）
     else:
-        result_messgae = {
+        result_message = {
             "status": True,
-            "img_output_standard": numpy_2_base64(result_image_standard),
-            "img_output_standard_hd": numpy_2_base64(result_image_hd),
+            "image_base64_standard": numpy_2_base64(result.standard),
+            "image_base64_hd": numpy_2_base64(result.hd),
         }
 
-    return result_messgae
+    return result_message
 
 
 # 透明图像添加纯色背景接口
 @app.post("/add_background")
-async def photo_add_background(input_image: UploadFile,
-                               color: str = Form(...)):
-    
-    # 读取图像
+async def photo_add_background(
+    input_image: UploadFile, color: str = Form(...), kb: str = Form(None)
+):
     image_bytes = await input_image.read()
     nparr = np.frombuffer(image_bytes, np.uint8)
     img = cv2.imdecode(nparr, cv2.IMREAD_UNCHANGED)
 
-    # 将字符串转为元组
-    color = ast.literal_eval(color)
-    # 将元祖的0和2号数字交换
+    color = hex_to_rgb(color)
     color = (color[2], color[1], color[0])
 
+    result_image = add_background(img, bgr=color).astype(np.uint8)
+
+    if kb:
+        result_image = cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR)
+        result_image_base64 = resize_image_to_kb_base64(result_image, int(kb))
+    else:
+        result_image_base64 = numpy_2_base64(result_image)
+
     # try:
+
     result_messgae = {
         "status": True,
-        "image": numpy_2_base64(add_background(img, bgr=color)),
+        "image_base64": result_image_base64,
     }
 
     # except Exception as e:
@@ -98,31 +101,44 @@ async def photo_add_background(input_image: UploadFile,
 
 # 六寸排版照生成接口
 @app.post("/generate_layout_photos")
-async def generate_layout_photos(input_image: UploadFile, size: str = Form(...)):
-    try:
-        image_bytes = await input_image.read()
-        nparr = np.frombuffer(image_bytes, np.uint8)
-        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+async def generate_layout_photos(
+    input_image: UploadFile,
+    height: str = Form(...),
+    width: str = Form(...),
+    kb: str = Form(None),
+):
+    # try:
+    image_bytes = await input_image.read()
+    nparr = np.frombuffer(image_bytes, np.uint8)
+    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
 
-        size = ast.literal_eval(size)
+    size = (int(height), int(width))
 
-        typography_arr, typography_rotate = generate_layout_photo(input_height=size[0],
-                                                                  input_width=size[1])
+    typography_arr, typography_rotate = generate_layout_photo(
+        input_height=size[0], input_width=size[1]
+    )
 
-        result_layout_image = generate_layout_image(img, typography_arr,
-                                                    typography_rotate,
-                                                    height=size[0],
-                                                    width=size[1])
+    result_layout_image = generate_layout_image(
+        img, typography_arr, typography_rotate, height=size[0], width=size[1]
+    ).astype(np.uint8)
 
-        result_messgae = {
-            "status": True,
-            "image": numpy_2_base64(result_layout_image),
-        }
+    if kb:
+        result_layout_image = cv2.cvtColor(result_layout_image, cv2.COLOR_RGB2BGR)
+        result_layout_image_base64 = resize_image_to_kb_base64(
+            result_layout_image, int(kb)
+        )
+    else:
+        result_layout_image_base64 = numpy_2_base64(result_layout_image)
 
-    except Exception as e:
-        result_messgae = {
-            "status": False,
-        }
+    result_messgae = {
+        "status": True,
+        "image_base64": result_layout_image_base64,
+    }
+
+    # except Exception as e:
+    #     result_messgae = {
+    #         "status": False,
+    #     }
 
     return result_messgae
 
@@ -131,7 +147,10 @@ if __name__ == "__main__":
     import uvicorn
 
     # 加载权重文件
-    HY_HUMAN_MATTING_WEIGHTS_PATH = "./hivision_modnet.onnx"
+    root_dir = os.path.dirname(os.path.abspath(__file__))
+    HY_HUMAN_MATTING_WEIGHTS_PATH = os.path.join(
+        root_dir, "hivision/creator/weights/hivision_modnet.onnx"
+    )
     sess = onnxruntime.InferenceSession(HY_HUMAN_MATTING_WEIGHTS_PATH)
 
     # 在8080端口运行推理服务

docker-compose.yml

@@ -0,0 +1,11 @@
+version: "3.8"
+
+services:
+  hivision_idphotos:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: hivision_idphotos2
+    command: python3 app.py --host 0.0.0.0 --port 7860
+    ports:
+      - "7860:7860"

docs/api_CN.md

@@ -0,0 +1,552 @@
+# API Docs
+
+## 目录
+
+- [开始之前：开启后端服务](#开始之前开启后端服务)
+- [接口功能说明](#接口功能说明)
+- [cURL 请求示例](#curl-请求示例)
+- [Python 请求示例](#python-请求示例)
+  - [Python Requests 请求方法](#1️⃣-python-requests-请求方法)
+  - [Python 脚本请求方法](#2️⃣-python-脚本请求方法)
+- [Java 请求示例](#java-请求示例)
+- [Javascript 请求示例](#javascript-请求示例)
+
+## 开始之前：开启后端服务
+
+在请求 API 之前，请先运行后端服务
+
+```bash
+python delopy_api.py
+```
+
+<br>
+
+## 接口功能说明
+
+### 1.生成证件照(底透明)
+
+接口名：`idphoto`
+
+`生成证件照`接口的逻辑是发送一张 RGB 图像，输出一张标准证件照和一张高清证件照：
+
+- **高清证件照**：根据`size`的宽高比例制作的证件照，文件名为`output_image_dir`增加`_hd`后缀
+- **标准证件照**：尺寸等于`size`，由高清证件照缩放而来，文件名为`output_image_dir`
+
+需要注意的是，生成的两张照片都是透明的（RGBA 四通道图像），要生成完整的证件照，还需要下面的`添加背景色`接口。
+
+> 问：为什么这么设计？  
+> 答：因为在实际产品中，经常用户会频繁切换底色预览效果，直接给透明底图像，由前端 js 代码合成颜色是更好体验的做法。
+
+### 2.添加背景色
+
+接口名：`add_background`
+
+`添加背景色`接口的逻辑是发送一张 RGBA 图像，根据`color`添加背景色，合成一张 JPG 图像。
+
+### 3.生成六寸排版照
+
+接口名：`generate_layout_photos`
+
+`生成六寸排版照`接口的逻辑是发送一张 RGB 图像（一般为添加背景色之后的证件照），根据`size`进行照片排布，然后生成一张六寸排版照。
+
+<br>
+
+
+## cURL 请求示例
+
+cURL 是一个命令行工具，用于使用各种网络协议传输数据。以下是使用 cURL 调用这些 API 的示例。
+
+### 1. 生成证件照(底透明)
+
+```bash
+curl -X POST "http://127.0.0.1:8080/idphoto" \
+-F "input_image=@demo/images/test.jpg" \
+-F "height=413" \
+-F "width=295"
+```
+
+### 2. 添加背景色
+
+```bash
+curl -X POST "http://127.0.0.1:8080/add_background" \
+-F "[email protected]" \
+-F "color=638cce" \
+-F "kb=200"
+```
+
+### 3. 生成六寸排版照
+
+```bash
+curl -X POST "http://127.0.0.1:8080/generate_layout_photos" \
+-F "[email protected]" \
+-F "height=413" \
+-F "width=295" \
+-F "kb=200"
+```
+
+
+## Python 请求示例
+
+### 1️⃣ Python Requests 请求方法
+
+#### 1.生成证件照(底透明)
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/idphoto"
+input_image_path = "images/test.jpg"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"height": 413, "width": 295}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response为一个json格式字典，包含status、image_base64_standard和image_base64_hd三项
+print(response)
+
+```
+
+#### 2.添加背景色
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/add_background"
+input_image_path = "test.png"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"color": '638cce', 'kb': None}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response为一个json格式字典，包含status和image_base64
+print(response)
+```
+
+#### 3.生成六寸排版照
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/generate_layout_photos"
+input_image_path = "test.jpg"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"height": 413, "width": 295, "kb": 200}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response为一个json格式字典，包含status和image_base64
+print(response)
+```
+
+<br>
+
+### 2️⃣ Python 脚本请求方法
+
+```bash
+python requests_api.py -u <URL> -t <TYPE> -i <INPUT_IMAGE_DIR> -o <OUTPUT_IMAGE_DIR> [--height <HEIGHT>] [--width <WIDTH>] [-c <COLOR>] [-k <KB>]
+```
+
+#### 参数说明
+
+##### 基本参数
+
+- `-u`, `--url`
+
+  - **描述**: API 服务的 URL。
+  - **默认值**: `http://127.0.0.1:8080`
+
+- `-t`, `--type`
+
+  - **描述**: 请求 API 的种类，可选值有 `idphoto`、`add_background` 和 `generate_layout_photos`。分别代表证件照制作、透明图加背景和排版照生成。
+  - **默认值**: `idphoto`
+
+- `-i`, `--input_image_dir`
+
+  - **描述**: 输入图像路径。
+  - **必需**: 是
+  - **示例**: `./input_images/photo.jpg`
+
+- `-o`, `--output_image_dir`
+  - **描述**: 保存图像路径。
+  - **必需**: 是
+  - **示例**: `./output_images/processed_photo.jpg`
+
+##### 可选参数
+
+- `--height`,
+  - **描述**: 标准证件照的输出尺寸的高度。
+  - **默认值**: 413
+- `--width`,
+
+  - **描述**: 标准证件照的输出尺寸的宽度。
+  - **默认值**: 295
+
+- `-c`, `--color`
+
+  - **描述**: 给透明图增加背景色，格式为 Hex（如#638cce），仅在 type 为`add_background`时生效
+  - **默认值**: `638cce`
+
+- `-k`, `--kb`
+  - **描述**: 输出照片的 KB 值，仅在 type 为`add_background`和`generate_layout_photos`时生效，值为 None 时不做设置。
+  - **默认值**: `None`
+  - **示例**: `50`
+
+### 1.生成证件照(底透明)
+
+```bash
+python requests_api.py  \
+    -u http://127.0.0.1:8080 \
+    -t idphoto \
+    -i ./photo.jpg \
+    -o ./idphoto.png \
+    --height 413 \
+    --width 295
+```
+
+### 2.添加背景色
+
+```bash
+python requests_api.py  \
+    -u http://127.0.0.1:8080  \
+    -t add_background  \
+    -i ./idphoto.png  \
+    -o ./idphoto_with_background.jpg  \
+    -c 638cce  \
+    -k 50
+```
+
+### 3.生成六寸排版照
+
+```bash
+python requests_api.py  \
+    -u http://127.0.0.1:8080  \
+    -t generate_layout_photos  \
+    -i ./idphoto_with_background.jpg  \
+    -o ./layout_photo.jpg  \
+    --height 413  \
+    --width 295 \
+    -k 200
+```
+
+### 请求失败的情况
+
+- 照片中检测到的人脸大于 1，则失败
+
+## Java 请求示例
+
+### 添加 maven 依赖
+
+```java
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.16</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.6</version>
+        </dependency>
+```
+
+### 运行代码
+
+#### 1.生成证件照(底透明)
+
+```java
+    /**
+     * 生成证件照(底透明)  /idphoto 接口
+     * @param inputImageDir 文件地址
+     * @return
+     * @throws IOException
+     */
+    public static String requestIdPhoto(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/idphoto";
+        // 创建文件对象
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        //包含status、image_base64_standard和image_base64_hd三项
+        return HttpUtil.post(url, paramMap);
+    }
+```
+
+#### 2.添加背景色
+
+```java
+    /**
+     * 添加背景色  /add_background 接口
+     * @param inputImageDir 文件地址
+     * @return
+     * @throws IOException
+     */
+    public static String requestAddBackground(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/add_background";
+        // 创建文件对象
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("color","638cce");
+        paramMap.put("kb","200");
+        // response为一个json格式字典，包含status和image_base64
+        return HttpUtil.post(url, paramMap);
+    }
+```
+
+#### 3.生成六寸排版照
+
+```java
+    /**
+     * 生成六寸排版照  /generate_layout_photos 接口
+     * @param inputImageDir 文件地址
+     * @return
+     * @throws IOException
+     */
+    public static String requestGenerateLayoutPhotos(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/generate_layout_photos";
+        // 创建文件对象
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        paramMap.put("kb","200");
+        //response为一个json格式字典，包含status和image_base64
+        return HttpUtil.post(url, paramMap);
+    }
+```
+
+#### 4.汇总
+
+```java
+
+import cn.hutool.http.HttpUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import org.apache.commons.io.FileUtils;
+import org.springframework.util.StringUtils;
+import java.io.File;
+import java.io.IOException;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author: qingshuang
+ * @createDate: 2024/09/05
+ * @description: java生成证件照，测试用例
+ */
+public class Test {
+    /**
+     * 接口地址
+     */
+    private final static String BASE_URL = "http://127.0.0.1:8080";
+
+    /**
+     * 生成证件照(底透明)  /idphoto 接口
+     * @param inputImageDir 文件地址
+     * @return
+     * @throws IOException
+     */
+    public static String requestIdPhoto(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/idphoto";
+        // 创建文件对象
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        return HttpUtil.post(url, paramMap);
+    }
+    /**
+     * 添加背景色  /add_background 接口
+     * @param inputImageDir 文件地址
+     * @return
+     * @throws IOException
+     */
+    public static String requestAddBackground(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/add_background";
+        // 创建文件对象
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("color","638cce");
+        paramMap.put("kb","200");
+        return HttpUtil.post(url, paramMap);
+    }
+    /**
+     * 生成六寸排版照  /generate_layout_photos 接口
+     * @param inputImageDir 文件地址
+     * @return
+     * @throws IOException
+     */
+    public static String requestGenerateLayoutPhotos(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/generate_layout_photos";
+        // 创建文件对象
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        paramMap.put("kb","200");
+        return HttpUtil.post(url, paramMap);
+    }
+    /**
+     * 生成证件照(底透明)
+     * @param inputImageDir 源文件地址
+     * @param outputImageDir 输出文件地址
+     * @throws IOException
+     */
+    private static void requestIdPhotoToImage(String inputImageDir, String outputImageDir) throws IOException {
+        String res =requestIdPhoto(inputImageDir);
+        //转成json
+        JSONObject response= JSONUtil.parseObj(res);
+        if(response.getBool("status")){//请求接口成功
+            String  image_base64_standard= response.getStr("image_base64_standard");
+            String  image_base64_hd =response.getStr("image_base64_hd");
+            String[] outputImageDirArr= StringUtils.split(outputImageDir,".");
+            // Base64 保存为图片
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_standard."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64_standard));
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_hd."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64_hd));
+        }
+    }
+    /**
+     * 添加背景色
+     * @param inputImageDir 源文件地址
+     * @param outputImageDir 输出文件地址
+     * @throws IOException
+     */
+    private static void requestAddBackgroundToImage(String inputImageDir, String outputImageDir) throws IOException {
+        String res =requestAddBackground(inputImageDir);
+        //转成json
+        JSONObject response= JSONUtil.parseObj(res);
+        if(response.getBool("status")){//请求接口成功
+            String  image_base64= response.getStr("image_base64");
+            String[] outputImageDirArr= StringUtils.split(outputImageDir,".");
+            // Base64 保存为图片
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_background."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64));
+        }
+    }
+    /**
+     * 生成六寸排版照
+     * @param inputImageDir 源文件地址
+     * @param outputImageDir 输出文件地址
+     * @throws IOException
+     */
+    private static void requestGenerateLayoutPhotosToImage(String inputImageDir, String outputImageDir) throws IOException {
+        String res =requestGenerateLayoutPhotos(inputImageDir);
+        //转成json
+        JSONObject response= JSONUtil.parseObj(res);
+        if(response.getBool("status")){//请求接口成功
+            String  image_base64= response.getStr("image_base64");
+            String[] outputImageDirArr= StringUtils.split(outputImageDir,".");
+            // Base64 保存为图片
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_layout."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64));
+        }
+    }
+
+    public static void main(String[] args) {
+        try {
+            //生成证件照(底透明)
+            requestIdPhotoToImage("C:\\Users\\Administrator\\Desktop\\1111.jpg","C:\\Users\\Administrator\\Desktop\\2222.png");
+            //添加背景色
+            requestAddBackgroundToImage("C:\\Users\\Administrator\\Desktop\\2222_hd.png","C:\\Users\\Administrator\\Desktop\\idphoto_with_background.jpg");
+            //生成六寸排版照
+            requestGenerateLayoutPhotosToImage("C:\\Users\\Administrator\\Desktop\\1111.jpg","C:\\Users\\Administrator\\Desktop\\2222.png");
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+```
+
+## JavaScript 请求示例
+
+在JavaScript中，我们可以使用`fetch` API来发送HTTP请求。以下是如何使用JavaScript调用这些API的示例。
+
+### 1. 生成证件照(底透明)
+
+```javascript
+async function generateIdPhoto(inputImagePath, height, width) {
+    const url = "http://127.0.0.1:8080/idphoto";
+    const formData = new FormData();
+    formData.append("input_image", new File([await fetch(inputImagePath).then(res => res.blob())], "test.jpg"));
+    formData.append("height", height);
+    formData.append("width", width);
+
+    const response = await fetch(url, {
+        method: 'POST',
+        body: formData
+    });
+
+    const result = await response.json();
+    console.log(result);
+    return result;
+}
+
+// 示例调用
+generateIdPhoto("images/test.jpg", 413, 295).then(response => {
+    console.log(response);
+});
+```
+
+### 2. 添加背景色
+
+```javascript
+async function addBackground(inputImagePath, color, kb) {
+    const url = "http://127.0.0.1:8080/add_background";
+    const formData = new FormData();
+    formData.append("input_image", new File([await fetch(inputImagePath).then(res => res.blob())], "test.png"));
+    formData.append("color", color);
+    formData.append("kb", kb);
+
+    const response = await fetch(url, {
+        method: 'POST',
+        body: formData
+    });
+
+    const result = await response.json();
+    console.log(result);
+    return result;
+}
+
+// 示例调用
+addBackground("test.png", "638cce", 200).then(response => {
+    console.log(response);
+});
+```
+
+### 3. 生成六寸排版照
+
+```javascript
+async function generateLayoutPhotos(inputImagePath, height, width, kb) {
+    const url = "http://127.0.0.1:8080/generate_layout_photos";
+    const formData = new FormData();
+    formData.append("input_image", new File([await fetch(inputImagePath).then(res => res.blob())], "test.jpg"));
+    formData.append("height", height);
+    formData.append("width", width);
+    formData.append("kb", kb);
+
+    const response = await fetch(url, {
+        method: 'POST',
+        body: formData
+    });
+
+    const result = await response.json();
+    console.log(result);
+    return result;
+}
+
+// 示例调用
+generateLayoutPhotos("test.jpg", 413, 295, 200).then(response => {
+    console.log(response);
+});
+```

docs/api_EN.md

@@ -0,0 +1,551 @@
+# API Documentation
+
+## TOC
+
+- [Before You Start: Launch the Backend Service](#before-you-start-launch-the-backend-service)
+- [Interface Function Descriptions](#interface-function-descriptions)
+- [cURL Request Example](#curl-request-examples)
+- [Python Request Example](#python-request-example)
+  - [Python Requests Method](#1️⃣-python-requests-method)
+  - [Python Script Method](#2️⃣-python-script-request-method)
+- [Java Request Example](#java-request-example)
+- [Javascript Request Example](#javascript-request-examples)
+
+## Before You Start: Launch the Backend Service
+
+Before making API requests, please run the backend service:
+
+```bash
+python deploy_api.py
+```
+
+<br>
+
+## Interface Function Descriptions
+
+### 1. Generate ID Photo (Transparent Background)
+
+Interface Name: `idphoto`
+
+The `Generate ID Photo` interface logic involves sending an RGB image and receiving a standard ID photo and a high-definition ID photo:
+
+- **High-Definition ID Photo**: An ID photo made according to the aspect ratio of `size`, with the filename being `output_image_dir` appended with `_hd` suffix.
+- **Standard ID Photo**: A photo with dimensions equal to `size`, scaled from the high-definition ID photo, with the filename being `output_image_dir`.
+
+It should be noted that both generated photos are transparent (RGBA four-channel images). To produce a complete ID photo, the following `Add Background Color` interface is also required.
+
+> Q: Why is this design used?  
+> A: In actual products, users often need to frequently switch background colors to preview effects. Providing a transparent background image and allowing the front-end JavaScript code to synthesize the color offers a better user experience.
+
+### 2. Add Background Color
+
+Interface Name: `add_background`
+
+The `Add Background Color` interface logic involves sending an RGBA image, adding a background color based on `color`, and synthesizing a JPG image.
+
+### 3. Generate 6-inch Layout Photo
+
+Interface Name: `generate_layout_photos`
+
+The `Generate 6-inch Layout Photo` interface logic involves sending an RGB image (usually an ID photo after adding a background color), arranging the photos according to `size`, and then generating a 6-inch layout photo.
+
+<br>
+
+
+## cURL Request Examples
+
+cURL is a command-line tool used to transfer data using various network protocols. Below are examples of how to use cURL to call these APIs.
+
+### 1. Generate ID Photo (Transparent Background)
+
+```bash
+curl -X POST "http://127.0.0.1:8080/idphoto" \
+-F "input_image=@demo/images/test.jpg" \
+-F "height=413" \
+-F "width=295"
+```
+
+### 2. Add Background Color
+
+```bash
+curl -X POST "http://127.0.0.1:8080/add_background" \
+-F "[email protected]" \
+-F "color=638cce" \
+-F "kb=200"
+```
+
+### 3. Generate Six-Inch Layout Photo
+
+```bash
+curl -X POST "http://127.0.0.1:8080/generate_layout_photos" \
+-F "[email protected]" \
+-F "height=413" \
+-F "width=295" \
+-F "kb=200"
+```
+
+## Python Request Example
+
+### 1️⃣ Python Requests Method
+
+#### 1. Generate ID Photo (Transparent Background)
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/idphoto"
+input_image_path = "images/test.jpg"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"height": 413, "width": 295}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response is a JSON dictionary containing status, image_base64_standard, and image_base64_hd
+print(response)
+```
+
+#### 2. Add Background Color
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/add_background"
+input_image_path = "test.png"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"color": '638cce', 'kb': None}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response is a JSON dictionary containing status and image_base64
+print(response)
+```
+
+#### 3. Generate 6-inch Layout Photo
+
+```python
+import requests
+
+url = "http://127.0.0.1:8080/generate_layout_photos"
+input_image_path = "test.jpg"
+
+files = {"input_image": open(input_image_path, "rb")}
+data = {"height": 413, "width": 295, "kb": 200}
+
+response = requests.post(url, files=files, data=data).json()
+
+# response is a JSON dictionary containing status and image_base64
+print(response)
+```
+
+<br>
+
+### 2️⃣ Python Script Request Method
+
+```bash
+python requests_api.py -u <URL> -t <TYPE> -i <INPUT_IMAGE_DIR> -o <OUTPUT_IMAGE_DIR> [--height <HEIGHT>] [--width <WIDTH>] [-c <COLOR>] [-k <KB>]
+```
+
+#### Parameter Descriptions
+
+##### Basic Parameters
+
+- `-u`, `--url`
+
+  - **Description**: The URL of the API service.
+  - **Default Value**: `http://127.0.0.1:8080`
+
+- `-t`, `--type`
+
+  - **Description**: The type of API request, with optional values being `idphoto`, `add_background`, and `generate_layout_photos`. They represent ID photo creation, transparent image background addition, and layout photo generation, respectively.
+  - **Default Value**: `idphoto`
+
+- `-i`, `--input_image_dir`
+
+  - **Description**: The path of the input image.
+  - **Required**: Yes
+  - **Example**: `./input_images/photo.jpg`
+
+- `-o`, `--output_image_dir`
+  - **Description**: The path to save the image.
+  - **Required**: Yes
+  - **Example**: `./output_images/processed_photo.jpg`
+
+##### Optional Parameters
+
+- `--height`
+
+  - **Description**: The height of the output size for the standard ID photo.
+  - **Default Value**: 413
+
+- `--width`
+
+  - **Description**: The width of the output size for the standard ID photo.
+  - **Default Value**: 295
+
+- `-c`, `--color`
+
+  - **Description**: Adds a background color to the transparent image, in Hex format (e.g., #638cce), only effective when the type is `add_background`.
+  - **Default Value**: `638cce`
+
+- `-k`, `--kb`
+  - **Description**: The KB value of the output photo, only effective when the type is `add_background` or `generate_layout_photos`, and no setting is made when the value is None.
+  - **Default Value**: `None`
+  - **Example**: `50`
+
+#### 1. Generate ID Photo (Transparent Background)
+
+```bash
+python requests_api.py  \
+    -u http://127.0.0.1:8080 \
+    -t idphoto \
+    -i ./photo.jpg \
+    -o ./idphoto.png \
+    --height 413 \
+    --width 295
+```
+
+#### 2. Add Background Color
+
+```bash
+python requests_api.py  \
+    -u http://127.0.0.1:8080  \
+    -t add_background  \
+    -i ./idphoto.png  \
+    -o ./idphoto_with_background.jpg  \
+    -c 638cce  \
+    -k 50
+```
+
+#### 3. Generate 6-inch Layout Photo
+
+```bash
+python requests_api.py  \
+    -u http://127.0.0.1:8080  \
+    -t generate_layout_photos  \
+    -i ./idphoto_with_background.jpg  \
+    -o ./layout_photo.jpg  \
+    --height 413  \
+    --width 295 \
+    -k 200
+```
+
+#### Request Failure Scenarios
+
+- The request fails if more than one face is detected in the photo.
+
+## Java Request Example
+
+### Add Maven Dependency
+
+```java
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.16</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.6</version>
+        </dependency>
+```
+
+### Running the Code
+
+#### 1. Generate ID Photo (Transparent Background)
+
+```java
+    /**
+     * Generate ID Photo (Transparent Background) /idphoto interface
+     * @param inputImageDir File address
+     * @return
+     * @throws IOException
+     */
+    public static String requestIdPhoto(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/idphoto";
+        // Create file object
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        // Contains status, image_base64_standard, and image_base64_hd
+        return HttpUtil.post(url, paramMap);
+    }
+```
+
+#### 2. Add Background Color
+
+```java
+    /**
+     * Add Background Color /add_background interface
+     * @param inputImageDir File address
+     * @return
+     * @throws IOException
+     */
+    public static String requestAddBackground(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/add_background";
+        // Create file object
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("color","638cce");
+        paramMap.put("kb","200");
+        // Response is a JSON dictionary containing status and image_base64
+        return HttpUtil.post(url, paramMap);
+    }
+```
+
+#### 3. Generate 6-inch Layout Photo
+
+```java
+    /**
+     * Generate 6-inch Layout Photo /generate_layout_photos interface
+     * @param inputImageDir File address
+     * @return
+     * @throws IOException
+     */
+    public static String requestGenerateLayoutPhotos(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/generate_layout_photos";
+        // Create file object
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        paramMap.put("kb","200");
+        // Response is a JSON dictionary containing status and image_base64
+        return HttpUtil.post(url, paramMap);
+    }
+```
+
+#### 4. Summary
+
+```java
+
+import cn.hutool.http.HttpUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import org.apache.commons.io.FileUtils;
+import org.springframework.util.StringUtils;
+import java.io.File;
+import java.io.IOException;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author: qingshuang
+ * @createDate: 2024/09/05
+ * @description: Java generate ID photo, test case
+ */
+public class Test {
+    /**
+     * Interface address
+     */
+    private final static String BASE_URL = "http://127.0.0.1:8080";
+
+    /**
+     * Generate ID Photo (Transparent Background) /idphoto interface
+     * @param inputImageDir File address
+     * @return
+     * @throws IOException
+     */
+    public static String requestIdPhoto(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/idphoto";
+        // Create file object
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        return HttpUtil.post(url, paramMap);
+    }
+    /**
+     * Add Background Color /add_background interface
+     * @param inputImageDir File address
+     * @return
+     * @throws IOException
+     */
+    public static String requestAddBackground(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/add_background";
+        // Create file object
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("color","638cce");
+        paramMap.put("kb","200");
+        return HttpUtil.post(url, paramMap);
+    }
+    /**
+     * Generate 6-inch Layout Photo /generate_layout_photos interface
+     * @param inputImageDir File address
+     * @return
+     * @throws IOException
+     */
+    public static String requestGenerateLayoutPhotos(String inputImageDir) throws IOException {
+        String url = BASE_URL+"/generate_layout_photos";
+        // Create file object
+        File inputFile = new File(inputImageDir);
+        Map<String, Object> paramMap=new HashMap<>();
+        paramMap.put("input_image",inputFile);
+        paramMap.put("height","413");
+        paramMap.put("width","295");
+        paramMap.put("kb","200");
+        return HttpUtil.post(url, paramMap);
+    }
+    /**
+     * Generate ID Photo (Transparent Background)
+     * @param inputImageDir Source file address
+     * @param outputImageDir Output file address
+     * @throws IOException
+     */
+    private static void requestIdPhotoToImage(String inputImageDir, String outputImageDir) throws IOException {
+        String res =requestIdPhoto(inputImageDir);
+        // Convert to JSON
+        JSONObject response= JSONUtil.parseObj(res);
+        if(response.getBool("status")){// Request interface success
+            String  image_base64_standard= response.getStr("image_base64_standard");
+            String  image_base64_hd =response.getStr("image_base64_hd");
+            String[] outputImageDirArr= StringUtils.split(outputImageDir,".");
+            // Base64 save as image
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_standard."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64_standard));
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_hd."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64_hd));
+        }
+    }
+    /**
+     * Add Background Color
+     * @param inputImageDir Source file address
+     * @param outputImageDir Output file address
+     * @throws IOException
+     */
+    private static void requestAddBackgroundToImage(String inputImageDir, String outputImageDir) throws IOException {
+        String res =requestAddBackground(inputImageDir);
+        // Convert to JSON
+        JSONObject response= JSONUtil.parseObj(res);
+        if(response.getBool("status")){// Request interface success
+            String  image_base64= response.getStr("image_base64");
+            String[] outputImageDirArr= StringUtils.split(outputImageDir,".");
+            // Base64 save as image
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_background."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64));
+        }
+    }
+    /**
+     * Generate 6-inch Layout Photo
+     * @param inputImageDir Source file address
+     * @param outputImageDir Output file address
+     * @throws IOException
+     */
+    private static void requestGenerateLayoutPhotosToImage(String inputImageDir, String outputImageDir) throws IOException {
+        String res =requestGenerateLayoutPhotos(inputImageDir);
+        // Convert to JSON
+        JSONObject response= JSONUtil.parseObj(res);
+        if(response.getBool("status")){// Request interface success
+            String  image_base64= response.getStr("image_base64");
+            String[] outputImageDirArr= StringUtils.split(outputImageDir,".");
+            // Base64 save as image
+            FileUtils.writeByteArrayToFile(new File(outputImageDirArr[0]+"_layout."+outputImageDirArr[1]),  Base64.getDecoder().decode(image_base64));
+        }
+    }
+
+    public static void main(String[] args) {
+        try {
+            // Generate ID Photo (Transparent Background)
+            requestIdPhotoToImage("C:\\Users\\Administrator\\Desktop\\1111.jpg","C:\\Users\\Administrator\\Desktop\\2222.png");
+            // Add Background Color
+            requestAddBackgroundToImage("C:\\Users\\Administrator\\Desktop\\2222_hd.png","C:\\Users\\Administrator\\Desktop\\idphoto_with_background.jpg");
+            // Generate 6-inch Layout Photo
+            requestGenerateLayoutPhotosToImage("C:\\Users\\Administrator\\Desktop\\1111.jpg","C:\\Users\\Administrator\\Desktop\\2222.png");
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}
+```
+
+## JavaScript Request Examples
+
+In JavaScript, we can use the `fetch` API to send HTTP requests. Below are examples of how to call these APIs using JavaScript.
+
+### 1. Generate ID Photo (Transparent Background)
+
+```javascript
+async function generateIdPhoto(inputImagePath, height, width) {
+    const url = "http://127.0.0.1:8080/idphoto";
+    const formData = new FormData();
+    formData.append("input_image", new File([await fetch(inputImagePath).then(res => res.blob())], "test.jpg"));
+    formData.append("height", height);
+    formData.append("width", width);
+
+    const response = await fetch(url, {
+        method: 'POST',
+        body: formData
+    });
+
+    const result = await response.json();
+    console.log(result);
+    return result;
+}
+
+// Example call
+generateIdPhoto("images/test.jpg", 413, 295).then(response => {
+    console.log(response);
+});
+```
+
+### 2. Add Background Color
+
+```javascript
+async function addBackground(inputImagePath, color, kb) {
+    const url = "http://127.0.0.1:8080/add_background";
+    const formData = new FormData();
+    formData.append("input_image", new File([await fetch(inputImagePath).then(res => res.blob())], "test.png"));
+    formData.append("color", color);
+    formData.append("kb", kb);
+
+    const response = await fetch(url, {
+        method: 'POST',
+        body: formData
+    });
+
+    const result = await response.json();
+    console.log(result);
+    return result;
+}
+
+// Example call
+addBackground("test.png", "638cce", 200).then(response => {
+    console.log(response);
+});
+```
+
+### 3. Generate Six-Inch Layout Photo
+
+```javascript
+async function generateLayoutPhotos(inputImagePath, height, width, kb) {
+    const url = "http://127.0.0.1:8080/generate_layout_photos";
+    const formData = new FormData();
+    formData.append("input_image", new File([await fetch(inputImagePath).then(res => res.blob())], "test.jpg"));
+    formData.append("height", height);
+    formData.append("width", width);
+    formData.append("kb", kb);
+
+    const response = await fetch(url, {
+        method: 'POST',
+        body: formData
+    });
+
+    const result = await response.json();
+    console.log(result);
+    return result;
+}
+
+// Example call
+generateLayoutPhotos("test.jpg", 413, 295, 200).then(response => {
+    console.log(response);
+});
+```

hivision/__init__.py

@@ -0,0 +1,4 @@
+from .creator import IDCreator, Params as IDParams, Result as IDResult
+
+
+__all__ = ["IDCreator", "IDParams", "IDResult", "utils", "error"]

hivision/creator/__init__.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 16:45
+@File: __init__.py
+@IDE: pycharm
+@Description:
+    创建证件照
+"""
+import numpy as np
+from typing import Tuple
+import hivision.creator.utils as U
+from .context import Context, ContextHandler, Params, Result
+from .human_matting import extract_human
+from .face_detector import detect_face
+from .photo_adjuster import adjust_photo
+
+
+class IDCreator:
+    """
+    证件照创建类，包含完整的证件照流程
+    """
+
+    def __init__(self):
+        # 回调时机
+        self.before_all: ContextHandler = None
+        """
+        在所有处理之前，此时图像已经被 resize 到最大边长为 2000
+        """
+        self.after_matting: ContextHandler = None
+        """
+        在抠图之后，ctx.matting_image 被赋值
+        """
+        self.after_detect: ContextHandler = None
+        """
+        在人脸检测之后，ctx.face 被赋值，如果为仅换底，则不会执行此回调
+        """
+        self.after_all: ContextHandler = None
+        """
+        在所有处理之后，此时 ctx.result 被赋值
+        """
+        # 处理者
+        self.matting_handler: ContextHandler = extract_human
+        self.detection_handler: ContextHandler = detect_face
+        # 上下文
+        self.ctx = None
+
+    def __call__(
+        self,
+        image: np.ndarray,
+        size: Tuple[int, int] = (413, 295),
+        change_bg_only: bool = False,
+        head_measure_ratio: float = 0.2,
+        head_height_ratio: float = 0.45,
+        head_top_range: float = (0.12, 0.1),
+    ) -> Result:
+        """
+        证件照处理函数
+        :param image: 输入图像
+        :param change_bg_only: 是否只需要换底
+        :param size: 输出的图像大小（h,w)
+        :param head_measure_ratio: 人脸面积与全图面积的期望比值
+        :param head_height_ratio: 人脸中心处在全图高度的比例期望值
+        :param head_top_range: 头距离顶部的比例（max,min)
+
+        :return: 返回处理后的证件照和一系列参数
+        """
+        # 0.初始化上下文
+        params = Params(
+            size=size,
+            change_bg_only=change_bg_only,
+            head_measure_ratio=head_measure_ratio,
+            head_height_ratio=head_height_ratio,
+            head_top_range=head_top_range,
+        )
+        self.ctx = Context(params)
+        ctx = self.ctx
+        ctx.processing_image = image
+        ctx.processing_image = U.resize_image_esp(
+            ctx.processing_image, 2000
+        )  # 将输入图片 resize 到最大边长为 2000
+        ctx.origin_image = ctx.processing_image.copy()
+        self.before_all and self.before_all(ctx)
+        # 1. 人像抠图
+        self.matting_handler(ctx)
+        self.after_matting and self.after_matting(ctx)
+        if ctx.params.change_bg_only:
+            ctx.result = Result(
+                standard=ctx.matting_image,
+                hd=ctx.matting_image,
+                clothing_params=None,
+                typography_params=None,
+            )
+            self.after_all and self.after_all(ctx)
+            return ctx.result
+        # 2. 人脸检测
+        self.detection_handler(ctx)
+        self.after_detect and self.after_detect(ctx)
+        # 3. 图像调整
+        result_image_hd, result_image_standard, clothing_params, typography_params = (
+            adjust_photo(ctx)
+        )
+        ctx.result = Result(
+            standard=result_image_standard,
+            hd=result_image_hd,
+            clothing_params=clothing_params,
+            typography_params=typography_params,
+        )
+        self.after_all and self.after_all(ctx)
+        return ctx.result

hivision/creator/context.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 19:20
+@File: context.py
+@IDE: pycharm
+@Description:
+    证件照创建上下文类，用于同步信息
+"""
+from typing import Optional, Callable, Tuple
+import numpy as np
+
+
+class Params:
+    def __init__(
+        self,
+        size: Tuple[int, int] = (413, 295),
+        change_bg_only: bool = False,
+        head_measure_ratio: float = 0.2,
+        head_height_ratio: float = 0.45,
+        head_top_range: float = (0.12, 0.1),
+    ):
+        self.__size = size
+        self.__change_bg_only = change_bg_only
+        self.__head_measure_ratio = head_measure_ratio
+        self.__head_height_ratio = head_height_ratio
+        self.__head_top_range = head_top_range
+
+    @property
+    def size(self):
+        return self.__size
+
+    @property
+    def change_bg_only(self):
+        return self.__change_bg_only
+
+    @property
+    def head_measure_ratio(self):
+        return self.__head_measure_ratio
+
+    @property
+    def head_height_ratio(self):
+        return self.__head_height_ratio
+
+    @property
+    def head_top_range(self):
+        return self.__head_top_range
+
+
+class Result:
+    def __init__(
+        self,
+        standard: np.ndarray,
+        hd: np.ndarray,
+        clothing_params: Optional[dict],
+        typography_params: Optional[dict],
+    ):
+        self.standard = standard
+        self.hd = hd
+        self.clothing_params = clothing_params
+        """
+        服装参数，仅换底时为 None
+        """
+        self.typography_params = typography_params
+        """
+        排版参数，仅换底时为 None
+        """
+
+    def __iter__(self):
+        return iter(
+            [self.standard, self.hd, self.clothing_params, self.typography_params]
+        )
+
+
+class Context:
+    def __init__(self, params: Params):
+        self.params: Params = params
+        """
+        证件照处理参数
+        """
+        self.origin_image: Optional[np.ndarray] = None
+        """
+        输入的原始图像，处理时会进行resize，长宽不一定等于输入图像
+        """
+        self.processing_image: Optional[np.ndarray] = None
+        """
+        当前正在处理的图像
+        """
+        self.matting_image: Optional[np.ndarray] = None
+        """
+        人像抠图结果
+        """
+        self.face: Optional[Tuple[int, int, int, int, float]] = None
+        """
+        人脸检测结果，大于一个人脸时已在上层抛出异常
+        元组长度为5，包含 x1, y1, x2, y2, score 的坐标, (x1, y1)为左上角坐标，(x2, y2)为右下角坐标, score为置信度, 最大值为1
+        """
+        self.result: Optional[Result] = None
+        """
+        证件照处理结果
+        """
+
+
+ContextHandler = Optional[Callable[[Context], None]]

hivision/creator/face_detector.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 19:32
+@File: face_detector.py
+@IDE: pycharm
+@Description:
+    人脸检测器
+"""
+from mtcnnruntime import MTCNN
+from .context import Context
+from hivision.error import FaceError
+import cv2
+
+mtcnn = None
+
+
+def detect_face(ctx: Context, scale: int = 2):
+    """
+    人脸检测处理者，只进行人脸数量的检测
+    :param ctx: 上下文，此时已获取到原始图和抠图结果，但是我们只需要原始图
+    :param scale: 最大边长缩放比例，原图:缩放图 = 1:scale
+    :raise FaceError: 人脸检测错误，多个人脸或者没有人脸
+    """
+    global mtcnn
+    if mtcnn is None:
+        mtcnn = MTCNN()
+    image = cv2.resize(
+        ctx.origin_image,
+        (ctx.origin_image.shape[1] // scale, ctx.origin_image.shape[0] // scale),
+        interpolation=cv2.INTER_AREA,
+    )
+    faces, _ = mtcnn.detect(image)
+    if len(faces) != 1:
+        # 保险措施，如果检测到多个人脸或者没有人脸，用原图再检测一次
+        faces, _ = mtcnn.detect(ctx.origin_image)
+    else:
+        for item, param in enumerate(faces[0]):
+            faces[0][item] = param * 2
+    if len(faces) != 1:
+        raise FaceError("Expected 1 face, but got {}".format(len(faces)), len(faces))
+    ctx.face = (faces[0][0], faces[0][1], faces[0][2], faces[0][3], faces[0][4])

hivision/creator/human_matting.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 21:21
+@File: human_matting.py
+@IDE: pycharm
+@Description:
+    人像抠图
+"""
+import numpy as np
+from PIL import Image
+import onnxruntime
+from .tensor2numpy import NNormalize, NTo_Tensor, NUnsqueeze
+from .context import Context
+import cv2
+import os
+
+weight_path = os.path.join(os.path.dirname(__file__), "weights", "hivision_modnet.onnx")
+
+
+def extract_human(ctx: Context):
+    """
+    人像抠图
+    :param ctx: 上下文
+    """
+    # 抠图
+    matting_image = get_modnet_matting(ctx.processing_image, weight_path)
+    # 修复抠图
+    ctx.processing_image = hollow_out_fix(matting_image)
+    ctx.matting_image = ctx.processing_image.copy()
+
+
+def hollow_out_fix(src: np.ndarray) -> np.ndarray:
+    """
+    修补抠图区域，作为抠图模型精度不够的补充
+    :param src:
+    :return:
+    """
+    b, g, r, a = cv2.split(src)
+    src_bgr = cv2.merge((b, g, r))
+    # -----------padding---------- #
+    add_area = np.zeros((10, a.shape[1]), np.uint8)
+    a = np.vstack((add_area, a, add_area))
+    add_area = np.zeros((a.shape[0], 10), np.uint8)
+    a = np.hstack((add_area, a, add_area))
+    # -------------end------------ #
+    _, a_threshold = cv2.threshold(a, 127, 255, 0)
+    a_erode = cv2.erode(
+        a_threshold,
+        kernel=cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5)),
+        iterations=3,
+    )
+    contours, hierarchy = cv2.findContours(
+        a_erode, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
+    )
+    contours = [x for x in contours]
+    # contours = np.squeeze(contours)
+    contours.sort(key=lambda c: cv2.contourArea(c), reverse=True)
+    a_contour = cv2.drawContours(np.zeros(a.shape, np.uint8), contours[0], -1, 255, 2)
+    # a_base = a_contour[1:-1, 1:-1]
+    h, w = a.shape[:2]
+    mask = np.zeros(
+        [h + 2, w + 2], np.uint8
+    )  # mask 必须行和列都加 2，且必须为 uint8 单通道阵列
+    cv2.floodFill(a_contour, mask=mask, seedPoint=(0, 0), newVal=255)
+    a = cv2.add(a, 255 - a_contour)
+    return cv2.merge((src_bgr, a[10:-10, 10:-10]))
+
+
+def image2bgr(input_image):
+    if len(input_image.shape) == 2:
+        input_image = input_image[:, :, None]
+    if input_image.shape[2] == 1:
+        result_image = np.repeat(input_image, 3, axis=2)
+    elif input_image.shape[2] == 4:
+        result_image = input_image[:, :, 0:3]
+    else:
+        result_image = input_image
+
+    return result_image
+
+
+def read_modnet_image(input_image, ref_size=512):
+    im = Image.fromarray(np.uint8(input_image))
+    width, length = im.size[0], im.size[1]
+    im = np.asarray(im)
+    im = image2bgr(im)
+    im = cv2.resize(im, (ref_size, ref_size), interpolation=cv2.INTER_AREA)
+    im = NNormalize(im, mean=np.array([0.5, 0.5, 0.5]), std=np.array([0.5, 0.5, 0.5]))
+    im = NUnsqueeze(NTo_Tensor(im))
+
+    return im, width, length
+
+
+sess = None
+
+
+def get_modnet_matting(input_image, checkpoint_path, ref_size=512):
+    global sess
+    if sess is None:
+        sess = onnxruntime.InferenceSession(checkpoint_path)
+
+    input_name = sess.get_inputs()[0].name
+    output_name = sess.get_outputs()[0].name
+
+    im, width, length = read_modnet_image(input_image=input_image, ref_size=ref_size)
+
+    matte = sess.run([output_name], {input_name: im})
+    matte = (matte[0] * 255).astype("uint8")
+    matte = np.squeeze(matte)
+    mask = cv2.resize(matte, (width, length), interpolation=cv2.INTER_AREA)
+    b, g, r = cv2.split(np.uint8(input_image))
+
+    output_image = cv2.merge((b, g, r, mask))
+
+    return output_image

src/layoutCreate.py → hivision/creator/layout_calculator.py

@@ -1,47 +1,71 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 21:35
+@File: layout_calculator.py
+@IDE: pycharm
+@Description:
+    布局计算器
+"""
+
 import cv2.detail
 import numpy as np
 
-def judge_layout(input_width, input_height, PHOTO_INTERVAL_W, PHOTO_INTERVAL_H, LIMIT_BLOCK_W, LIMIT_BLOCK_H):
-    centerBlockHeight_1, centerBlockWidth_1 = input_height, input_width  # 由证件照们组成的一个中心区块（1代表不转置排列）
-    centerBlockHeight_2, centerBlockWidth_2 = input_width, input_height  # 由证件照们组成的一个中心区块（2代表转置排列）
+
+def judge_layout(
+    input_width,
+    input_height,
+    PHOTO_INTERVAL_W,
+    PHOTO_INTERVAL_H,
+    LIMIT_BLOCK_W,
+    LIMIT_BLOCK_H,
+):
+    centerBlockHeight_1, centerBlockWidth_1 = (
+        input_height,
+        input_width,
+    )  # 由证件照们组成的一个中心区块（1 代表不转置排列）
+    centerBlockHeight_2, centerBlockWidth_2 = (
+        input_width,
+        input_height,
+    )  # 由证件照们组成的一个中心区块（2 代表转置排列）
 
     # 1.不转置排列的情况下：
     layout_col_no_transpose = 0  # 行
     layout_row_no_transpose = 0  # 列
     for i in range(1, 4):
-        centerBlockHeight_temp = input_height * i + PHOTO_INTERVAL_H * (i-1)
+        centerBlockHeight_temp = input_height * i + PHOTO_INTERVAL_H * (i - 1)
         if centerBlockHeight_temp < LIMIT_BLOCK_H:
             centerBlockHeight_1 = centerBlockHeight_temp
             layout_row_no_transpose = i
         else:
             break
     for j in range(1, 9):
-        centerBlockWidth_temp = input_width * j + PHOTO_INTERVAL_W * (j-1)
+        centerBlockWidth_temp = input_width * j + PHOTO_INTERVAL_W * (j - 1)
         if centerBlockWidth_temp < LIMIT_BLOCK_W:
             centerBlockWidth_1 = centerBlockWidth_temp
             layout_col_no_transpose = j
         else:
             break
-    layout_number_no_transpose = layout_row_no_transpose*layout_col_no_transpose
+    layout_number_no_transpose = layout_row_no_transpose * layout_col_no_transpose
 
     # 2.转置排列的情况下：
     layout_col_transpose = 0  # 行
     layout_row_transpose = 0  # 列
     for i in range(1, 4):
-        centerBlockHeight_temp = input_width * i + PHOTO_INTERVAL_H * (i-1)
+        centerBlockHeight_temp = input_width * i + PHOTO_INTERVAL_H * (i - 1)
         if centerBlockHeight_temp < LIMIT_BLOCK_H:
             centerBlockHeight_2 = centerBlockHeight_temp
             layout_row_transpose = i
         else:
             break
     for j in range(1, 9):
-        centerBlockWidth_temp = input_height * j + PHOTO_INTERVAL_W * (j-1)
+        centerBlockWidth_temp = input_height * j + PHOTO_INTERVAL_W * (j - 1)
         if centerBlockWidth_temp < LIMIT_BLOCK_W:
             centerBlockWidth_2 = centerBlockWidth_temp
             layout_col_transpose = j
         else:
             break
-    layout_number_transpose = layout_row_transpose*layout_col_transpose
+    layout_number_transpose = layout_row_transpose * layout_col_transpose
 
     if layout_number_transpose > layout_number_no_transpose:
         layout_mode = (layout_col_transpose, layout_row_transpose, 2)
@@ -59,19 +83,25 @@ def generate_layout_photo(input_height, input_width):
     PHOTO_INTERVAL_W = 30  # 证件照与证件照之间的水平距离
     SIDES_INTERVAL_H = 50  # 证件照与画布边缘的垂直距离
     SIDES_INTERVAL_W = 70  # 证件照与画布边缘的水平距离
-    LIMIT_BLOCK_W = LAYOUT_WIDTH - 2*SIDES_INTERVAL_W
-    LIMIT_BLOCK_H = LAYOUT_HEIGHT - 2*SIDES_INTERVAL_H
+    LIMIT_BLOCK_W = LAYOUT_WIDTH - 2 * SIDES_INTERVAL_W
+    LIMIT_BLOCK_H = LAYOUT_HEIGHT - 2 * SIDES_INTERVAL_H
 
-    # 2.创建一个1180x1746的空白画布
+    # 2.创建一个 1180x1746 的空白画布
     white_background = np.zeros([LAYOUT_HEIGHT, LAYOUT_WIDTH, 3], np.uint8)
     white_background.fill(255)
 
-    # 3.计算照片的layout（列、行、横竖朝向）,证件照组成的中心区块的分辨率
-    layout_mode, centerBlockWidth, centerBlockHeight = judge_layout(input_width, input_height, PHOTO_INTERVAL_W,
-                                                                    PHOTO_INTERVAL_H, LIMIT_BLOCK_W, LIMIT_BLOCK_H)
+    # 3.计算照片的 layout（列、行、横竖朝向）,证件照组成的中心区块的分辨率
+    layout_mode, centerBlockWidth, centerBlockHeight = judge_layout(
+        input_width,
+        input_height,
+        PHOTO_INTERVAL_W,
+        PHOTO_INTERVAL_H,
+        LIMIT_BLOCK_W,
+        LIMIT_BLOCK_H,
+    )
     # 4.开始排列组合
-    x11 = (LAYOUT_WIDTH - centerBlockWidth)//2
-    y11 = (LAYOUT_HEIGHT - centerBlockHeight)//2
+    x11 = (LAYOUT_WIDTH - centerBlockWidth) // 2
+    y11 = (LAYOUT_HEIGHT - centerBlockHeight) // 2
     typography_arr = []
     typography_rotate = False
     if layout_mode[2] == 2:
@@ -80,13 +110,16 @@ def generate_layout_photo(input_height, input_width):
 
     for j in range(layout_mode[1]):
         for i in range(layout_mode[0]):
-            xi = x11 + i*input_width + i*PHOTO_INTERVAL_W
-            yi = y11 + j*input_height + j*PHOTO_INTERVAL_H
+            xi = x11 + i * input_width + i * PHOTO_INTERVAL_W
+            yi = y11 + j * input_height + j * PHOTO_INTERVAL_H
             typography_arr.append([xi, yi])
 
     return typography_arr, typography_rotate
 
-def generate_layout_image(input_image, typography_arr, typography_rotate, width=295, height=413):
+
+def generate_layout_image(
+    input_image, typography_arr, typography_rotate, width=295, height=413
+):
     LAYOUT_WIDTH = 1746
     LAYOUT_HEIGHT = 1180
     white_background = np.zeros([LAYOUT_HEIGHT, LAYOUT_WIDTH, 3], np.uint8)
@@ -98,16 +131,8 @@ def generate_layout_image(input_image, typography_arr, typography_rotate, width=
         height, width = width, height
     for arr in typography_arr:
         locate_x, locate_y = arr[0], arr[1]
-        white_background[locate_y:locate_y+height, locate_x:locate_x+width] = input_image
+        white_background[locate_y : locate_y + height, locate_x : locate_x + width] = (
+            input_image
+        )
 
     return white_background
-
-
-if __name__ == "__main__":
-    typography_arr, typography_rotate = generate_layout_photo(input_height=413, input_width=295)
-    print("typography_arr:", typography_arr)
-    print("typography_rotate:", typography_rotate)
-    result_image = generate_layout_image(cv2.imread("./32.jpg"), typography_arr, typography_rotate, width=295, height=413)
-    cv2.imwrite("./result_image.jpg", result_image)
-
-

{src → hivision/creator}/move_image.py

@@ -1,6 +1,6 @@
 """
-有一些png图像下部也会有一些透明的区域，使得图像无法对其底部边框
-本程序实现移动图像，使其下部与png图像实际大小相对齐
+有一些 png 图像下部也会有一些透明的区域，使得图像无法对其底部边框
+本程序实现移动图像，使其下部与 png 图像实际大小相对齐
 """
 import os
 import cv2
@@ -16,7 +16,7 @@ def merge(boxes):
     生成的边框可能不止只有一个，需要将边框合并
     """
     x, y, h, w = boxes[0]
-    # x和y应该是整个boxes里面最小的值
+    # x 和 y 应该是整个 boxes 里面最小的值
     if len(boxes) > 1:
         for tmp in boxes:
             x_tmp, y_tmp, h_tmp, w_tmp = tmp
@@ -33,14 +33,14 @@ def merge(boxes):
 
 def get_box(png_img):
     """
-    获取矩形边框最终返回一个元组(x,y,h,w)，分别对应矩形左上角的坐标和矩形的高和宽
+    获取矩形边框最终返回一个元组 (x,y,h,w)，分别对应矩形左上角的坐标和矩形的高和宽
     """
     r,  g,  b , a = cv2.split(png_img)
     gray_img = a
     th, binary = cv2.threshold(gray_img, 127 , 255, cv2.THRESH_BINARY)  # 二值化
     # cv2.imshow("name", binary)
     # cv2.waitKey(0)
-    contours, hierarchy = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)  # 得到轮廓列表contours
+    contours, hierarchy = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)  # 得到轮廓列表 contours
     bounding_boxes = merge([cv2.boundingRect(cnt) for cnt in contours])  # 轮廓合并
     # print(bounding_boxes)
     return bounding_boxes
@@ -48,14 +48,14 @@ def get_box(png_img):
 
 def get_box_2(png_img):
     """
-    不用opencv内置算法生成矩形了，改用自己的算法（for循环）
+    不用 opencv 内置算法生成矩形了，改用自己的算法（for 循环）
     """
     _, _, _, a = cv2.split(png_img)
     _, a = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)
-    # 将r，g，b通道丢弃，只留下透明度通道
+    # 将 r，g，b 通道丢弃，只留下透明度通道
     # cv2.imshow("name", a)
     # cv2.waitKey(0)
-    # 在透明度矩阵中，0代表完全透明
+    # 在透明度矩阵中，0 代表完全透明
     height,width=a.shape  # 高和宽
     f=0
     tmp1 = 0
@@ -108,14 +108,14 @@ def get_box_2(png_img):
 
 def move(input_image):
     """
-    裁剪主函数，输入一张png图像，该图像周围是透明的
+    裁剪主函数，输入一张 png 图像，该图像周围是透明的
     """
     png_img = input_image  # 获取图像
 
-    height, width, channels = png_img.shape  # 高y、宽x
-    y_low,y_high, _, _ = get_box_pro(png_img, model=2)  # for循环
-    base = np.zeros((y_high, width, channels),dtype=np.uint8)  # for循环
-    png_img = png_img[0:height - y_high, :, :]  # for循环
+    height, width, channels = png_img.shape  # 高 y、宽 x
+    y_low,y_high, _, _ = get_box_pro(png_img, model=2)  # for 循环
+    base = np.zeros((y_high, width, channels),dtype=np.uint8)  # for 循环
+    png_img = png_img[0:height - y_high, :, :]  # for 循环
     png_img = np.concatenate((base, png_img), axis=0)
     return png_img, y_high
 

hivision/creator/photo_adjuster.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 20:02
+@File: photo_adjuster.py
+@IDE: pycharm
+@Description:
+    证件照调整
+"""
+from .context import Context
+from .layout_calculator import generate_layout_photo
+import hivision.creator.utils as U
+import numpy as np
+import math
+import cv2
+
+
+def adjust_photo(ctx: Context):
+    # Step1. 准备人脸参数
+    face_rect = ctx.face
+    standard_size = ctx.params.size
+    params = ctx.params
+    x, y = face_rect[0], face_rect[1]
+    w, h = face_rect[2] - x + 1, face_rect[3] - y + 1
+    height, width = ctx.processing_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 / params.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] * params.head_height_ratio)
+    y2 = y1 + crop_size[0]
+    x2 = x1 + crop_size[1]
+
+    # Step3, 裁剪框的调整
+    cut_image = IDphotos_cut(x1, y1, x2, y2, ctx.processing_image)
+    cut_image = cv2.resize(cut_image, (crop_size[1], crop_size[0]))
+    y_top, y_bottom, x_left, x_right = U.get_box(
+        cut_image.astype(np.uint8), model=2, correction_factor=0
+    )  # 得到 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 = U.detect_distance(
+        y_top - cut_value_top,
+        crop_size[0],
+        max=params.head_top_range[0],
+        min=params.head_top_range[1],
+    )
+
+    # 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,
+            ctx.processing_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  # 更新换装参数
+
+    # 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,
+    }
+
+    # Step7. 排版照参数获取
+    typography_arr, typography_rotate = generate_layout_photo(
+        input_height=standard_size[0], input_width=standard_size[1]
+    )
+
+    return (
+        result_image_hd,
+        result_image_standard,
+        clothing_params,
+        {
+            "arr": typography_arr,
+            "rotate": typography_rotate,
+        },
+    )
+
+
+def IDphotos_cut(x1, y1, x2, y2, img):
+    """
+    在图片上进行滑动裁剪，输入输出为
+    输入：一张图片 img，和裁剪框信息 (x1,x2,y1,y2)
+    输出：裁剪好的图片，然后裁剪框超出了图像范围，那么将用 0 矩阵补位
+    ------------------------------------
+    x:裁剪框左上的横坐标
+    y:裁剪框左上的纵坐标
+    x2:裁剪框右下的横坐标
+    y2:裁剪框右下的纵坐标
+    crop_size:裁剪框大小
+    img:裁剪图像（numpy.array）
+    output_path:裁剪图片的输出路径
+    ------------------------------------
+    """
+
+    crop_size = (y2 - y1, x2 - x1)
+    """
+    ------------------------------------
+    temp_x_1:裁剪框左边超出图像部分
+    temp_y_1:裁剪框上边超出图像部分
+    temp_x_2:裁剪框右边超出图像部分
+    temp_y_2:裁剪框下边超出图像部分
+    ------------------------------------
+    """
+    temp_x_1 = 0
+    temp_y_1 = 0
+    temp_x_2 = 0
+    temp_y_2 = 0
+
+    if y1 < 0:
+        temp_y_1 = abs(y1)
+        y1 = 0
+    if y2 > img.shape[0]:
+        temp_y_2 = y2
+        y2 = img.shape[0]
+        temp_y_2 = temp_y_2 - y2
+
+    if x1 < 0:
+        temp_x_1 = abs(x1)
+        x1 = 0
+    if x2 > img.shape[1]:
+        temp_x_2 = x2
+        x2 = img.shape[1]
+        temp_x_2 = temp_x_2 - x2
+
+    # 生成一张全透明背景
+    print("crop_size:", crop_size)
+    background_bgr = np.full((crop_size[0], crop_size[1]), 255, dtype=np.uint8)
+    background_a = np.full((crop_size[0], crop_size[1]), 0, dtype=np.uint8)
+    background = cv2.merge(
+        (background_bgr, background_bgr, background_bgr, background_a)
+    )
+
+    background[
+        temp_y_1 : crop_size[0] - temp_y_2, temp_x_1 : crop_size[1] - temp_x_2
+    ] = img[y1:y2, x1:x2]
+
+    return background
+
+
+def move(input_image):
+    """
+    裁剪主函数，输入一张 png 图像，该图像周围是透明的
+    """
+    png_img = input_image  # 获取图像
+
+    height, width, channels = png_img.shape  # 高 y、宽 x
+    y_low, y_high, _, _ = U.get_box(png_img, model=2)  # for 循环
+    base = np.zeros((y_high, width, channels), dtype=np.uint8)  # for 循环
+    png_img = png_img[0 : height - y_high, :, :]  # for 循环
+    png_img = np.concatenate((base, png_img), axis=0)
+    return png_img, y_high
+
+
+def standard_photo_resize(input_image: np.array, size):
+    """
+    input_image: 输入图像，即高清照
+    size: 标准照的尺寸
+    """
+    resize_ratio = input_image.shape[0] / size[0]
+    resize_item = int(round(input_image.shape[0] / size[0]))
+    if resize_ratio >= 2:
+        for i in range(resize_item - 1):
+            if i == 0:
+                result_image = cv2.resize(
+                    input_image,
+                    (size[1] * (resize_item - i - 1), size[0] * (resize_item - i - 1)),
+                    interpolation=cv2.INTER_AREA,
+                )
+            else:
+                result_image = cv2.resize(
+                    result_image,
+                    (size[1] * (resize_item - i - 1), size[0] * (resize_item - i - 1)),
+                    interpolation=cv2.INTER_AREA,
+                )
+    else:
+        result_image = cv2.resize(
+            input_image, (size[1], size[0]), interpolation=cv2.INTER_AREA
+        )
+
+    return result_image
+
+
+def resize_image_by_min(input_image, esp=600):
+    """
+    将图像缩放为最短边至少为 esp 的图像。
+    :param input_image: 输入图像（OpenCV 矩阵）
+    :param esp: 缩放后的最短边长
+    :return: 缩放后的图像，缩放倍率
+    """
+    height, width = input_image.shape[0], input_image.shape[1]
+    min_border = min(height, width)
+    if min_border < esp:
+        if height >= width:
+            new_width = esp
+            new_height = height * esp // width
+        else:
+            new_height = esp
+            new_width = width * esp // height
+
+        return (
+            cv2.resize(
+                input_image, (new_width, new_height), interpolation=cv2.INTER_AREA
+            ),
+            new_height / height,
+        )
+
+    else:
+        return input_image, 1

{hivisionai/hycv → hivision/creator}/tensor2numpy.py

@@ -1,8 +1,8 @@
 """
-作者:林泽毅
-建这个开源库的起源呢,是因为在做onnx推理的时候,需要将原来的tensor转换成numpy.array
-问题是Tensor和Numpy的矩阵排布逻辑不同
-包括Tensor推理经常会进行Transform,比如ToTensor,Normalize等
+作者：林泽毅
+建这个开源库的起源呢，是因为在做 onnx 推理的时候，需要将原来的 tensor 转换成 numpy.array
+问题是 Tensor 和 Numpy 的矩阵排布逻辑不同
+包括 Tensor 推理经常会进行 Transform，比如 ToTensor,Normalize 等
 就想做一些等价转换的函数。
 """
 import numpy as np
@@ -11,7 +11,7 @@ import numpy as np
 def NTo_Tensor(array):
     """
     :param array: opencv/PIL读取的numpy矩阵
-    :return:返回一个形如Tensor的numpy矩阵
+    :return:返回一个形如 Tensor 的 numpy 矩阵
     Example:
     Inputs:array.shape = (512,512,3)
     Outputs:output.shape = (3,512,512)
@@ -23,16 +23,16 @@ def NTo_Tensor(array):
 def NNormalize(array, mean=np.array([0.5, 0.5, 0.5]), std=np.array([0.5, 0.5, 0.5]), dtype=np.float32):
     """
     :param array: opencv/PIL读取的numpy矩阵
-           mean: 归一化均值,np.array格式
-           std:  归一化标准差,np.array格式
-           dtype：输出的numpy数据格式,一般onnx需要float32
-    :return:numpy矩阵
+           mean: 归一化均值，np.array 格式
+           std:  归一化标准差，np.array 格式
+           dtype：输出的 numpy 数据格式，一般 onnx 需要 float32
+    :return:numpy 矩阵
     Example:
-    Inputs:array为opencv/PIL读取的一张图片
+    Inputs:array 为 opencv/PIL 读取的一张图片
            mean=np.array([0.5,0.5,0.5])
            std=np.array([0.5,0.5,0.5])
            dtype=np.float32
-    Outputs:output为归一化后的numpy矩阵
+    Outputs:output 为归一化后的 numpy 矩阵
     """
     im = array / 255.0
     im = np.divide(np.subtract(im, mean), std)
@@ -45,11 +45,11 @@ def NUnsqueeze(array, axis=0):
     """
     :param array: opencv/PIL读取的numpy矩阵
            axis：要增加的维度
-    :return:numpy矩阵
+    :return:numpy 矩阵
     Example:
-    Inputs:array为opencv/PIL读取的一张图片,array.shape为[512,512,3]
+    Inputs:array 为 opencv/PIL 读取的一张图片，array.shape 为 [512,512,3]
            axis=0
-    Outputs:output为array在第0维增加一个维度,shape转为[1,512,512,3]
+    Outputs:output 为 array 在第 0 维增加一个维度，shape 转为 [1,512,512,3]
     """
     if axis == 0:
         output = array[None, :, :, :]

hivision/creator/utils.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 19:25
+@File: utils.py
+@IDE: pycharm
+@Description:
+    通用图像处理工具
+"""
+import cv2
+import numpy as np
+
+
+def resize_image_esp(input_image, esp=2000):
+    """
+    输入：
+    input_path：numpy 图片
+    esp：限制的最大边长
+    """
+    # resize 函数=>可以让原图压缩到最大边为 esp 的尺寸 (不改变比例)
+    width = input_image.shape[0]
+
+    length = input_image.shape[1]
+    max_num = max(width, length)
+
+    if max_num > esp:
+        print("Image resizing...")
+        if width == max_num:
+            length = int((esp / width) * length)
+            width = esp
+
+        else:
+            width = int((esp / length) * width)
+            length = esp
+        print(length, width)
+        im_resize = cv2.resize(
+            input_image, (length, width), interpolation=cv2.INTER_AREA
+        )
+        return im_resize
+    else:
+        return input_image
+
+
+def get_box(
+    image: np.ndarray,
+    model: int = 1,
+    correction_factor=None,
+    thresh: int = 127,
+):
+    """
+    本函数能够实现输入一张四通道图像，返回图像中最大连续非透明面积的区域的矩形坐标
+    本函数将采用 opencv 内置函数来解析整个图像的 mask，并提供一些参数，用于读取图像的位置信息
+    Args:
+        image: 四通道矩阵图像
+        model: 返回值模式
+        correction_factor: 提供一些边缘扩张接口，输入格式为 list 或者 int:[up, down, left, right]。
+                    举个例子，假设我们希望剪切出的矩形框左边能够偏左 1 个像素，则输入 [0, 0, 1, 0]；
+                        如果希望右边偏右 1 个像素，则输入 [0, 0, 0, 1]
+                    如果输入为 int，则默认只会对左右两边做拓展，比如输入 2，则和 [0, 0, 2, 2] 是等效的
+        thresh: 二值化阈值，为了保持一些羽化效果，thresh 必须要小
+    Returns:
+        model 为 1 时，将会返回切割出的矩形框的四个坐标点信息
+        model 为 2 时，将会返回矩形框四边相距于原图四边的距离
+    """
+    # ------------ 数据格式规范部分 -------------- #
+    # 输入必须为四通道
+    if correction_factor is None:
+        correction_factor = [0, 0, 0, 0]
+    if not isinstance(image, np.ndarray) or len(cv2.split(image)) != 4:
+        raise TypeError("输入的图像必须为四通道 np.ndarray 类型矩阵！")
+    # correction_factor 规范化
+    if isinstance(correction_factor, int):
+        correction_factor = [0, 0, correction_factor, correction_factor]
+    elif not isinstance(correction_factor, list):
+        raise TypeError("correction_factor 必须为 int 或者 list 类型！")
+    # ------------ 数据格式规范完毕 -------------- #
+    # 分离 mask
+    _, _, _, mask = cv2.split(image)
+    # mask 二值化处理
+    _, mask = cv2.threshold(mask, thresh=thresh, maxval=255, type=0)
+    contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    temp = np.ones(image.shape, np.uint8) * 255
+    cv2.drawContours(temp, contours, -1, (0, 0, 255), -1)
+    contours_area = []
+    for cnt in contours:
+        contours_area.append(cv2.contourArea(cnt))
+    idx = contours_area.index(max(contours_area))
+    x, y, w, h = cv2.boundingRect(contours[idx])  # 框出图像
+    # ------------ 开始输出数据 -------------- #
+    height, width, _ = image.shape
+    y_up = y - correction_factor[0] if y - correction_factor[0] >= 0 else 0
+    y_down = (
+        y + h + correction_factor[1]
+        if y + h + correction_factor[1] < height
+        else height - 1
+    )
+    x_left = x - correction_factor[2] if x - correction_factor[2] >= 0 else 0
+    x_right = (
+        x + w + correction_factor[3]
+        if x + w + correction_factor[3] < width
+        else width - 1
+    )
+    if model == 1:
+        # model=1，将会返回切割出的矩形框的四个坐标点信息
+        return [y_up, y_down, x_left, x_right]
+    elif model == 2:
+        # model=2, 将会返回矩形框四边相距于原图四边的距离
+        return [y_up, height - y_down, x_left, width - x_right]
+    else:
+        raise EOFError("请选择正确的模式！")
+
+
+def detect_distance(value, crop_height, max=0.06, min=0.04):
+    """
+    检测人头顶与照片顶部的距离是否在适当范围内。
+    输入：与顶部的差值
+    输出：(status, move_value)
+    status=0 不动
+    status=1 人脸应向上移动（裁剪框向下移动）
+    status-2 人脸应向下移动（裁剪框向上移动）
+    ---------------------------------------
+    value：头顶与照片顶部的距离
+    crop_height: 裁剪框的高度
+    max: 距离的最大值
+    min: 距离的最小值
+    ---------------------------------------
+    """
+    value = value / crop_height  # 头顶往上的像素占图像的比例
+    if min <= value <= max:
+        return 0, 0
+    elif value > max:
+        # 头顶往上的像素比例高于 max
+        move_value = value - max
+        move_value = int(move_value * crop_height)
+        # print("上移{}".format(move_value))
+        return 1, move_value
+    else:
+        # 头顶往上的像素比例低于 min
+        move_value = min - value
+        move_value = int(move_value * crop_height)
+        # print("下移{}".format(move_value))
+        return -1, move_value

hivision_modnet.onnx → hivision/creator/weights/modnet_photographic_portrait_matting.onnx

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

hivision/error.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 18:32
+@File: error.py
+@IDE: pycharm
+@Description:
+    错误处理
+"""
+
+
+class FaceError(Exception):
+    def __init__(self, err, face_num):
+        """
+        证件照人脸错误，此时人脸检测失败，可能是没有检测到人脸或者检测到多个人脸
+        Args:
+            err: 错误描述
+            face_num: 告诉此时识别到的人像个数
+        """
+        super().__init__(err)
+        self.face_num = face_num

hivision/utils.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""
+@DATE: 2024/9/5 21:52
+@File: utils.py
+@IDE: pycharm
+@Description:
+    hivision提供的工具函数
+"""
+from PIL import Image
+import io
+import numpy as np
+import cv2
+import base64
+
+
+def resize_image_to_kb(input_image, output_image_path, target_size_kb):
+    """
+    Resize an image to a target size in KB.
+    将图像调整大小至目标文件大小（KB）。
+
+    :param input_image_path: Path to the input image. 输入图像的路径。
+    :param output_image_path: Path to save the resized image. 保存调整大小后的图像的路径。
+    :param target_size_kb: Target size in KB. 目标文件大小（KB）。
+
+    Example:
+    resize_image_to_kb('input_image.jpg', 'output_image.jpg', 50)
+    """
+
+    if isinstance(input_image, np.ndarray):
+        img = Image.fromarray(input_image)
+    elif isinstance(input_image, Image.Image):
+        img = input_image
+    else:
+        raise ValueError("input_image must be a NumPy array or PIL Image.")
+
+    # Convert image to RGB mode if it's not
+    if img.mode != "RGB":
+        img = img.convert("RGB")
+
+    # Initial quality value
+    quality = 95
+
+    while True:
+        # Create a BytesIO object to hold the image data in memory
+        img_byte_arr = io.BytesIO()
+
+        # Save the image to the BytesIO object with the current quality
+        img.save(img_byte_arr, format="JPEG", quality=quality)
+
+        # Get the size of the image in KB
+        img_size_kb = len(img_byte_arr.getvalue()) / 1024
+
+        # Check if the image size is within the target size
+        if img_size_kb <= target_size_kb or quality == 1:
+            # If the image is smaller than the target size, add padding
+            if img_size_kb < target_size_kb:
+                padding_size = int(
+                    (target_size_kb * 1024) - len(img_byte_arr.getvalue())
+                )
+                padding = b"\x00" * padding_size
+                img_byte_arr.write(padding)
+
+            # Save the image to the output path
+            with open(output_image_path, "wb") as f:
+                f.write(img_byte_arr.getvalue())
+            break
+
+        # Reduce the quality if the image is still too large
+        quality -= 5
+
+        # Ensure quality does not go below 1
+        if quality < 1:
+            quality = 1
+
+
+def resize_image_to_kb_base64(input_image, target_size_kb):
+    """
+    Resize an image to a target size in KB and return it as a base64 encoded string.
+    将图像调整大小至目标文件大小（KB）并返回base64编码的字符串。
+
+    :param input_image: Input image as a NumPy array or PIL Image. 输入图像，可以是NumPy数组或PIL图像。
+    :param target_size_kb: Target size in KB. 目标文件大小（KB）。
+
+    :return: Base64 encoded string of the resized image. 调整大小后的图像的base64编码字符串。
+    """
+
+    if isinstance(input_image, np.ndarray):
+        img = Image.fromarray(input_image)
+    elif isinstance(input_image, Image.Image):
+        img = input_image
+    else:
+        raise ValueError("input_image must be a NumPy array or PIL Image.")
+
+    # Convert image to RGB mode if it's not
+    if img.mode != "RGB":
+        img = img.convert("RGB")
+
+    # Initial quality value
+    quality = 95
+
+    while True:
+        # Create a BytesIO object to hold the image data in memory
+        img_byte_arr = io.BytesIO()
+
+        # Save the image to the BytesIO object with the current quality
+        img.save(img_byte_arr, format="JPEG", quality=quality)
+
+        # Get the size of the image in KB
+        img_size_kb = len(img_byte_arr.getvalue()) / 1024
+
+        # Check if the image size is within the target size
+        if img_size_kb <= target_size_kb or quality == 1:
+            # If the image is smaller than the target size, add padding
+            if img_size_kb < target_size_kb:
+                padding_size = int(
+                    (target_size_kb * 1024) - len(img_byte_arr.getvalue())
+                )
+                padding = b"\x00" * padding_size
+                img_byte_arr.write(padding)
+
+            # Encode the image data to base64
+            img_base64 = base64.b64encode(img_byte_arr.getvalue()).decode("utf-8")
+            return img_base64
+
+        # Reduce the quality if the image is still too large
+        quality -= 5
+
+        # Ensure quality does not go below 1
+        if quality < 1:
+            quality = 1
+
+
+def numpy_2_base64(img: np.ndarray):
+    _, buffer = cv2.imencode(".png", img)
+    base64_image = base64.b64encode(buffer).decode("utf-8")
+
+    return base64_image
+
+
+def save_numpy_image(numpy_img, file_path):
+    # 检查数组的形状
+    if numpy_img.shape[2] == 4:
+        # 将 BGR 转换为 RGB，并保留透明通道
+        rgb_img = np.concatenate(
+            (np.flip(numpy_img[:, :, :3], axis=-1), numpy_img[:, :, 3:]), axis=-1
+        ).astype(np.uint8)
+        img = Image.fromarray(rgb_img, mode="RGBA")
+    else:
+        # 将 BGR 转换为 RGB
+        rgb_img = np.flip(numpy_img, axis=-1).astype(np.uint8)
+        img = Image.fromarray(rgb_img, mode="RGB")
+
+    img.save(file_path)
+
+
+def numpy_to_bytes(numpy_img):
+    img = Image.fromarray(numpy_img)
+    img_byte_arr = io.BytesIO()
+    img.save(img_byte_arr, format="PNG")
+    img_byte_arr.seek(0)
+    return img_byte_arr
+
+
+def hex_to_rgb(value):
+    value = value.lstrip("#")
+    length = len(value)
+    return tuple(
+        int(value[i : i + length // 3], 16) for i in range(0, length, length // 3)
+    )
+
+
+def generate_gradient(start_color, width, height, mode="updown"):
+    # 定义背景颜色
+    end_color = (255, 255, 255)  # 白色
+
+    # 创建一个空白图像
+    r_out = np.zeros((height, width), dtype=int)
+    g_out = np.zeros((height, width), dtype=int)
+    b_out = np.zeros((height, width), dtype=int)
+
+    if mode == "updown":
+        # 生成上下渐变色
+        for y in range(height):
+            r = int(
+                (y / height) * end_color[0] + ((height - y) / height) * start_color[0]
+            )
+            g = int(
+                (y / height) * end_color[1] + ((height - y) / height) * start_color[1]
+            )
+            b = int(
+                (y / height) * end_color[2] + ((height - y) / height) * start_color[2]
+            )
+            r_out[y, :] = r
+            g_out[y, :] = g
+            b_out[y, :] = b
+
+    else:
+        # 生成中心渐变色
+        img = np.zeros((height, width, 3))
+        # 定义椭圆中心和半径
+        center = (width // 2, height // 2)
+        end_axies = max(height, width)
+        # 定义渐变色
+        end_color = (255, 255, 255)
+        # 绘制椭圆
+        for y in range(end_axies):
+            axes = (end_axies - y, end_axies - y)
+            r = int(
+                (y / end_axies) * end_color[0]
+                + ((end_axies - y) / end_axies) * start_color[0]
+            )
+            g = int(
+                (y / end_axies) * end_color[1]
+                + ((end_axies - y) / end_axies) * start_color[1]
+            )
+            b = int(
+                (y / end_axies) * end_color[2]
+                + ((end_axies - y) / end_axies) * start_color[2]
+            )
+
+            cv2.ellipse(img, center, axes, 0, 0, 360, (b, g, r), -1)
+        b_out, g_out, r_out = cv2.split(np.uint64(img))
+
+    return r_out, g_out, b_out
+
+
+def add_background(input_image, bgr=(0, 0, 0), mode="pure_color"):
+    """
+    本函数的功能为为透明图像加上背景。
+    :param input_image: numpy.array(4 channels), 透明图像
+    :param bgr: tuple, 合成纯色底时的 BGR 值
+    :param new_background: numpy.array(3 channels)，合成自定义图像底时的背景图
+    :return: output: 合成好的输出图像
+    """
+    height, width = input_image.shape[0], input_image.shape[1]
+    b, g, r, a = cv2.split(input_image)
+    a_cal = a / 255
+    if mode == "pure_color":
+        # 纯色填充
+        b2 = np.full([height, width], bgr[0], dtype=int)
+        g2 = np.full([height, width], bgr[1], dtype=int)
+        r2 = np.full([height, width], bgr[2], dtype=int)
+    elif mode == "updown_gradient":
+        b2, g2, r2 = generate_gradient(bgr, width, height, mode="updown")
+    else:
+        b2, g2, r2 = generate_gradient(bgr, width, height, mode="center")
+
+    output = cv2.merge(
+        ((b - b2) * a_cal + b2, (g - g2) * a_cal + g2, (r - r2) * a_cal + r2)
+    )
+
+    return output

hivisionai/app.py

@@ -1,452 +0,0 @@
-# -*- 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

@@ -1,406 +0,0 @@
-"""
-焕影小程序功能服务端的基本工具函数,以类的形式封装
-"""
-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
-
-

hivisionai/hyService/dbTools.py

@@ -1,337 +0,0 @@
-import os
-import pymongo
-import datetime
-import time
-from .cloudService import GetConfig
-local_path = os.path.dirname(__file__)
-
-
-class DBUtils(GetConfig):
-    """
-    从安全的角度出发,将一些默认配置文件上传至COS中,接下来使用COS和它的子类的时候,在第一次使用时需要输入Cuny给的id和key
-    用于连接数据库等对象
-    当然,在db_default_download = False的时候,如果在运行路径下已经有配置文件了,
-    那么就不用再次下载了,也不用输入id和key
-    事实上这只需要运行一次,因为配置文件将会被下载至源码文件夹中
-    如果要自定义路径,请在继承的子类中编写__init__函数,将service_path定向到指定路径
-    """
-    __BASE_DIR: dict = None
-    __PARAMS_DIR: dict = None
-    db_base_path: str = f"{local_path}/conf/base_config.json"
-    db_params_path: str = f"{local_path}/conf/params.json"
-    db_default_download: bool = False
-
-    @property
-    def base_config(self):
-        if self.__BASE_DIR is None:
-            self.__BASE_DIR = self.load_json(self.db_base_path, self.db_default_download)
-        return self.__BASE_DIR
-
-    @property
-    def db_config(self):
-        return self.base_config["database_config"]
-
-    @property
-    def params_config(self):
-        if self.__PARAMS_DIR is None:
-            self.__PARAMS_DIR = self.load_json(self.db_params_path, self.db_default_download)
-        return self.__PARAMS_DIR
-
-    @property
-    def size_dir(self):
-        return self.params_config["size_config"]
-
-    @property
-    def func_dir(self):
-        return self.params_config["func_config"]
-
-    @property
-    def wx_config(self):
-        return self.base_config["wx_config"]
-
-    def get_dbClient(self):
-        return pymongo.MongoClient(self.db_config["connect_url"])
-
-    @staticmethod
-    def get_time(yyyymmdd=None, delta_date=0):
-        """
-        给出当前的时间
-        :param yyyymmdd: 以yyyymmdd给出的日期时间
-        :param delta_date: 获取减去delta_day后的时间，默认为0就是当天
-        时间格式:yyyy_mm_dd
-        """
-        if yyyymmdd is None:
-            now_time = (datetime.datetime.now() - datetime.timedelta(delta_date)).strftime("%Y-%m-%d")
-            return now_time
-        # 输入了yyyymmdd的数据和delta_date,通过这两个数据返回距离yyyymmdd   delta_date天的时间
-        pre_time = datetime.datetime(int(yyyymmdd[0:4]), int(yyyymmdd[4:6]), int(yyyymmdd[6:8]))
-        return (pre_time - datetime.timedelta(delta_date)).strftime("%Y-%m-%d")
-
-    # 获得时间戳
-    def get_timestamp(self, date_time:str=None) -> int:
-        """
-        输入的日期形式为:"2021-11-29 16:39:45.999"
-        真正必须输入的是前十个字符,及精确到日期,后面的时间可以不输入,不输入则默认置零
-        """
-        def standardDateTime(dt:str) -> str:
-            """
-            规范化时间字符串
-            """
-            if len(dt) < 10:
-                raise ValueError("你必须至少输入准确到天的日期!比如:2021-11-29")
-            elif len(dt) == 10:
-                return dt + " 00:00:00.0"
-            else:
-                try:
-                    date, time = dt.split(" ")
-                except ValueError:
-                    raise ValueError("你只能也必须在日期与具体时间之间增加一个空格,其他地方不能出现空格!")
-                while len(time) < 10:
-                    if len(time) in (2, 5):
-                        time += ":"
-                    elif len(time) == 8:
-                        time += "."
-                    else:
-                        time += "0"
-                return date + " " + time
-        if date_time is None:
-            # 默认返回当前时间(str), date_time精确到毫秒
-            date_time = datetime.datetime.now()
-        # 转换成时间戳
-        else:
-            date_time = standardDateTime(dt=date_time)
-            date_time = datetime.datetime.strptime(date_time, "%Y-%m-%d %H:%M:%S.%f")
-        timestamp_ms = int(time.mktime(date_time.timetuple()) * 1000.0 + date_time.microsecond / 1000.0)
-        return timestamp_ms
-
-    @staticmethod
-    def get_standardTime(yyyy_mm_dd: str):
-        return yyyy_mm_dd[0:4] + yyyy_mm_dd[5:7] + yyyy_mm_dd[8:10]
-
-    def find_oneDay_data(self, db_name: str, collection_name: str, date: str = None) -> dict:
-        """
-        获取指定天数的数据，如果date is None，就自动寻找距今最近的有数据的那一天的数据
-        """
-        df = None  # 应该被返回的数据
-        collection = self.get_dbClient()[db_name][collection_name]
-        if date is None:  # 自动寻找前几天的数据,最多三十天
-            for delta_date in range(1, 31):
-                date_yyyymmdd = self.get_standardTime(self.get_time(delta_date=delta_date))
-                filter_ = {"date": date_yyyymmdd}
-                df = collection.find_one(filter=filter_)
-                if df is not None:
-                    del df["_id"]
-                    break
-        else:
-            filter_ = {"date": date}
-            df = collection.find_one(filter=filter_)
-            if df is not None:
-                del df["_id"]
-        return df
-
-    def find_daysData_byPeriod(self, date_period: tuple, db_name: str, col_name: str):
-        # 给出一个指定的范围日期，返回相应的数据(日期的两头都会被寻找)
-        # 这个函数我们默认数据库中的数据是连续的，即不会出现在 20211221 到 20211229 之间有一天没有数据的情况
-        if len(date_period) != 2:
-            raise ValueError("date_period数据结构：(开始日期，截止日期)")
-        start, end = date_period  # yyyymmdd
-        delta_date = int(end) - int(start)
-        if delta_date < 0:
-            raise ValueError("传入的日期有误！")
-        collection = self.get_dbClient()[db_name][col_name]
-        date = start
-        while int(date) <= int(end):
-            yield collection.find_one(filter={"date": date})
-            date = self.get_standardTime(self.get_time(date, -1))
-
-    @staticmethod
-    def find_biggest_valueDict(dict_: dict):
-        # 寻找字典中数值最大的字段，要求输入的字典的字段值全为数字
-        while len(dict_) > 0:
-            max_value = 0
-            p = None
-            for key in dict_:
-                if dict_[key] > max_value:
-                    p = key
-                    max_value = dict_[key]
-            yield p, max_value
-            del dict_[p]
-
-    def copy_andAdd_dict(self, dict_base, dict_):
-        # 深度拷贝字典，将后者赋值给前者
-        # 如果后者的键名在前者已经存在，则直接相加。这就要求两者的数据是数值型
-        for key in dict_:
-            if key not in dict_base:
-                dict_base[key] = dict_[key]
-            else:
-                if isinstance(dict_[key], int) or isinstance(dict_[key], float):
-                    dict_base[key] = round(dict_[key] + dict_base[key], 2)
-                else:
-                    dict_base[key] = self.copy_andAdd_dict(dict_base[key], dict_[key])
-        return dict_base
-
-    @staticmethod
-    def compare_data(dict1: dict, dict2: dict, suffix: str, save: int, **kwargs):
-        """
-        有两个字典,并且通过kwargs会传输一个新的字典,根据字典中的键值我们进行比对,处理成相应的数据格式
-        并且在dict1中,生成一个新的键值,为kwargs中的元素+suffix
-        save:保留几位小数
-        """
-        new_dict = dict1.copy()
-        for key in kwargs:
-            try:
-                if kwargs[key] not in dict2 or int(dict2[kwargs[key]]) == -1 or float(dict1[kwargs[key]]) <= 0.0:
-                    # 数据不存在
-                    data_new = 5002
-                else:
-                    try:
-                        data_new = round(
-                            ((float(dict1[kwargs[key]]) - float(dict2[kwargs[key]])) / float(dict2[kwargs[key]])) * 100
-                            , save)
-                    except ZeroDivisionError:
-                        data_new = 5002
-                    if data_new == 0.0:
-                        data_new = 0
-            except TypeError as e:
-                print(e)
-                data_new = 5002  # 如果没有之前的数据,默认返回0
-            new_dict[kwargs[key] + suffix] = data_new
-        return new_dict
-
-    @staticmethod
-    def sum_dictList_byKey(dictList: list, **kwargs) -> dict:
-        """
-        有一个列表,列表中的元素为字典,并且所有字典都有一个键值为key的字段,字段值为数字
-        我们将每一个字典的key字段提取后相加,得到该字段值之和.
-        """
-        sum_num = {}
-        if kwargs is None:
-            raise ImportError("Please input at least ONE key")
-        for key in kwargs:
-            sum_num[kwargs[key]] = 0
-        for dict_ in dictList:
-            if not isinstance(dict_, dict):
-                raise TypeError("object is not DICT!")
-            for key in kwargs:
-                sum_num[kwargs[key]] += dict_[kwargs[key]]
-        return sum_num
-
-    @staticmethod
-    def sum_2ListDict(list_dict1: list, list_dict2: list, key_name, data_name):
-        """
-        有两个列表,列表内的元素为字典,我们根据key所对应的键值寻找列表中键值相同的两个元素,将他们的data对应的键值相加
-        生成新的列表字典(其余键值被删除)
-        key仅在一个列表中存在,则直接加入新的列表字典
-        """
-        sum_list = []
-
-        def find_sameKey(kn, key_, ld: list) -> int:
-            for dic_ in ld:
-                if dic_[kn] == key_:
-                    post_ = ld.index(dic_)
-                    return post_
-            return -1
-
-        for dic in list_dict1:
-            key = dic[key_name]  # 键名
-            post = find_sameKey(key_name, key, list_dict2)  # 在list2中寻找相同的位置
-            data = dic[data_name] + list_dict2[post][data_name] if post != -1 else dic[data_name]
-            sum_list.append({key_name: key, data_name: data})
-        return sum_list
-
-    @staticmethod
-    def find_biggest_dictList(dictList: list, key: str = "key", data: str = "value"):
-        """
-        有一个列表，里面每一个元素都是一个字典
-        这些字典有一些共通性质，那就是里面都有一个key键名和一个data键名，后者的键值必须是数字
-        我们根据data键值的大小进行生成，每一次返回列表中data键值最大的数和它的key键值
-        """
-        while len(dictList) > 0:
-            point = 0
-            biggest_num = int(dictList[0][data])
-            biggest_key = dictList[0][key]
-            for i in range(len(dictList)):
-                num = int(dictList[i][data])
-                if num > biggest_num:
-                    point = i
-                    biggest_num = int(dictList[i][data])
-                    biggest_key = dictList[i][key]
-            yield str(biggest_key), biggest_num
-            del dictList[point]
-
-    def get_share_data(self, date_yyyymmdd: str):
-        # 获得用户界面情况
-        visitPage = self.find_oneDay_data(date=date_yyyymmdd,
-                                          db_name="cuny-user-analysis",
-                                          collection_name="daily-userVisitPage")
-        if visitPage is not None:
-            # 这一部分没有得到数据是可以容忍的.不用抛出模态框错误
-            # 获得昨日用户分享情况
-            sum_num = self.sum_dictList_byKey(dictList=visitPage["data_list"],
-                                              key1="page_share_pv",
-                                              key2="page_share_uv")
-        else:
-            # 此时将分享次数等置为-1
-            sum_num = {"page_share_pv": -1, "page_share_uv": -1}
-        return sum_num
-
-    @staticmethod
-    def compare_date(date1_yyyymmdd: str, date2_yyyymmdd: str):
-        # 如果date1是date2的昨天，那么就返回True
-        date1 = int(date1_yyyymmdd)
-        date2 = int(date2_yyyymmdd)
-        return True if date2 - date1 == 1 else False
-
-    def change_time(self, date_yyyymmdd: str, mode: int):
-        # 将yyyymmdd的数据分开为相应的数据形式
-        if mode == 1:
-            if self.compare_date(date_yyyymmdd, self.get_standardTime(self.get_time(delta_date=0))) is False:
-                return date_yyyymmdd[0:4] + "年" + date_yyyymmdd[4:6] + "月" + date_yyyymmdd[6:8] + "日"
-            else:
-                return "昨日"
-        elif mode == 2:
-            date = date_yyyymmdd[0:4] + "." + date_yyyymmdd[4:6] + "." + date_yyyymmdd[6:8]
-            if self.compare_date(date_yyyymmdd, self.get_standardTime(self.get_time(delta_date=0))) is True:
-                return date + "~" + date + " | 昨日"
-            else:
-                return date + "~" + date
-
-    @staticmethod
-    def changeList_dict2List_list(dl: list, order: list):
-        """
-        列表内是一个个字典,本函数将字典拆解,以order的形式排列键值为列表
-        考虑到一些格式的问题,这里我采用生成器的形式封装
-        """
-        for dic in dl:
-            # dic是列表内的字典元素
-            tmp = []
-            for key_name in order:
-                key = dic[key_name]
-                tmp.append(key)
-            yield tmp
-
-    def dict_mapping(self, dict_name: str, id_: str):
-        """
-        进行字典映射，输入字典名称和键名，返回具体的键值
-        如果不存在，则原路返回键名
-        """
-        try:
-            return getattr(self, dict_name)[id_]
-        except KeyError:
-            return id_
-        except AttributeError:
-            print(f"[WARNING]: 本对象内部不存在{dict_name}!")
-            return id_
-
-    @staticmethod
-    def dictAddKey(dic: dict, dic_tmp: dict, **kwargs):
-        """
-        往字典中加入参数，可迭代
-        """
-        for key in kwargs:
-            dic[key] = dic_tmp[key]
-        return dic
-
-
-if __name__ == "__main__":
-    dbu = DBUtils()

hivisionai/hyService/error.py

@@ -1,20 +0,0 @@
-"""
-@author: cuny
-@fileName: error.py
-@create_time: 2022/03/10 下午3:14
-@introduce:
-保存一些定义的错误类型
-"""
-class ProcessError(Exception):
-    def __init__(self, err):
-        super().__init__(err)
-        self.err = err
-    def __str__(self):
-        return self.err
-
-class WrongImageType(TypeError):
-    def __init__(self, err):
-        super().__init__(err)
-        self.err = err
-    def __str__(self):
-        return self.err