whitening

demo/locals.py

@@ -292,4 +292,20 @@ LOCALES = {
             "label": "抠图图像",
         },
     },
+    "beauty_tab": {
+        "en": {
+            "label": "Beauty",
+        },
+        "zh": {
+            "label": "美颜",
+        },
+    },
+    "whitening_strength": {
+        "en": {
+            "label": "whitening strength",
+        },
+        "zh": {
+            "label": "美白强度",
+        },
+    },
 }

demo/processor.py

@@ -1,13 +1,13 @@
 import numpy as np
 from hivision import IDCreator
 from hivision.error import FaceError, APIError
-from hivision.utils import add_background, resize_image_to_kb
+from hivision.utils import add_background, resize_image_to_kb, add_watermark
 from hivision.creator.layout_calculator import (
     generate_layout_photo,
     generate_layout_image,
 )
 from hivision.creator.choose_handler import choose_handler
-from demo.utils import add_watermark, range_check
+from demo.utils import range_check
 import gradio as gr
 import os
 import time
@@ -41,7 +41,7 @@ class IDPhotoProcessor:
         face_detect_option,
         head_measure_ratio=0.2,
         top_distance_max=0.12,
-        top_distance_min=0.10,
+        whitening_strength=0,
     ):
         top_distance_min = top_distance_max - 0.02
 
@@ -70,6 +70,8 @@ class IDPhotoProcessor:
                 return [
                     gr.update(value=None),  # img_output_standard
                     gr.update(value=None),  # img_output_standard_hd
+                    gr.update(value=None),  # img_output_standard_png
+                    gr.update(value=None),  # img_output_standard_hd_png
                     None,  # img_output_layout (assuming it should be None or not updated)
                     gr.update(  # notification
                         value=LOCALES["size_mode"][language]["custom_size_eror"],
@@ -113,6 +115,7 @@ class IDPhotoProcessor:
             idphoto_json["size_mode"] in LOCALES["size_mode"][language]["choices"][1]
         )
 
+        # 生成证件照
         try:
             result = creator(
                 input_image,
@@ -120,11 +123,15 @@ class IDPhotoProcessor:
                 size=idphoto_json["size"],
                 head_measure_ratio=head_measure_ratio,
                 head_top_range=(top_distance_max, top_distance_min),
+                whitening_strength=whitening_strength,
             )
+        # 如果检测到人脸数量不等于1
         except FaceError:
             return [
                 gr.update(value=None),  # img_output_standard
                 gr.update(value=None),  # img_output_standard_hd
+                gr.update(value=None),  # img_output_standard_png
+                gr.update(value=None),  # img_output_standard_hd_png
                 gr.update(visible=False),  # img_output_layout
                 gr.update(  # notification
                     value=LOCALES["notification"][language]["face_error"],
@@ -132,11 +139,12 @@ class IDPhotoProcessor:
                 ),
                 None,  # file_download (assuming it should be None or have no update)
             ]
-
+        # 如果 API 错误
         except APIError as e:
             return [
                 gr.update(value=None),  # img_output_standard
                 gr.update(value=None),  # img_output_standard_hd
+                gr.update(value=None),  # img_output_standard_png
                 gr.update(value=None),  # img_output_standard_hd_png
                 gr.update(visible=False),  # img_output_layout
                 gr.update(  # notification
@@ -145,13 +153,14 @@ class IDPhotoProcessor:
                 ),
                 None,  # file_download (assuming it should be None or have no update)
             ]
-
+        # 证件照生成正常
         else:
-            (result_image_standard, result_image_hd, _, _) = result
+            (result_image_standard, result_image_hd, _, _, _, _) = result
 
             result_image_standard_png = np.uint8(result_image_standard)
             result_image_hd_png = np.uint8(result_image_hd)
 
+            # 纯色渲染
             if (
                 idphoto_json["render_mode"]
                 == LOCALES["render_mode"][language]["choices"][0]
@@ -162,6 +171,7 @@ class IDPhotoProcessor:
                 result_image_hd = np.uint8(
                     add_background(result_image_hd, bgr=idphoto_json["color_bgr"])
                 )
+            # 上下渐变渲染
             elif (
                 idphoto_json["render_mode"]
                 == LOCALES["render_mode"][language]["choices"][1]
@@ -180,6 +190,7 @@ class IDPhotoProcessor:
                         mode="updown_gradient",
                     )
                 )
+            # 中心渐变渲染
             else:
                 result_image_standard = np.uint8(
                     add_background(
@@ -277,7 +288,7 @@ class IDPhotoProcessor:
                 return [
                     result_image_standard,  # img_output_standard
                     result_image_hd,  # img_output_standard_hd
-                    result_image_standard_png,  # img_output_standard_hd_png
+                    result_image_standard_png,  # img_output_standard_png
                     result_image_hd_png,  # img_output_standard_hd_png
                     result_layout_image,  # img_output_layout
                     gr.update(visible=False),  # notification
@@ -287,7 +298,7 @@ class IDPhotoProcessor:
                 return [
                     result_image_standard,  # img_output_standard
                     result_image_hd,  # img_output_standard_hd
-                    result_image_standard_png,  # img_output_standard_hd_png
+                    result_image_standard_png,  # img_output_standard_png
                     result_image_hd_png,  # img_output_standard_hd_png
                     result_layout_image,  # img_output_layout
                     gr.update(visible=False),  # notification

demo/ui.py

@@ -2,7 +2,12 @@ import gradio as gr
 import os
 import pathlib
 from demo.locals import LOCALES
-from hivision.creator.choose_handler import FACE_DETECT_MODELS
+from demo.processor import IDPhotoProcessor
+
+"""
+只裁切模式:
+1. 如果重新上传了照片，然后点击按钮，第一次会调用不裁切的模式，第二次会调用裁切的模式
+"""
 
 
 def load_description(fp):
@@ -12,7 +17,10 @@ def load_description(fp):
 
 
 def create_ui(
-    processor, root_dir, human_matting_models: list, face_detect_models: list
+    processor: IDPhotoProcessor,
+    root_dir: str,
+    human_matting_models: list,
+    face_detect_models: list,
 ):
     DEFAULT_LANG = "zh"
     DEFAULT_HUMAN_MATTING_MODEL = "modnet_photographic_portrait_matting"
@@ -55,6 +63,7 @@ def create_ui(
                         value=human_matting_models[0],
                     )
 
+                # TAB1 - 关键参数
                 with gr.Tab(
                     LOCALES["key_param"][DEFAULT_LANG]["label"]
                 ) as key_parameter_tab:
@@ -97,6 +106,7 @@ def create_ui(
                         value=LOCALES["render_mode"][DEFAULT_LANG]["choices"][0],
                     )
 
+                # TAB2 - 高级参数
                 with gr.Tab(
                     LOCALES["advance_param"][DEFAULT_LANG]["label"]
                 ) as advance_parameter_tab:
@@ -132,6 +142,20 @@ def create_ui(
                             interactive=True,
                         )
 
+                # TAB3 - 美颜
+                with gr.Tab(
+                    LOCALES["beauty_tab"][DEFAULT_LANG]["label"]
+                ) as beauty_parameter_tab:
+                    whitening_option = gr.Slider(
+                        label=LOCALES["whitening_strength"][DEFAULT_LANG]["label"],
+                        minimum=0,
+                        maximum=10,
+                        value=2,
+                        step=1,
+                        interactive=True,
+                    )
+
+                # TAB4 - 水印
                 with gr.Tab(
                     LOCALES["watermark_tab"][DEFAULT_LANG]["label"]
                 ) as watermark_parameter_tab:
@@ -379,6 +403,12 @@ def create_ui(
                     matting_image_accordion: gr.update(
                         label=LOCALES["matting_image"][language]["label"]
                     ),
+                    beauty_parameter_tab: gr.update(
+                        label=LOCALES["beauty_tab"][language]["label"]
+                    ),
+                    whitening_option: gr.update(
+                        label=LOCALES["whitening_strength"][language]["label"]
+                    ),
                 }
 
             def change_color(colors):
@@ -417,6 +447,7 @@ def create_ui(
                     return {custom_image_kb: gr.update(visible=False)}
 
             # ---------------- 绑定事件 ----------------
+            # 语言切换
             language_options.input(
                 change_language,
                 inputs=[language_options],
@@ -450,6 +481,8 @@ def create_ui(
                     watermark_text_space,
                     watermark_options,
                     matting_image_accordion,
+                    beauty_parameter_tab,
+                    whitening_option,
                 ],
             )
 
@@ -494,6 +527,7 @@ def create_ui(
                     face_detect_model_options,
                     head_measure_ratio_option,
                     top_distance_option,
+                    whitening_option,
                 ],
                 outputs=[
                     img_output_standard,

demo/utils.py

@@ -42,20 +42,3 @@ def csv_to_color_list(csv_file: str) -> dict:
 def range_check(value, min_value=0, max_value=255):
     value = int(value)
     return max(min_value, min(value, max_value))
-
-
-def add_watermark(
-    image, text, size=50, opacity=0.5, angle=45, color="#8B8B1B", space=75
-):
-    image = Image.fromarray(image)
-    watermarker = Watermarker(
-        input_image=image,
-        text=text,
-        style=WatermarkerStyles.STRIPED,
-        angle=angle,
-        color=color,
-        opacity=opacity,
-        size=size,
-        space=space,
-    )
-    return np.array(watermarker.image.convert("RGB"))

hivision/creator/__init__.py

@@ -12,7 +12,8 @@ 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_mtcnn, detect_face_face_plusplus
+from .face_detector import detect_face_mtcnn
+from hivision.plugin.beauty.whitening import make_whitening
 from .photo_adjuster import adjust_photo
 
 
@@ -51,18 +52,24 @@ class IDCreator:
         image: np.ndarray,
         size: Tuple[int, int] = (413, 295),
         change_bg_only: bool = False,
+        crop_only: bool = False,
         head_measure_ratio: float = 0.2,
         head_height_ratio: float = 0.45,
         head_top_range: float = (0.12, 0.1),
+        face: Tuple[int, int, int, int] = None,
+        whitening_strength: int = 0,
     ) -> Result:
         """
         证件照处理函数
         :param image: 输入图像
-        :param change_bg_only: 是否只需要换底
+        :param change_bg_only: 是否只需要抠图
+        :param crop_only: 是否只需要裁剪
         :param size: 输出的图像大小（h,w)
         :param head_measure_ratio: 人脸面积与全图面积的期望比值
         :param head_height_ratio: 人脸中心处在全图高度的比例期望值
         :param head_top_range: 头距离顶部的比例（max,min)
+        :param face: 人脸坐标
+        :param whitening_strength: 美白强度
 
         :return: 返回处理后的证件照和一系列参数
         """
@@ -73,6 +80,9 @@ class IDCreator:
             head_measure_ratio=head_measure_ratio,
             head_height_ratio=head_height_ratio,
             head_top_range=head_top_range,
+            crop_only=crop_only,
+            face=face,
+            whitening_strength=whitening_strength,
         )
         self.ctx = Context(params)
         ctx = self.ctx
@@ -82,30 +92,51 @@ class IDCreator:
         )  # 将输入图片 resize 到最大边长为 2000
         ctx.origin_image = ctx.processing_image.copy()
         self.before_all and self.before_all(ctx)
+
+        # 美白
+        if ctx.params.whitening_strength > 0:
+            ctx.processing_image = make_whitening(
+                ctx.processing_image, ctx.params.whitening_strength
+            )
+
         # 1. 人像抠图
-        self.matting_handler(ctx)
-        self.after_matting and self.after_matting(ctx)
+        if not ctx.params.crop_only:
+            # 调用抠图工作流
+            self.matting_handler(ctx)
+            self.after_matting and self.after_matting(ctx)
+        else:
+            ctx.matting_image = ctx.processing_image
+
+        # 如果仅换底，则直接返回抠图结果
         if ctx.params.change_bg_only:
             ctx.result = Result(
                 standard=ctx.matting_image,
                 hd=ctx.matting_image,
+                matting=ctx.matting_image,
                 clothing_params=None,
                 typography_params=None,
+                face=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)
         )
+
+        # 4. 返回结果
         ctx.result = Result(
             standard=result_image_standard,
             hd=result_image_hd,
+            matting=ctx.matting_image,
             clothing_params=clothing_params,
             typography_params=typography_params,
+            face=ctx.face,
         )
         self.after_all and self.after_all(ctx)
         return ctx.result

hivision/creator/context.py

@@ -16,15 +16,21 @@ class Params:
         self,
         size: Tuple[int, int] = (413, 295),
         change_bg_only: bool = False,
+        crop_only: bool = False,
         head_measure_ratio: float = 0.2,
         head_height_ratio: float = 0.45,
         head_top_range: float = (0.12, 0.1),
+        face: Tuple[int, int, int, int] = None,
+        whitening_strength: int = 0,
     ):
         self.__size = size
         self.__change_bg_only = change_bg_only
+        self.__crop_only = crop_only
         self.__head_measure_ratio = head_measure_ratio
         self.__head_height_ratio = head_height_ratio
         self.__head_top_range = head_top_range
+        self.__face = face
+        self.__whitening_strength = whitening_strength
 
     @property
     def size(self):
@@ -46,17 +52,32 @@ class Params:
     def head_top_range(self):
         return self.__head_top_range
 
+    @property
+    def crop_only(self):
+        return self.__crop_only
+
+    @property
+    def face(self):
+        return self.__face
+
+    @property
+    def whitening_strength(self):
+        return self.__whitening_strength
+
 
 class Result:
     def __init__(
         self,
         standard: np.ndarray,
         hd: np.ndarray,
+        matting: np.ndarray,
         clothing_params: Optional[dict],
         typography_params: Optional[dict],
+        face: Optional[Tuple[int, int, int, int, float]],
     ):
         self.standard = standard
         self.hd = hd
+        self.matting = matting
         self.clothing_params = clothing_params
         """
         服装参数，仅换底时为 None
@@ -65,10 +86,18 @@ class Result:
         """
         排版参数，仅换底时为 None
         """
+        self.face = face
 
     def __iter__(self):
         return iter(
-            [self.standard, self.hd, self.clothing_params, self.typography_params]
+            [
+                self.standard,
+                self.hd,
+                self.matting,
+                self.clothing_params,
+                self.typography_params,
+                self.face,
+            ]
         )
 
 

hivision/creator/retinaface/inference.py

@@ -1,6 +1,6 @@
 import numpy as np
 import cv2
-import onnxruntime as ort
+import onnxruntime
 from hivision.creator.retinaface.box_utils import decode, decode_landm
 from hivision.creator.retinaface.prior_box import PriorBox
 
@@ -46,10 +46,39 @@ keep_top_k = 750
 save_image = True
 vis_thres = 0.6
 
+ONNX_DEVICE = (
+    "CUDAExecutionProvider"
+    if onnxruntime.get_device() == "GPU"
+    else "CPUExecutionProvider"
+)
 
-def load_model_ort(model_path):
-    ort_session = ort.InferenceSession(model_path)
-    return ort_session
+
+def load_onnx_model(checkpoint_path, set_cpu=False):
+    providers = (
+        ["CUDAExecutionProvider", "CPUExecutionProvider"]
+        if ONNX_DEVICE == "CUDAExecutionProvider"
+        else ["CPUExecutionProvider"]
+    )
+
+    if set_cpu:
+        sess = onnxruntime.InferenceSession(
+            checkpoint_path, providers=["CPUExecutionProvider"]
+        )
+    else:
+        try:
+            sess = onnxruntime.InferenceSession(checkpoint_path, providers=providers)
+        except Exception as e:
+            if ONNX_DEVICE == "CUDAExecutionProvider":
+                print(f"Failed to load model with CUDAExecutionProvider: {e}")
+                print("Falling back to CPUExecutionProvider")
+                # 尝试使用CPU加载模型
+                sess = onnxruntime.InferenceSession(
+                    checkpoint_path, providers=["CPUExecutionProvider"]
+                )
+            else:
+                raise e  # 如果是CPU执行失败，重新抛出异常
+
+    return sess
 
 
 def retinaface_detect_faces(image, model_path: str, sess=None):
@@ -75,7 +104,7 @@ def retinaface_detect_faces(image, model_path: str, sess=None):
 
     # Load ONNX model
     if sess is None:
-        retinaface = load_model_ort(model_path)
+        retinaface = load_onnx_model(model_path, set_cpu=False)
     else:
         retinaface = sess
 

hivision/plugin/beauty/__init__.py

@@ -0,0 +1 @@
+from .beauty_tools import BeautyTools

hivision/plugin/beauty/beauty_tools.py

@@ -0,0 +1,49 @@
+"""
+@author: cuny
+@file: MakeBeautiful.py
+@time: 2022/7/7 20:23
+@description: 
+美颜工具集合文件，作为暴露在外的插件接口
+"""
+
+from .grind_skin import grindSkin
+from .whitening import MakeWhiter
+from .thin_face import thinFace
+import numpy as np
+
+
+def BeautyTools(
+    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

hivision/plugin/beauty/grind_skin.py

@@ -0,0 +1,44 @@
+"""
+@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.0, strength) / 10.0
+    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)))

hivision/plugin/beauty/thin_face.py

@@ -0,0 +1,304 @@
+"""
+@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.0
+    ):
+        """
+        采用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.0):
+    """
+    瘦脸程序接口，输入人脸关键点信息和强度，即可实现瘦脸
+    注意处理四通道图像
+    Args:
+        src: 原图
+        landmark: 关键点信息
+        place: 选择瘦脸区域，为0-4之间的值
+        strength: 瘦脸强度，输入值在0-10之间，如果小于或者等于0，则不瘦脸
+
+    Returns:
+        瘦脸后的图像
+    """
+    strength = min(100.0, strength * 10.0)
+    if strength <= 0.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)))

hivision/plugin/beauty/whitening.py

@@ -0,0 +1,83 @@
+import cv2
+import numpy as np
+import os
+import gradio as gr
+
+
+class LutWhite:
+    CUBE64_ROWS = 8
+    CUBE64_SIZE = 64
+    CUBE256_SIZE = 256
+    CUBE_SCALE = CUBE256_SIZE // CUBE64_SIZE
+
+    def __init__(self, lut_image):
+        self.lut = self._create_lut(lut_image)
+
+    def _create_lut(self, lut_image):
+        reshape_lut = np.zeros(
+            (self.CUBE256_SIZE, self.CUBE256_SIZE, self.CUBE256_SIZE, 3), dtype=np.uint8
+        )
+        for i in range(self.CUBE64_SIZE):
+            tmp = i // self.CUBE64_ROWS
+            cx = (i % self.CUBE64_ROWS) * self.CUBE64_SIZE
+            cy = tmp * self.CUBE64_SIZE
+            cube64 = lut_image[cy : cy + self.CUBE64_SIZE, cx : cx + self.CUBE64_SIZE]
+            if cube64.size == 0:
+                continue
+            cube256 = cv2.resize(cube64, (self.CUBE256_SIZE, self.CUBE256_SIZE))
+            reshape_lut[i * self.CUBE_SCALE : (i + 1) * self.CUBE_SCALE] = cube256
+        return reshape_lut
+
+    def apply(self, src):
+        b, g, r = src[:, :, 0], src[:, :, 1], src[:, :, 2]
+        return self.lut[b, g, r]
+
+
+class MakeWhiter:
+    def __init__(self, lut_image):
+        self.lut_white = LutWhite(lut_image)
+
+    def run(self, src: np.ndarray, strength: int) -> np.ndarray:
+        strength = np.clip(strength / 10.0, 0, 1)
+        if strength <= 0:
+            return src
+        img = self.lut_white.apply(src[:, :, :3])
+        return cv2.addWeighted(src[:, :, :3], 1 - strength, img, strength, 0)
+
+
+base_dir = os.path.dirname(os.path.abspath(__file__))
+default_lut = cv2.imread(os.path.join(base_dir, "lut/lut_origin.png"))
+make_whiter = MakeWhiter(default_lut)
+
+
+def make_whitening(image, strength):
+    image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    output_image = make_whiter.run(image, strength)
+    return cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB)
+
+
+def make_whitening_png(image, strength):
+    image = cv2.cvtColor(np.array(image), cv2.COLOR_RGBA2BGRA)
+
+    b, g, r, a = cv2.split(image)
+    bgr_image = cv2.merge((b, g, r))
+
+    b_w, g_w, r_w = cv2.split(make_whiter.run(bgr_image, strength))
+    output_image = cv2.merge((b_w, g_w, r_w, a))
+
+    return cv2.cvtColor(output_image, cv2.COLOR_RGBA2BGRA)
+
+
+# 启动Gradio应用
+if __name__ == "__main__":
+    demo = gr.Interface(
+        fn=make_whitening_png,
+        inputs=[
+            gr.Image(type="pil", image_mode="RGBA", label="Input Image"),
+            gr.Slider(0, 10, step=1, label="Whitening Strength"),
+        ],
+        outputs=gr.Image(type="pil"),
+        title="Image Whitening Demo",
+        description="Upload an image and adjust the whitening strength to see the effect.",
+    )
+    demo.launch()

hivision/utils.py

@@ -12,6 +12,7 @@ import io
 import numpy as np
 import cv2
 import base64
+from hivision.plugin.watermark import Watermarker, WatermarkerStyles
 
 
 def resize_image_to_kb(input_image, output_image_path, target_size_kb):
@@ -74,12 +75,6 @@ def resize_image_to_kb(input_image, output_image_path, target_size_kb):
             quality = 1
 
 
-import numpy as np
-from PIL import Image
-import io
-import base64
-
-
 def resize_image_to_kb_base64(input_image, target_size_kb, mode="exact"):
     """
     Resize an image to a target size in KB and return it as a base64 encoded string.
@@ -153,13 +148,20 @@ def resize_image_to_kb_base64(input_image, target_size_kb, mode="exact"):
     return img_base64
 
 
-def numpy_2_base64(img: np.ndarray):
+def numpy_2_base64(img: np.ndarray) -> str:
     _, buffer = cv2.imencode(".png", img)
     base64_image = base64.b64encode(buffer).decode("utf-8")
 
     return base64_image
 
 
+def base64_2_numpy(base64_image: str) -> np.ndarray:
+    img = base64.b64decode(base64_image)
+    img = np.frombuffer(img, np.uint8)
+
+    return img
+
+
 def save_numpy_image(numpy_img, file_path):
     # 检查数组的形状
     if numpy_img.shape[2] == 4:
@@ -273,3 +275,20 @@ def add_background(input_image, bgr=(0, 0, 0), mode="pure_color"):
     )
 
     return output
+
+
+def add_watermark(
+    image, text, size=50, opacity=0.5, angle=45, color="#8B8B1B", space=75
+):
+    image = Image.fromarray(image)
+    watermarker = Watermarker(
+        input_image=image,
+        text=text,
+        style=WatermarkerStyles.STRIPED,
+        angle=angle,
+        color=color,
+        opacity=opacity,
+        size=size,
+        space=space,
+    )
+    return np.array(watermarker.image.convert("RGB"))