src/cuny_tools.py

import cv2
import numpy as np
from hivisionai.hycv.utils import get_box_pro
from hivisionai.hycv.vision import cover_image, draw_picture_dots
from math import fabs, sin, radians, cos

def opencv_rotate(img, angle):
    h, w = img.shape[:2]
    center = (w / 2, h / 2)
    scale = 1.0
    # 2.1获取M矩阵
    """

    M矩阵

    [

    cosA -sinA (1-cosA)*centerX+sinA*centerY

    sinA cosA  -sinA*centerX+(1-cosA)*centerY

    ]

    """
    M = cv2.getRotationMatrix2D(center, angle, scale)
    # 2.2 新的宽高，radians(angle) 把角度转为弧度 sin(弧度)
    new_H = int(w * fabs(sin(radians(angle))) + h * fabs(cos(radians(angle))))
    new_W = int(h * fabs(sin(radians(angle))) + w * fabs(cos(radians(angle))))
    # 2.3 平移
    M[0, 2] += (new_W - w) / 2
    M[1, 2] += (new_H - h) / 2
    rotate = cv2.warpAffine(img, M, (new_W, new_H), borderValue=(0, 0, 0))
    return rotate


def transformationNeck2(image:np.ndarray, per_to_side:float=0.8)->np.ndarray:
    """

    透视变换脖子函数,输入图像和四个点(矩形框)

    矩形框内的图像可能是不完整的(边角有透明区域)

    我们将根据透视变换将矩形框内的图像拉伸成和矩形框一样的形状.

    算法分为几个步骤: 选择脖子的四个点 -> 选定这四个点拉伸后的坐标 -> 透视变换 -> 覆盖原图

    """
    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
    height, width = a.shape
    def locate_side(image_:np.ndarray, x_:int, y_max:int) -> int:
        # 寻找x=y, 且 y <= y_max 上从下往上第一个非0的点,如果没找到就返回0
        y_ = 0
        for y_ in range(y_max - 1, -1, -1):
            if image_[y_][x_] != 0:
                break
        return y_
    def locate_width(image_:np.ndarray, y_:int, mode, left_or_right:int=None):
        # 从y=y这个水平线上寻找两边的非零点
        # 增加left_or_right的原因在于为下面check_jaw服务
        if mode==1:  # 左往右
            x_ = 0
            if left_or_right is None:
                left_or_right = 0
            for x_ in range(left_or_right, width):
                if image_[y_][x_] != 0:
                    break
        else:  # 右往左
            x_ = width
            if left_or_right is None:
                left_or_right = width - 1
            for x_ in range(left_or_right, -1, -1):
                if image_[y_][x_] != 0:
                    break
        return x_
    def check_jaw(image_:np.ndarray, left_, right_):
        """

        检查选择的点是否与截到下巴,如果截到了,就往下平移一个单位

        """
        f= True # True代表没截到下巴
        # [x, y]
        for x_cell in range(left_[0] + 1, right_[0]):
            if image_[left_[1]][x_cell] == 0:
                f = False
                break
        if f is True:
            return left_, right_
        else:
            y_ = left_[1] + 2
            x_left_ = locate_width(image_, y_, mode=1, left_or_right=left_[0])
            x_right_ = locate_width(image_, y_, mode=2, left_or_right=right_[0])
            left_, right_ = check_jaw(image_, [x_left_, y_], [x_right_, y_])
        return left_, right_
    # 选择脖子的四个点,核心在于选择上面的两个点,这两个点的确定的位置应该是"宽出来的"两个点
    _, _ ,_, a = cv2.split(image)  # 这应该是一个四通道的图像
    ret,a_thresh = cv2.threshold(a,127,255,cv2.THRESH_BINARY)
    y_high, y_low, x_left, x_right = get_box_pro(image=image, model=1) # 直接返回矩阵信息
    y_left_side = locate_side(image_=a_thresh, x_=x_left, y_max=y_low)  # 左边的点的y轴坐标
    y_right_side = locate_side(image_=a_thresh, x_=x_right, y_max=y_low)  # 右边的点的y轴坐标
    y = min(y_left_side, y_right_side)  # 将两点的坐标保持相同
    cell_left_above, cell_right_above = check_jaw(a_thresh,[x_left, y], [x_right, y])
    x_left, x_right = cell_left_above[0], cell_right_above[0]
    # 此时我们寻找到了脖子的"宽出来的"两个点,这两个点作为上面的两个点, 接下来寻找下面的两个点
    if per_to_side >1:
        assert ValueError("per_to_side 必须小于1!")
    # 在后面的透视变换中我会把它拉成矩形, 在这里我先获取四个点的高和宽
    height_ = 150  # 这个值应该是个变化的值,与拉伸的长度有关,但是现在先规定为150
    width_ = x_right - x_left  # 其实也就是 cell_right_above[1] - cell_left_above[1]
    y = int((y_low - y)*per_to_side + y)  # 定位y轴坐标
    cell_left_below, cell_right_bellow = ([locate_width(a_thresh, y_=y, mode=1), y], [locate_width(a_thresh, y_=y, mode=2), y])
    # 四个点全齐,开始透视变换
    # 寻找透视变换后的四个点,只需要变换below的两个点即可
    # cell_left_below_final, cell_right_bellow_final = ([cell_left_above[1], y_low], [cell_right_above[1], y_low])
    # 需要变换的四个点为 cell_left_above, cell_right_above, cell_left_below, cell_right_bellow
    rect = np.array([cell_left_above, cell_right_above, cell_left_below, cell_right_bellow],
                    dtype='float32')
    # 变化后的坐标点
    dst = np.array([[0, 0], [width_, 0], [0 , height_], [width_, height_]],
                    dtype='float32')
    # 计算变换矩阵
    M = cv2.getPerspectiveTransform(rect, dst)
    warped = cv2.warpPerspective(image, M, (width_, height_))
    final = cover_image(image=warped, background=image, mode=3, x=cell_left_above[0], y=cell_left_above[1])
    # tmp = np.zeros(image.shape)
    # final = cover_image(image=warped, background=tmp, mode=3, x=cell_left_above[0], y=cell_left_above[1])
    # final = cover_image(image=image, background=final, mode=3, x=0, y=0)
    return final


def transformationNeck(image:np.ndarray, cutNeckHeight:int, neckBelow:int,

                       toHeight:int,per_to_side:float=0.75) -> np.ndarray:
    """

    脖子扩充算法, 其实需要输入的只是脖子扣出来的部分以及需要被扩充的高度/需要被扩充成的高度.

    """
    height, width, channels = image.shape
    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
    def locate_width(image_:np.ndarray, y_:int, mode, left_or_right:int=None):
        # 从y=y这个水平线上寻找两边的非零点
        # 增加left_or_right的原因在于为下面check_jaw服务
        if mode==1:  # 左往右
            x_ = 0
            if left_or_right is None:
                left_or_right = 0
            for x_ in range(left_or_right, width):
                if image_[y_][x_] != 0:
                    break
        else:  # 右往左
            x_ = width
            if left_or_right is None:
                left_or_right = width - 1
            for x_ in range(left_or_right, -1, -1):
                if image_[y_][x_] != 0:
                    break
        return x_
    def check_jaw(image_:np.ndarray, left_, right_):
        """

        检查选择的点是否与截到下巴,如果截到了,就往下平移一个单位

        """
        f= True # True代表没截到下巴
        # [x, y]
        for x_cell in range(left_[0] + 1, right_[0]):
            if image_[left_[1]][x_cell] == 0:
                f = False
                break
        if f is True:
            return left_, right_
        else:
            y_ = left_[1] + 2
            x_left_ = locate_width(image_, y_, mode=1, left_or_right=left_[0])
            x_right_ = locate_width(image_, y_, mode=2, left_or_right=right_[0])
            left_, right_ = check_jaw(image_, [x_left_, y_], [x_right_, y_])
        return left_, right_
    x_left = locate_width(image_=a_thresh, mode=1, y_=cutNeckHeight)
    x_right = locate_width(image_=a_thresh, mode=2, y_=cutNeckHeight)
    # 在这里我们取消了对下巴的检查,原因在于输入的imageHeight并不能改变
    # cell_left_above, cell_right_above = check_jaw(a_thresh, [x_left, imageHeight], [x_right, imageHeight])
    cell_left_above, cell_right_above = [x_left, cutNeckHeight], [x_right, cutNeckHeight]
    toWidth = x_right - x_left  # 矩形宽
    # 此时我们寻找到了脖子的"宽出来的"两个点,这两个点作为上面的两个点, 接下来寻找下面的两个点
    if per_to_side >1:
        assert ValueError("per_to_side 必须小于1!")
    y_below = int((neckBelow - cutNeckHeight) * per_to_side + cutNeckHeight)  # 定位y轴坐标
    cell_left_below = [locate_width(a_thresh, y_=y_below, mode=1), y_below]
    cell_right_bellow = [locate_width(a_thresh, y_=y_below, mode=2), y_below]
    # 四个点全齐,开始透视变换
    # 需要变换的四个点为 cell_left_above, cell_right_above, cell_left_below, cell_right_bellow
    rect = np.array([cell_left_above, cell_right_above, cell_left_below, cell_right_bellow],
                    dtype='float32')
    # 变化后的坐标点
    dst = np.array([[0, 0], [toWidth, 0], [0 , toHeight], [toWidth, toHeight]],
                    dtype='float32')
    M = cv2.getPerspectiveTransform(rect, dst)
    warped = cv2.warpPerspective(image, M, (toWidth, toHeight))
    # 将变换后的图像覆盖到原图上
    final = cover_image(image=warped, background=image, mode=3, x=cell_left_above[0], y=cell_left_above[1])
    return final


def bestJunctionCheck_beta(image:np.ndarray, stepSize:int=4, if_per:bool=False):
    """

    最优衔接点检测算法, 去寻找脖子的"拐点"

    """
    point_k = 1
    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
    height, width = a.shape
    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
    y_high, y_low, x_left, x_right = get_box_pro(image=image, model=1)  # 直接返回矩阵信息
    def scan(y_:int, max_num:int=2):
        num = 0
        left = False
        right = False
        for x_ in range(width):
            if a_thresh[y_][x_] != 0:
                if x_ < width // 2 and left is False:
                    num += 1
                    left = True
                elif x_ > width // 2 and right is False:
                    num += 1
                    right = True
        return True if num >= max_num else False
    def locate_neck_above():
        """

        定位脖子的尖尖脚

        """
        for y_ in range( y_high - 2, height):
            if scan(y_):
                return y_, y_
    y_high_left, y_high_right = locate_neck_above()
    def locate_width_pro(image_:np.ndarray, y_:int, mode):
        """

        这会是一个生成器,用于生成脖子两边的轮廓

        x_, y_ 是启始点的坐标,每一次寻找都会让y_+1

        mode==1说明是找左边的边,即,image_[y_][x_] == 0 且image_[y_][x_ + 1] !=0 时跳出;

            否则 当image_[y_][x_] != 0 时, x_ - 1; 当image_[y_][x_] == 0 且 image_[y_][x_ + 1] ==0 时x_ + 1

        mode==2说明是找右边的边,即,image_[y_][x_] == 0 且image_[y_][x_ - 1] !=0 时跳出

            否则 当image_[y_][x_] != 0 时, x_ + 1; 当image_[y_][x_] == 0 且 image_[y_][x_ - 1] ==0 时x_ - 1

        """
        y_ += 1
        if mode == 1:
            x_ = 0
            while 0 <= y_ < height and 0 <= x_ < width:
                while image_[y_][x_] != 0 and x_ >= 0:
                    x_ -= 1
                while image_[y_][x_] == 0 and image_[y_][x_ + 1] == 0 and x_ < width - 2:
                    x_ += 1
                yield [y_, x_]
                y_ += 1
        elif mode == 2:
            x_ = width-1
            while 0 <= y_ < height and 0 <= x_ < width:
                while image_[y_][x_] != 0  and x_ < width - 2: x_ += 1
                while image_[y_][x_] == 0 and image_[y_][x_ - 1] == 0 and x_ >= 0: x_ -= 1
                yield [y_, x_]
                y_ += 1
        yield False
    def kGenerator(image_:np.ndarray, mode):
        """

        导数生成器,用来生成每一个点对应的导数

        """
        y_ = y_high_left if mode == 1 else y_high_right
        c_generator = locate_width_pro(image_=image_, y_=y_, mode=mode)
        for cell in c_generator:
            nc = locate_width_pro(image_=image_, y_=cell[0] + stepSize, mode=mode)
            nextCell = next(nc)
            if nextCell is False:
                yield False, False
            else:
                k = (cell[1] - nextCell[1]) / stepSize
                yield k, cell
    def findPt(image_:np.ndarray, mode):
        k_generator = kGenerator(image_=image_, mode=mode)
        k, cell = next(k_generator)
        k_next, cell_next = next(k_generator)
        if k is False:
            raise ValueError("无法找到拐点!")
        while k_next is not False:
            k_next, cell_next = next(k_generator)
            if (k_next < - 1 / stepSize) or k_next > point_k:
                break
            cell = cell_next
        # return int(cell[0] + stepSize / 2)
        return cell[0]
    # 先找左边的拐点:
    pointY_left = findPt(image_=a_thresh, mode=1)
    # 再找右边的拐点:
    pointY_right = findPt(image_=a_thresh, mode=2)
    point = (pointY_left + pointY_right) // 2
    if if_per is True:
        point = (pointY_left + pointY_right) // 2
        return point / (y_low - y_high)
    pointX_left = next(locate_width_pro(image_=a_thresh, y_= point - 1, mode=1))[1]
    pointX_right = next(locate_width_pro(image_=a_thresh, y_=point- 1, mode=2))[1]
    return [pointX_left, point], [pointX_right, point]


def bestJunctionCheck(image:np.ndarray, offset:int, stepSize:int=4):
    """

    最优点检测算算法输入一张脖子图片(无论这张图片是否已经被二值化,我都认为没有被二值化),输出一个小数(脖子最上方与衔接点位置/脖子图像长度)

    与beta版不同的是它新增了一个阈值限定内容.

    对于脖子而言,我我们首先可以定位到上面的部分,然后根据上面的这个点向下进行遍历检测.

    与beta版类似,我们使用一个stepSize来用作斜率的检测

    但是对于遍历检测而言,与beta版不同的是,我们需要对遍历的地方进行一定的限制.

    限制的标准是,如果当前遍历的点的横坐标和起始点横坐标的插值超过了某个阈值,则认为是越界.

    """
    point_k = 1
    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
    height, width = a.shape
    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
    # 直接返回脖子的位置信息, 修正系数为0, get_box_pro内部也封装了二值化,所以直接输入原图
    y_high, y_low, _, _ = get_box_pro(image=image, model=1, correction_factor=0)
    # 真正有用的只有上下y轴的两个值...
    # 首先当然是确定起始点的位置,我们用同样的scan扫描函数进行行遍历.
    def scan(y_:int, max_num:int=2):
        num = 0
        # 设定两个值,分别代表脖子的左边和右边
        left = False
        right = False
        for x_ in range(width):
            if a_thresh[y_][x_] != 0:
                # 检测左边
                if x_ < width // 2 and left is False:
                    num += 1
                    left = True
                # 检测右边
                elif x_ > width // 2 and right is False:
                    num += 1
                    right = True
        return True if num >= max_num else False
    def locate_neck_above():
        """

        定位脖子的尖尖脚

        """
        # y_high就是脖子的最高点
        for y_ in range(y_high, height):
            if scan(y_):
                return y_
    y_start = locate_neck_above()  # 得到遍历的初始高度
    if y_low - y_start < stepSize: assert ValueError("脖子太小!")
    # 然后获取一下初始的坐标点
    x_left, x_right = 0, width
    for x_left_ in range(0, width):
        if a_thresh[y_start][x_left_] != 0:
            x_left = x_left_
            break
    for x_right_  in range(width -1 , -1, -1):
        if a_thresh[y_start][x_right_] != 0:
            x_right = x_right_
            break
    # 接下来我定义两个生成器,首先是脖子轮廓(向下寻找的)生成器,每进行一次next,生成器会返回y+1的脖子轮廓点
    def contoursGenerator(image_:np.ndarray, y_:int, mode):
        """

        这会是一个生成器,用于生成脖子两边的轮廓

        y_ 是启始点的y坐标,每一次寻找都会让y_+1

        mode==1说明是找左边的边,即,image_[y_][x_] == 0 且image_[y_][x_ + 1] !=0 时跳出;

            否则 当image_[y_][x_] != 0 时, x_ - 1; 当image_[y_][x_] == 0 且 image_[y_][x_ + 1] ==0 时x_ + 1

        mode==2说明是找右边的边,即,image_[y_][x_] == 0 且image_[y_][x_ - 1] !=0 时跳出

            否则 当image_[y_][x_] != 0 时, x_ + 1; 当image_[y_][x_] == 0 且 image_[y_][x_ - 1] ==0 时x_ - 1

        """
        y_ += 1
        try:
            if mode == 1:
                x_ = 0
                while 0 <= y_ < height and 0 <= x_ < width:
                    while image_[y_][x_] != 0 and x_ >= 0: x_ -= 1
                    # 这里其实会有bug,不过可以不管
                    while x_ < width and image_[y_][x_] == 0 and image_[y_][x_ + 1] == 0: x_ += 1
                    yield [y_, x_]
                    y_ += 1
            elif mode == 2:
                x_ = width-1
                while 0 <= y_ < height and 0 <= x_ < width:
                    while x_ < width and image_[y_][x_] != 0: x_ += 1
                    while x_ >= 0 and image_[y_][x_] == 0 and image_[y_][x_ - 1] == 0: x_ -= 1
                    yield [y_, x_]
                    y_ += 1
        # 当处理失败则返回False
        except IndexError:
            yield False
    # 然后是斜率生成器,这个生成器依赖子轮廓生成器,每一次生成轮廓后会计算斜率,另一个点的选取和stepSize有关
    def kGenerator(image_: np.ndarray, mode):
        """

        导数生成器,用来生成每一个点对应的导数

        """
        y_ = y_start
        # 对起始点建立一个生成器, mode=1时是左边轮廓,mode=2时是右边轮廓
        c_generator = contoursGenerator(image_=image_, y_=y_, mode=mode)
        for cell in c_generator:
            # 寻找距离当前cell距离为stepSize的轮廓点
            kc = contoursGenerator(image_=image_, y_=cell[0] + stepSize, mode=mode)
            kCell = next(kc)
            if kCell is False:
                # 寻找失败
                yield False, False
            else:
                # 寻找成功,返回当坐标点和斜率值
                # 对于左边而言,斜率必然是前一个点的坐标减去后一个点的坐标
                # 对于右边而言,斜率必然是后一个点的坐标减去前一个点的坐标
                k = (cell[1] - kCell[1]) / stepSize if mode == 1 else (kCell[1] - cell[1]) / stepSize
                yield k, cell
    # 接着开始写寻找算法,需要注意的是我们是分两边选择的
    def findPt(image_:np.ndarray, mode):
        x_base = x_left if mode == 1 else x_right
        k_generator = kGenerator(image_=image_, mode=mode)
        k, cell = k_generator.__next__()
        if k is False:
            raise ValueError("无法找到拐点!")
        k_next, cell_next = k_generator.__next__()
        while k_next is not False:
            cell = cell_next
            if cell[1] > x_base and mode == 2:
                x_base = cell[1]
            elif cell[1] < x_base and mode == 1:
                x_base = cell[1]
            # 跳出循环的方式一:斜率超过了某个值
            if k_next > point_k:
                print("K out")
                break
            # 跳出循环的方式二:超出阈值
            elif abs(cell[1] - x_base) > offset:
                print("O out")
                break
            k_next, cell_next = k_generator.__next__()
        if abs(cell[1] - x_base) > offset:
            cell[0] = cell[0] - offset - 1
        return cell[0]
    # 先找左边的拐点:
    pointY_left = findPt(image_=a_thresh, mode=1)
    # 再找右边的拐点:
    pointY_right = findPt(image_=a_thresh, mode=2)
    point = min(pointY_right, pointY_left)
    per = (point - y_high) / (y_low - y_high)
    # pointX_left = next(contoursGenerator(image_=a_thresh, y_= point- 1, mode=1))[1]
    # pointX_right = next(contoursGenerator(image_=a_thresh, y_=point - 1, mode=2))[1]
    # return [pointX_left, point], [pointX_right, point]
    return per


def checkSharpCorner(image:np.ndarray):
    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
    height, width = a.shape
    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
    # 直接返回脖子的位置信息, 修正系数为0, get_box_pro内部也封装了二值化,所以直接输入原图
    y_high, y_low, _, _ = get_box_pro(image=image, model=1, correction_factor=0)
    def scan(y_:int, max_num:int=2):
        num = 0
        # 设定两个值,分别代表脖子的左边和右边
        left = False
        right = False
        for x_ in range(width):
            if a_thresh[y_][x_] != 0:
                # 检测左边
                if x_ < width // 2 and left is False:
                    num += 1
                    left = True
                # 检测右边
                elif x_ > width // 2 and right is False:
                    num += 1
                    right = True
        return True if num >= max_num else False
    def locate_neck_above():
        """

        定位脖子的尖尖脚

        """
        # y_high就是脖子的最高点
        for y_ in range(y_high, height):
            if scan(y_):
                return y_
    y_start = locate_neck_above()
    return y_start


def checkJaw(image:np.ndarray, y_start:int):
    # 寻找"马鞍点"
    _, _, _, a = cv2.split(image)  # 这应该是一个四通道的图像
    height, width = a.shape
    ret, a_thresh = cv2.threshold(a, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
    if width <=1: raise TypeError("图像太小!")
    x_left, x_right = 0, width - 1
    for x_left in range(width):
        if a_thresh[y_start][x_left] != 0:
            while a_thresh[y_start][x_left] != 0: x_left += 1
            break
    for x_right in range(width-1, -1, -1):
        if a_thresh[y_start][x_right] != 0:
            while a_thresh[y_start][x_right] != 0: x_right -= 1
            break
    point_list_y = []
    point_list_x = []
    for x in range(x_left, x_right):
        y = y_start
        while a_thresh[y][x] == 0: y += 1
        point_list_y.append(y)
        point_list_x.append(x)
    y = max(point_list_y)
    x = point_list_x[point_list_y.index(y)]
    return x, y


def checkHairLOrR(cloth_image_input_cut,

                  input_a,

                  neck_a,

                  cloth_image_input_top_y,

                  cutbar_top=0.4,

                  cutbar_bottom=0.5,

                  threshold=0.3):
    """

    本函数用于检测衣服是否被头发遮挡,当前只考虑左右是否被遮挡,即"一刀切"

    返回int

    0代表没有被遮挡

    1代表左边被遮挡

    2代表右边被遮挡

    3代表全被遮挡了

    约定,输入的图像是一张灰度图,且被二值化过.

    """
    def per_darkPoint(img:np.ndarray) -> int:
        """

        用于遍历相加图像上的黑点.

        然后返回黑点数/图像面积

        """
        h, w = img.shape
        sum_darkPoint = 0
        for y in range(h):
            for x in range(w):
                if img[y][x] == 0:
                    sum_darkPoint += 1
        return sum_darkPoint / (h * w)

    if threshold < 0 or threshold > 1: raise TypeError("阈值设置必须在0和1之间!")

    # 裁出cloth_image_input_cut按高度40%～50%的区域-cloth_image_input_cutbar，并转换为A矩阵，做二值化
    cloth_image_input_height = cloth_image_input_cut.shape[0]
    _, _, _, cloth_image_input_cutbar = cv2.split(cloth_image_input_cut[
                                                  int(cloth_image_input_height * cutbar_top):int(
                                                      cloth_image_input_height * cutbar_bottom), :])
    _, cloth_image_input_cutbar = cv2.threshold(cloth_image_input_cutbar, 127, 255, cv2.THRESH_BINARY)

    # 裁出input_image、neck_image的A矩阵的对应区域，并做二值化
    input_a_cutbar = input_a[cloth_image_input_top_y + int(cloth_image_input_height * cutbar_top):
                             cloth_image_input_top_y + int(cloth_image_input_height * cutbar_bottom), :]
    _, input_a_cutbar = cv2.threshold(input_a_cutbar, 127, 255, cv2.THRESH_BINARY)
    neck_a_cutbar = neck_a[cloth_image_input_top_y + int(cloth_image_input_height * cutbar_top):
                           cloth_image_input_top_y + int(cloth_image_input_height * cutbar_bottom), :]
    _, neck_a_cutbar = cv2.threshold(neck_a_cutbar, 50, 255, cv2.THRESH_BINARY)

    # 将三个cutbar合到一起-result_a_cutbar
    input_a_cutbar = np.uint8(255 - input_a_cutbar)
    result_a_cutbar = cv2.add(input_a_cutbar, cloth_image_input_cutbar)
    result_a_cutbar = cv2.add(result_a_cutbar, neck_a_cutbar)

    if_mask = 0
    # 我们将图像 一刀切,分为左边和右边
    height, width = result_a_cutbar.shape  # 一通道图像
    left_image = result_a_cutbar[:, :width//2]
    right_image = result_a_cutbar[:, width//2:]
    if per_darkPoint(left_image) > threshold:
        if_mask = 1
    if per_darkPoint(right_image) > threshold:
        if_mask = 3 if if_mask == 1 else 2
    return if_mask


def find_black(image):
    """

    找黑色点函数，遇到输入矩阵中的第一个黑点，返回它的y值

    """
    height, width = image.shape[0], image.shape[1]
    for i in range(height):
        for j in range(width):
            if image[i, j] < 127:
                return i
    return None


def convert_black_array(image):
    height, width = image.shape[0], image.shape[1]
    mask = np.zeros([height, width])
    for j in range(width):
        for i in range(height):
            if image[i, j] > 127:
                mask[i:, j] = 1
                break
    return mask


def checkLongHair(neck_image, head_bottom_y, neck_top_y):
    """

    长发检测函数，输入为head/neck图像，通过下巴是否为最低点，来判断是否为长发

    :return 0 : 短发

    :return 1 : 长发

    """
    jaw_y = neck_top_y + checkJaw(neck_image, y_start=checkSharpCorner(neck_image))[1]
    if jaw_y >= head_bottom_y-3:
        return 0
    else:
        return 1


def checkLongHair2(head_bottom_y, cloth_top_y):
    if head_bottom_y > cloth_top_y+10:
        return 1
    else:
        return 0


if __name__ == "__main__":
    for i in range(1, 8):
        img = cv2.imread(f"./neck_temp/neck_image{i}.png", cv2.IMREAD_UNCHANGED)
        # new = transformationNeck(image=img, cutNeckHeight=419,neckBelow=472, toHeight=150)
        # point_list = bestJunctionCheck(img, offset=5, stepSize=3)
        # per = bestJunctionCheck(img, offset=5, stepSize=3)
        # # 返回一个小数的形式, 接下来我将它处理为两个点
        point_list = []
        # y_high_, y_low_, _, _ = get_box_pro(image=img, model=1, conreection_factor=0)
        # _y = y_high_ + int((y_low_ - y_high_) * per)
        # _, _, _, a_ = cv2.split(img)  # 这应该是一个四通道的图像
        # h, w = a_.shape
        # r, a_t = cv2.threshold(a_, 127, 255, cv2.THRESH_BINARY)  # 将透明图层二值化
        # _x = 0
        # for _x in range(w):
        #     if a_t[_y][_x] != 0:
        #         break
        # point_list.append([_x, _y])
        # for _x in range(w - 1, -1, -1):
        #     if a_t[_y][_x] != 0:
        #         break
        # point_list.append([_x, _y])
        y = checkSharpCorner(img)
        point = checkJaw(image=img, y_start=y)
        point_list.append(point)
        new = draw_picture_dots(img, point_list, pen_size=2)
        cv2.imshow(f"{i}", new)
    cv2.waitKey(0)