jnhg_ai_code/utils/renwu.py

from pathlib import Path

import matplotlib.path as mat

from utils.general import strtolstl

from utils.general import compute_IOU

from torchvision import transforms

from PIL import Image

import torch

import torch.nn.functional as F

import numpy as np

from ultralytics.engine.results import Results

from shapely.geometry import Point



from shapely.geometry.polygon import Polygon

mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]

test = transforms.Compose([transforms.Resize((224,224)),

        #transforms.CenterCrop(224),

        transforms.ToTensor(),

        transforms.Normalize(mean=mean, std=std)

                           ])

def clapre(modelcla,claimg,clapoint):

    imgten = torch.stack(claimg,dim=0)

    clapoint = torch.stack(clapoint,dim=0)

    imgten = imgten.to(0)

    result = modelcla(imgten)

    result = F.softmax(result)

    print(result)

    index = result.argmax(1)

    index = index.cpu().numpy()

    index = np.argwhere(index<5)

    index = index.reshape(-1)

    print(index)

    if len(index)>0:

        print(clapoint[index])

        return clapoint[index]

    else:

        return None



class Helmet:

    def __init__(self):

        self.flag = False

    def getflag(self,det,persondet,annotator,fence=0,point=None,names=None,rname=None,num=1):

        #print(type(det))

        self.flag = False

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag

class Uniform:

    def __init__(self):

        self.flag = False



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                          xyxy[3].cpu().item())

                                    p2 = (

                                    int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                    xyxy[3].cpu().item())

                                    pt = [p1, p2]

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag



class Fall:

    def __init__(self):

        self.flag = False



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag



class Personcount:

    def __init__(self):

        self.flag = False



    def getflag(self, det,persondet, annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        detnum = 0

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                #self.flag = True

                                detnum = detnum+1

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        detnum = detnum+1

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        #self.flag = True

                else:

                    if persondet is None:

                        #self.flag = True

                        detnum = detnum+1

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                detnum = detnum+1

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                #self.flag = True

        if detnum >= num:

            self.flag = True

        return self.flag

    

class Arm:

    def __init__(self):

        self.flag = False



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                            # c = int(cls)  # integer class

                            # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0,0,255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(np.array(person).reshape(-1,2)).contains_points(pt)

                            if personinflag.any():

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag

    

class Bag:

    def __init__(self):

        self.flag = False



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag

    

class Cross:

    def __init__(self):

        self.flag = False



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        detnum = 0

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                detnum = detnum+1

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        detnum = detnum+1

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        detnum = detnum+1

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                detnum = detnum +1 

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag



class Extinguisher:

    def __init__(self):

        self.flag = False



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag



def calculate_iou(box1, box2):



    # 计算交集区域 也就是找到次左上 次右下



    x1_int = max(box1[0], box2[0])



    y1_int = max(box1[1], box2[1])



    x2_int = min(box1[2], box2[2])



    y2_int = min(box1[3], box2[3])







    # 交集区域的宽高



    width_int = max(0, x2_int - x1_int)



    height_int = max(0, y2_int - y1_int)



    area_int = width_int * height_int







    # 计算两个框的面积



    area_box1 = (box1[2] - box1[0]) * (box1[3] - box1[1])



    area_box2 = (box2[2] - box2[0]) * (box2[3] - box1[1])







    # 计算并集面积



    area_union = area_box1 + area_box2 - area_int







    # 计算IoU



    iou = area_int / area_union if area_union > 0 else 0



    return iou

def check_cls4_overlap(person_box, target_box, cls4_boxes):
    """
    检查是否有 cls4 物体在目标框与人物框交集区域内，并计算交集面积与 cls4 物体面积的重叠比率。
    返回重叠比率最大值以及其对应的交集区域坐标和 cls4 框。

    参数:
    person_box (tuple): 人物框 (x_min, y_min, x_max, y_max)
    target_box (tuple): 目标框 (x_min, y_min, x_max, y_max)
    cls4_boxes (list): cls4 物体框的列表，每个框为 (x_min, y_min, x_max, y_max)

    返回:
    tuple:
        - 最大的重叠比率 (float)，如果没有符合条件的物体则为 None。
        - 最大重叠比率对应的交集区域的坐标 (inter_x1, inter_y1)。
        - 对应的 cls4 框 (tuple)，如果没有符合条件的物体则为 None。
    """
    # 计算目标框与人物框的交集区域
    min_x = max(person_box[0], target_box[0])
    min_y = max(person_box[1], target_box[1])
    max_x = min(person_box[2], target_box[2])
    max_y = min(person_box[3], target_box[3])

    target_area = (min_x, min_y, max_x, max_y)  # 交集区域

    max_overlap_ratio = -1  # 用于存储最大的重叠比率 这设置为-1有助于区别是否计算了
    best_inter_x1 = 0  # 用于存储最大重叠比率对应的交集坐标
    best_inter_y1 = 0
    best_cls4_box = []  # 用于存储对应的 cls4 框 不能初始化为整数0 整数不可迭代 后序不能添加

    # 检查是否有 cls4 物体在交集区域内
    for cls4_box in cls4_boxes:
        # 判断 cls4 框是否与交集区域有交集
        inter_x1 = max(cls4_box[0], target_area[0])
        inter_y1 = max(cls4_box[1], target_area[1])
        inter_x2 = min(cls4_box[2], target_area[2])
        inter_y2 = min(cls4_box[3], target_area[3])

        if inter_x1 < inter_x2 and inter_y1 < inter_y2:
            # 计算交集区域的面积
            intersection_area = (inter_x2 - inter_x1) * (inter_y2 - inter_y1)
            #print("交集的面积", intersection_area)

            # 计算 cls4_box 的面积
            cls4_area = (cls4_box[2] - cls4_box[0]) * (cls4_box[3] - cls4_box[1])
            #print("cls4_area的面积是", cls4_area)

            # 计算交集区域占 cls4_box 面积的比例
            overlap_ratio = intersection_area / cls4_area

            # 更新最大重叠比率及其相关信息
            if max_overlap_ratio == 0 or overlap_ratio > max_overlap_ratio:
                max_overlap_ratio = overlap_ratio
                best_inter_x1 = inter_x1
                best_inter_y1 = inter_y1
                best_cls4_box = cls4_box

    return max_overlap_ratio, (best_inter_x1, best_inter_y1), best_cls4_box

class Persontre1:

    def __init__(self):

        self.flag = False

        self.classifier_model = torch.load('/home/h3c/yolo/persontrecls.pt') 

    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1,im0=None):

        self.flag = False

        dirp = {}

        dirf = {}

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:

                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                              xyxy[3].cpu().item())

                        p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              xyxy[3].cpu().item())

                        pt = [p1, p2]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                            if c==0:

                                dirp.setdefault(0,[])

                                dirp[0].append(xyxy)

                            elif c in [1,2]:

                                dirp.setdefault(1,[])

                                dirp[1].append(xyxy)

                                dirf.setdefault(1,[])

                                dirf[1].append(xyxy)

                            elif c==3:

                                dirp.setdefault(1,[])

                                dirp[1].append(xyxy)

                            elif c==4:

                                dirf.setdefault(0,[])

                                dirf[0].append(xyxy)

                                #annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        #annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        #self.flag = True

                                        if c==0:

                                            dirp.setdefault(0,[])

                                            dirp[0].append(xyxy)

                                        elif c in [1,2]:

                                            dirp.setdefault(1,[])

                                            dirp[1].append(xyxy)

                                            dirf.setdefault(1,[])

                                            dirf[1].append(xyxy)

                                        elif c==3:

                                            dirp.setdefault(1,[])

                                            dirp[1].append(xyxy)

                                        elif c==4:

                                            dirf.setdefault(0,[])

                                            dirf[0].append(xyxy)

                else:

                    if persondet is None:

                        #self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        #label = None

                        #annotator.box_label(xyxy, None, color=(0, 0, 255))

                        if c==0:

                            dirp.setdefault(0,[])

                            dirp[0].append(xyxy)

                        elif c in [1,2]:

                            dirp.setdefault(1,[])

                            dirp[1].append(xyxy)

                            dirf.setdefault(1,[])

                            dirf[1].append(xyxy)

                        elif c==3:

                            dirp.setdefault(1,[])

                            dirp[1].append(xyxy)

                        elif c==4:

                            dirf.setdefault(0,[])

                            dirf[0].append(xyxy)

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                #annotator.box_label(xyxy, None, color=(0, 0, 255))

                                #self.flag = True

                                if c==0:

                                    dirp.setdefault(0,[])

                                    dirp[0].append(xyxy)

                                elif c in [1,2]:

                                    dirp.setdefault(1,[])

                                    dirp[1].append(xyxy)

                                    dirf.setdefault(1,[])

                                    dirf[1].append(xyxy)

                                elif c==3:

                                    dirp.setdefault(1,[])

                                    dirp[1].append(xyxy)

                                elif c==4:

                                    dirf.setdefault(0,[])

                                    dirf[0].append(xyxy)

        if len(dirp.keys()) == 2:

            claimg = []

            clapoint = []

            for person in dirp[0]:

                for other in dirp[1]:

                    iou, newxyxy = compute_IOU(person, other)

                    if iou>0.1:

                        print(newxyxy)

                        imgtmp = im0[int(newxyxy[1]):int(newxyxy[3]),int(newxyxy[0]):int(newxyxy[2])]

                        imgtmp = imgtmp[...,::-1]

                        imgtmp = Image.fromarray(imgtmp)

                        imgten1 = test(imgtmp)

                        claimg.append(imgten1)

                        clapoint.append((newxyxy))

                        result = clapre(self.classifier_model,claimg,clapoint)

                        #imgten = imgten1[None]

                        #imgten = imgten.to(0)

                        #result = modelcla(imgten)

                        #result = F.softmax(result, dim=1)

                        #cla = result.argmax(1)

                        if result is not None:

                            self.flag = True

                            for res in result:

                                print(res)

                                annotator.box_label(res, None, color=(0,0,255))

        if len(dirp.keys()) == 2:

            claimg = []

            clapoint = []

            for person in dirp[0]:

                for other in dirp[1]:

                    iou, newxyxy = compute_IOU(person, other)

                    if iou>0.1:

                        print(newxyxy)

                        imgtmp = im0[int(newxyxy[1]):int(newxyxy[3]),int(newxyxy[0]):int(newxyxy[2])]

                        imgtmp = imgtmp[...,::-1]

                        imgtmp = Image.fromarray(imgtmp)

                        imgten1 = test(imgtmp)

                        claimg.append(imgten1)

                        clapoint.append((newxyxy))

                        result = clapre(self.classifier_model,claimg,clapoint)

                        #imgten = imgten1[None]

                        #imgten = imgten.to(0)

                        #result = modelcla(imgten)

                        #result = F.softmax(result, dim=1)

                        #cla = result.argmax(1)

                        if result is not None:

                            self.flag = True

                            for res in result:

                                print(res)

                                annotator.box_label(res, None, color=(0,0,255))

        return self.flag



class Persontree:

    def __init__(self):

        self.flag = False

        self.classifier_model = torch.load('/home/h3c/yolo/persontrecls.pt') 

    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1,im0=None):

        self.flag = False

        target_classes = [1, 2, 3]

        results = Results(annotator.result(),path=None,names=names,boxes=det)

        boxes = results.boxes

        person_boxes = []



        target_boxes = []



        cls4_boxes = []







        # 处理检测结果



        for i in range(len(boxes)):



            cls = int(boxes.cls[i].item())



            con = boxes.conf[i].item()







            if cls == 0 and con > 0.1:  # 如果是 "person" 类别



                x1, y1, x2, y2 = boxes.xyxy[i].tolist()



                person_boxes.append([x1, y1, x2, y2])







            if cls in target_classes and con > 0.1:  # 目标类别（bag, box, cart）



                x1, y1, x2, y2 = boxes.xyxy[i].tolist()



                target_boxes.append([x1, y1, x2, y2])







            if cls == 4 and con > 0.1:  # 如果是 "cls 4" 类别



                x1, y1, x2, y2 = boxes.xyxy[i].tolist()



                cls4_boxes.append([x1, y1, x2, y2])







        # 如果检测到 "person" 类别和目标框，计算IoU



        if person_boxes and target_boxes:



            for i, person_box in enumerate(person_boxes):



                person_center_y = (person_box[1] + person_box[3]) / 2







                for j, target_box in enumerate(target_boxes):



                    target_center_y = (target_box[1] + target_box[3]) / 2







                    # 判断目标框的中心点是否在person框的下方



                    if target_center_y + 20 > person_center_y:  # 根据需要调整此阈值



                        iou = calculate_iou(person_box, target_box)







                        if iou > 0:  # IoU大于0，进入新的判断



                            # 创建一个包围person和target框的区域 本来思路是判断脚是否在这个大框框里面 但是这个不合理 应该判断脚是不是在这个交集里面，再检测脚和人与物交集有没有交集



                            min_x = max(person_box[0], target_box[0])



                            min_y = max(person_box[1], target_box[1])



                            max_x = min(person_box[2], target_box[2])



                            max_y = min(person_box[3], target_box[3])







                            target_area = (min_x, min_y, max_x, max_y)











                            # 检查是否有cls 4物体在这个区域内



                            for cls4_box in cls4_boxes: #比较巧妙 提前存储这个变量 然后检测这个物体是不是在这里面



                                # 判断cls 4框是否与这个区域有交集



                                inter_x1 = max(cls4_box[0], target_area[0])



                                inter_y1 = max(cls4_box[1], target_area[1])



                                inter_x2 = min(cls4_box[2], target_area[2])



                                inter_y2 = min(cls4_box[3], target_area[3])







                                if inter_x1 < inter_x2 and inter_y1 < inter_y2:



                                    # 计算交集区域的面积



                                    intersection_area = (inter_x2 - inter_x1) * (inter_y2 - inter_y1)







                                    # 计算 cls4_box 的面积



                                    cls4_area = (cls4_box[2] - cls4_box[0]) * (cls4_box[3] - cls4_box[1])







                                    # 计算交集区域占 cls4_box 面积的比例



                                    overlap_ratio = intersection_area / cls4_area

                                    if overlap_ratio > 0.5:

                                        self.flag = True

        return self.flag

class Persontre:

    def __init__(self):

        self.flag = False

        self.classifier_model = torch.load('/home/h3c/yolo/persontrecls.pt') 

    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1,im0=None):

        self.flag = False
        cls3 =3 #对cart单独一类

        cls4 = 4  # 新增加的类别编号（假设为 4）
        target_classes = [1, 2, 3]

        results = Results(annotator.result(),path=None,names=names,boxes=det)
        boxes = results.boxes
        person_boxes = [] # 人 车子 脚 以及 指定区域内的脚
        cls3_boxes = []
        cls4_boxes = []
        best_cls4_box = []
        # 处理检测结果
        for i in range(len(boxes)):
            cls = int(boxes.cls[i].item())
            con = boxes.conf[i].item()

            if cls == 0 and con > 0.1:  # 如果是 "person" 类别  先把对应类别添加上去  先把每一个识别物体输入上去
                x1, y1, x2, y2 = boxes.xyxy[i].tolist()
                person_boxes.append([x1, y1, x2, y2])

            if cls == cls3 and con > 0.1:  # 目标类别 cart
                x1, y1, x2, y2 = boxes.xyxy[i].tolist()
                cls3_boxes.append([x1, y1, x2, y2])

            if cls == cls4 and con > 0.1:  # 如果是 "cls 4" 类别
                x1, y1, x2, y2 = boxes.xyxy[i].tolist()
                cls4_boxes.append([x1, y1, x2, y2])



        # 如果检测到 "person" 类别和目标框，计算IoU
        if person_boxes and cls3_boxes: # 先查看这俩个类别有没有
            for i, person_box in enumerate(person_boxes):

                for j, cls3_box in enumerate(cls3_boxes):

                    # 判断目标框的中心点是否在person框的下方
                        iou = calculate_iou(person_box, cls3_box)
                        # 踩的逻辑 一个是要求车子和人有交并比 其次判断脚是不是在这个交并比内 并且比重不能太低
                        if iou > 0.2: # 用来判断坐 如果iou足够高 就视为是坐
                            # 加载图像并绘制标注
                            # 看看这个值大概有多少 好衡量一下
                            #print(f"这个iou大于0.2的 这是第{frame_idx},iou是{iou}")  # 写入介绍


                            annotator.box_label(person_box, None, color=(0, 0, 255))
                            annotator.box_label(cls3_box, None, color=(0, 0, 255))
                            self.flag = True
                            #print("这是坐",f"{saved_image_path}")
                        elif iou > 0 :  # IoU大于0，进入新的判断 代表不是坐
                            # 创建一个包围person和target框的区域 本来思路是判断脚是否在这个大框框里面 但是这个不合理 应该判断脚是不是在这个交集里面，再检测脚和人与物交集有没有交集


                            overlap_ratio, inter_xy, best_cls4_box1 = check_cls4_overlap(person_box, cls3_box,cls4_boxes)

                            best_cls4_box.extend(best_cls4_box1)  #拿到这四个点的坐标



                            inter_x1, inter_y1 = inter_xy

                            # 如果占比大于某个阈值，可以执行进一步的操作
                            if overlap_ratio > 0.2:
                                annotator.box_label(person_box, None, color=(0, 0, 255))
                                annotator.box_label(cls3_box, None, color=(0, 0, 255))
                                annotator.box_label(best_cls4_box, None, color=(0, 0, 255))
                                self.flag = True

class Danager:

    def __init__(self):

        self.flag = False



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        for *xyxy, conf, cls in reversed(det):

            c = int(cls)

            labelname = names[c]

            if labelname in rname:

                if fence == 1:



                    pointa = strtolstl(point)

                    for poi in pointa:

                        p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 2),

                              int(xyxy[1].cpu().item() + (xyxy[3].cpu().item() - xyxy[1].cpu().item()) / 2))

                        #p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                              #xyxy[3].cpu().item())

                        pt = [p1]

                        inflag = mat.Path(poi).contains_points(pt)

                        if inflag.any():

                            if persondet is None:

                                self.flag = True

                                # c = int(cls)  # integer class

                                # label = f'{self.names[c]} {conf:.2f}'

                                label = None

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                            else:

                                for person in persondet:

                                    personinflag = mat.Path(person).contains_points(pt)

                                    if personinflag.any():

                                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                                        self.flag = True

                else:

                    if persondet is None:

                        self.flag = True

                        # c = int(cls)  # integer class

                        # label = f'{self.names[c]} {conf:.2f}'

                        label = None

                        annotator.box_label(xyxy, None, color=(0, 0, 255))

                    else:

                        for person in persondet:

                            p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  xyxy[3].cpu().item())

                            p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                                  xyxy[3].cpu().item())

                            pt = [p1, p2]

                            personinflag = mat.Path(person).contains_points(pt)

                            if personinflag.any():

                                annotator.box_label(xyxy, None, color=(0, 0, 255))

                                self.flag = True

        return self.flag



class CarHelmetBelt:

    def __init__(self):

        self.flag = False



    def selectNoBeltPerson(self, person_objs, belt_objs):

        objs = []

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_belt = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in belt_objs]

        for person_obj, person in zip(person_objs, polygon_person):

            with_belt = False

            for belt in polygon_belt:

                if person.intersection(belt).area / belt.area > 0.5:

                    with_belt = True

                    break

            if not with_belt:

                objs.append(person_obj)

        return objs



    def selectWithPersonHead(self, person_objs, head_objs):

        objs = []

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, top + (bottom - top)/2), (left, top + (bottom - top)/2)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_head = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in head_objs]

        for head_obj, head in zip(head_objs, polygon_head):

            with_person = False

            for person in polygon_person:

                print('head')

                if person.intersection(head).area / head.area > 0.5:

                    with_person = True

                    break

            if with_person:

                objs.append(head_obj)

        return objs



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        results = Results(annotator.result(),path=None,names=names,boxes=det)

        person_objs = []

        head_objs = []

        belt_objs = []

        self.polygon_areas = [Polygon(strtolstl(point)[0])]

        for result in results:

            boxes = result.boxes

            for box in boxes:

                #print(box.conf.cpu())

                left, top, right, bottom = box.xyxy.cpu().numpy().tolist()[0]

                polygon_box = Polygon([(left, top), (right, top), (right, bottom), (left, bottom)])



                intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in self.polygon_areas ]

                if sum(intersection_areas) == 0:

                    continue



                intersection_areas_ratio = sorted([intersection_area / polygon_box.area for intersection_area in intersection_areas])

                if intersection_areas_ratio[-1] < 0.9:

                    continue



                conf = box.conf.cpu().numpy().tolist()[0]

                cls = box.cls.cpu().numpy().tolist()[0]

                if cls == 0:

                    person_objs.append([left, top, right, bottom, conf, names[cls]])

                elif cls == 1:

                    head_objs.append([left, top, right, bottom, conf, names[cls]])

                elif cls == 3:

                    belt_objs.append([left, top, right, bottom, conf, names[cls]])

                #print(head_objs)

                #print(person_objs)

        illegal_objs = self.selectNoBeltPerson(person_objs, belt_objs) + self.selectWithPersonHead(person_objs, head_objs)

        if len(illegal_objs)>0:

            for obj in illegal_objs:

                annotator.box_label(obj[:4], None, color=(0, 0, 255))

            self.flag = True

        return self.flag



class newUniformi1:

    def __init__(self):

        self.flag = False



    def selectNoUniformPerson(self, person_objs, uniform_objs):

        objs = []

        print(person_objs)

        print(uniform_objs)

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_uniform = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in uniform_objs]

        for person_obj, person in zip(person_objs, polygon_person):

            with_uniform = False

            for uniform in polygon_uniform:

                if person.intersection(uniform).area / uniform.area > 0.3:

                    with_uniform = True

                    break

            if not with_uniform:

                print(f'illperson_obj {person_obj} illpolygon_uniform {polygon_uniform}')

                objs.append(person_obj)

        return objs





    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        results = Results(annotator.result(),path=None,names=names,boxes=det)

        print(results.boxes)

        person_objs = []

        uniform_objs = []

        #belt_objs = []

        if len(point)>1:

            self.polygon_areas = [Polygon(strtolstl(point)[0])]

        else:

            self.polygon_areas = None

        if persondet is not None:

            if self.polygon_areas is not None:

                for left, top, right,top,right, bottom,left,bottom in persondet:

                    polygon_box = Polygon([(left, top), (right, top), (right, bottom), (left, bottom)])



                    intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in

                                          self.polygon_areas]

                    if sum(intersection_areas) == 0:

                        continue



                    intersection_areas_ratio = sorted(

                        [intersection_area / polygon_box.area for intersection_area in intersection_areas])

                    print(f'inter = {intersection_areas_ratio}')

                    if intersection_areas_ratio[-1] >= 0.3:
                        print("person in check space!!!")

                        width = right - left

                        height = bottom - top
                        print(f'{left}, {top}, {right},{top},{right}, {bottom},{left},{bottom}')
                        print(f'hw = {width* height}')
                        if width * height > 10000:

                            person_objs.append([left, top, right, bottom, 0.25, 'person'])

        for result in results:

            boxes = result.boxes

            for box in boxes:

                left, top, right, bottom = box.xyxy.cpu().numpy().tolist()[0]

                # if self.polygon_areas is not None :

                #     if persondet is None and box.cls.cpu().numpy().tolist()[0] == 4:

                #         polygon_box = Polygon([(left, top), (right, top), (right, bottom), (left, bottom)])

                #

                #         intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in self.polygon_areas ]

                #         if sum(intersection_areas) == 0:

                #             continue

                #

                #         intersection_areas_ratio = sorted([intersection_area / polygon_box.area for intersection_area in intersection_areas])

                #         print(f'inter = {intersection_areas_ratio}')

                #         if intersection_areas_ratio[-1] < 0.3:

                #             continue



                conf = box.conf.cpu().numpy().tolist()[0]

                cls = box.cls.cpu().numpy().tolist()[0]

                # if persondet is not None:

                #     if cls == 4 and conf >=0.7:

                #         width = right - left

                #         height = bottom - top

                #         if width * height >10000:

                #             person_objs.append([left, top, right, bottom, conf, names[cls]])



                if cls in [1,2]:

                    #width = right - left

                    #height = bottom - top

                    #if width * height >4096:

                    uniform_objs.append([left, top, right, bottom, conf, names[cls]])

                
        print(f'personobjs = {person_objs}')
        print(f'uniformobjs = {uniform_objs}')
        illegal_objs = self.selectNoUniformPerson(person_objs, uniform_objs) 

        if len(illegal_objs)>0:

            for obj in illegal_objs:

                annotator.box_label(obj[:4], None, color=(0, 0, 255))

            self.flag = True

        return self.flag



class newHelmet:

    def __init__(self):

        self.flag = False



    def selectNoHelmetPerson(self, person_objs, head_objs):

        objs = []

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_head = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in head_objs]

        for person_obj, person in zip(person_objs, polygon_person):

            with_head = False

            for head in polygon_head:

                print('head')

                if person.intersection(head).area / head.area > 0.3:

                    with_head = True

                    break

            if  with_head:

                objs.append(person_obj)

        return objs





    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        results = Results(annotator.result(),path=None,names=names,boxes=det)

        person_objs = []

        head_objs = []

        helmet_objs = []

        headtmp = []

        #belt_objs = []

        if len(point)>1:

            self.polygon_areas = [Polygon(strtolstl(point)[0])]

        else:

            self.polygon_areas = None

        for result in results:

            boxes = result.boxes

            for box in boxes:

                left, top, right, bottom = box.xyxy.cpu().numpy().tolist()[0]

                if self.polygon_areas is not None:

                    polygon_box = Polygon([(left, top), (right, top), (right, bottom), (left, bottom)])



                    intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in self.polygon_areas ]

                    if sum(intersection_areas) == 0:

                        continue



                    intersection_areas_ratio = sorted([intersection_area / polygon_box.area for intersection_area in intersection_areas])

                    if intersection_areas_ratio[-1] < 0.9:

                        continue

                conf = box.conf.cpu().numpy().tolist()[0]

                cls = box.cls.cpu().numpy().tolist()[0]
                #print(f'{conf} {cls}')
                #print(cls in [5,6,7,8,9,10])
                if cls == 4 and conf >=0.7:

                    width = right - left

                    height = bottom - top

                    if width * height >4096:

                        person_objs.append([left, top, right, bottom, conf, names[cls]])

                elif cls == 0 and conf >= 0.5:

                    #width = right - left

                    #height = bottom - top

                    #if width * height >4096:

                    print('------')

                    headtmp.append([left, top, right, bottom, conf, names[cls]])

                elif cls in [5,6,7,8,9,10]:

                    helmet_objs.append([(left, top), (right, top), (right, bottom), (left, bottom)])

        print(f'headtmp= {headtmp}')

        print(f'helmet_objs = {helmet_objs}')

        for left, top, right, bottom, conf, name  in headtmp:

            flag = False

            pt = [(int((left+right)/2),int((top+bottom)/2))]

            for helmet in helmet_objs:

                pflag = mat.Path(helmet).contains_points(pt)

                if pflag.any():

                    flag = True

                    break

            if not flag:

                head_objs.append([left, top, right, bottom, conf, name])

        illegal_objs = self.selectNoHelmetPerson(person_objs, head_objs) 

        if len(illegal_objs)>0:

            for obj in illegal_objs:

                annotator.box_label(obj[:4], None, color=(0, 0, 255))

            self.flag = True

        return self.flag

        

class newHelmetn:

    def __init__(self):

        self.flag = False



    def selectNoHelmetPerson(self, person_objs, head_objs):

        objs = []

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_head = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in head_objs]

        for person_obj, person in zip(person_objs, polygon_person):

            with_head = False

            for head in polygon_head:

                if person.intersection(head).area / head.area > 0.3:

                    with_head = True

                    break

            if  with_head:

                objs.append(person_obj)

        return objs





    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        results = Results(annotator.result(),path=None,names=names,boxes=det)

        person_objs = []

        head_objs = []

        #belt_objs = []

        if len(point)>1:

            self.polygon_areas = [Polygon(strtolstl(point)[0])]

        else:

            self.polygon_areas = None

        for result in results:

            boxes = result.boxes

            for box in boxes:

                left, top, right, bottom = box.xyxy.cpu().numpy().tolist()[0]

                if self.polygon_areas is not None:

                    polygon_box = Polygon([(left, top), (right, top), (right, bottom), (left, bottom)])



                    intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in self.polygon_areas ]

                    if sum(intersection_areas) == 0:

                        continue



                    intersection_areas_ratio = sorted([intersection_area / polygon_box.area for intersection_area in intersection_areas])

                    if intersection_areas_ratio[-1] < 0.9:

                        continue

                conf = box.conf.cpu().numpy().tolist()[0]

                cls = box.cls.cpu().numpy().tolist()[0]

                if cls == 4:

                    width = right - left

                    height = bottom - top

                    if width * height >4096:

                        person_objs.append([left, top, right, bottom, conf, names[cls]])

                elif cls == 0:

                    #width = right - left

                    #height = bottom - top

                    #if width * height >4096:

                    head_objs.append([left, top, right, bottom, conf, names[cls]])

                

        illegal_objs = self.selectNoHelmetPerson(person_objs, head_objs) 

        if len(illegal_objs)>0:

            for obj in illegal_objs:

                annotator.box_label(obj[:4], None, color=(0, 0, 255))

            self.flag = True

        return self.flag

        

class newUniformt:

    def __init__(self):

        self.flag = False



    def selectNoUniformPerson(self, person_objs, uniform_objs):

        objs = []

        print(person_objs)

        print(uniform_objs)

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_uniform = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in uniform_objs]

        for person_obj, person in zip(person_objs, polygon_person):

            with_uniform = False

            for uniform in polygon_uniform:

                if person.intersection(uniform).area / uniform.area > 0.3:

                    with_uniform = True

                    break

            if not with_uniform:

                print(f'illperson_obj {person_obj} illpolygon_uniform {polygon_uniform}')

                objs.append(person_obj)

        return objs



    def selectHeadPerson(self, person_objs, head_objs):

        objs = []

        print(person_objs)

        print(head_objs)

        #personlist = []

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_head = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in uniform_objs]

        for person_obj, person in zip(person_objs, polygon_person):

            #with_uniform = False

            for head in polygon_head:

                if person.intersection(head).area / head.area > 0.3:

                    #with_uniform = True

                    #break

            #if not with_uniform:

            #    print(f'illperson_obj {person_obj} illpolygon_uniform {polygon_uniform}')

                    objs.append(person_obj)

                    break

        return objs



    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        results = Results(annotator.result(),path=None,names=names,boxes=det)

        print(results.boxes)

        person_objs = []

        uniform_objs = []

        head_objs = []

        #belt_objs = []

        if len(point)>1:

            self.polygon_areas = [Polygon(strtolstl(point)[0])]

        else:

            self.polygon_areas = None

        for result in results:

            boxes = result.boxes

            for box in boxes:

                left, top, right, bottom = box.xyxy.cpu().numpy().tolist()[0]

                if self.polygon_areas is not None:

                    polygon_box = Polygon([(left, top), (right, top), (right, bottom), (left, bottom)])



                    intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in self.polygon_areas ]

                    if sum(intersection_areas) == 0:

                        continue



                    intersection_areas_ratio = sorted([intersection_area / polygon_box.area for intersection_area in intersection_areas])

                    if intersection_areas_ratio[-1] < 0.9:

                        continue



                conf = box.conf.cpu().numpy().tolist()[0]

                cls = box.cls.cpu().numpy().tolist()[0]

                if cls == 4:

                    width = right - left

                    height = bottom - top

                    if width * height >4096:

                        person_objs.append([left, top, right, bottom, conf, names[cls]])

                elif cls in [1,2]:

                    #width = right - left

                    #height = bottom - top

                    #if width * height >4096:

                    uniform_objs.append([left, top, right, bottom, conf, names[cls]])

                elif cls != 3:

                    head_objs.append([left, top, right, bottom, conf, names[cls]])

                

        person_objs = self.selectNoUniformPerson(person_objs, head_objs)

        illegal_objs = self.selectNoUniformPerson(person_objs, uniform_objs) 

        if len(illegal_objs)>0:

            for obj in illegal_objs:

                annotator.box_label(obj[:4], None, color=(0, 0, 255))

            self.flag = True

        return self.flag

        

class newUniform:

    def __init__(self):

        self.flag = False



    def selectNoUniformPerson(self, person_objs, uniform_objs):

        objs = []

        print(person_objs)

        print(uniform_objs)

        polygon_person = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in person_objs]

        polygon_uniform = [Polygon(

            [(left, top), (right, top), (right, bottom), (left, bottom)]) for left, top, right, bottom, _, _ in uniform_objs]

        for person_obj, person in zip(person_objs, polygon_person):

            with_uniform = False

            for uniform in polygon_uniform:

                if person.intersection(uniform).area / uniform.area > 0.3:

                    with_uniform = True

                    break

            if not with_uniform:

                print(f'illperson_obj {person_obj} illpolygon_uniform {polygon_uniform}')

                objs.append(person_obj)

        return objs





    def getflag(self, det, persondet,annotator, fence=0, point=None, names=None, rname=None,num=1):

        self.flag = False

        results = Results(annotator.result(),path=None,names=names,boxes=det)

        print(results.boxes)

        person_objs = []

        uniform_objs = []

        print(f'persondet = {persondet}')

        #belt_objs = []

        if len(point)>1:

            self.polygon_areas = [Polygon(strtolstl(point)[0])]
            print(self.polygon_areas)

        else:

            self.polygon_areas = None
        tmppersondet = []
        if self.polygon_areas is not None:
            for person in persondet:
                polygon_box = Polygon([(person[0], person[1]), (person[2], person[3]), (person[4], person[5]), (person[6], person[7])])
                intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in self.polygon_areas ]
                if sum(intersection_areas) == 0:
                    continue
                intersection_areas_ratio = sorted([intersection_area / polygon_box.area for intersection_area in intersection_areas])

                #print(intersection_areas_ratio)
                if intersection_areas_ratio[-1] < 0.9:
                    continue
                tmppersondet.append(person)
            persondet = tmppersondet
        print(f'tmppersondet = {tmppersondet}')
        #persondet = tmppersondet
        for result in results:

            boxes = result.boxes

            for box in boxes:

                left, top, right, bottom = box.xyxy.cpu().numpy().tolist()[0]

                conf = box.conf.cpu().numpy().tolist()[0]

                cls = box.cls.cpu().numpy().tolist()[0]
                #if self.polygon_areas is not None and cls == 4:

                #    polygon_box = Polygon([(left, top), (right, top), (right, bottom), (left, bottom)])



               #     intersection_areas = [polygon_area.intersection(polygon_box).area for polygon_area in self.polygon_areas ]

               #     if sum(intersection_areas) == 0:

               #         continue



               #     intersection_areas_ratio = sorted([intersection_area / polygon_box.area for intersection_area in intersection_areas])

               #     if intersection_areas_ratio[-1] < 0.9:

               #         continue



                #conf = box.conf.cpu().numpy().tolist()[0]

                #cls = box.cls.cpu().numpy().tolist()[0]

                print(conf)

                print(cls)

                if cls == 4 and conf >=0.7:

                    width = right - left

                    height = bottom - top

                    print(width*height)

                    if width * height >10000:

                        for person in persondet:

                            #p1 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3),

                                  #xyxy[3].cpu().item())

                            #p2 = (int(xyxy[0].cpu().item() + (xyxy[2].cpu().item() - xyxy[0].cpu().item()) / 3 * 2),

                            #      xyxy[3].cpu().item())

                            personcenterx = int((person[0]+person[2])/2)

                            personcentery = int((person[1]+person[7])/2)

                            p1 = (personcenterx,personcentery)

                            print(p1)

                            pt = [p1]

                            print(f'p1 = {p1}')

                            print(f'person = {person}')

                            personinflag = mat.Path([(left, top), (right, top), (right, bottom), (left, bottom)]).contains_points(pt)

                            if personinflag.any():

                                person_objs.append([left, top, right, bottom, conf, names[cls]])

                elif cls in [1,2]:

                    #width = right - left

                    #height = bottom - top

                    #if width * height >4096:

                    uniform_objs.append([left, top, right, bottom, conf, names[cls]])

                

        illegal_objs = self.selectNoUniformPerson(person_objs, uniform_objs) 

        if len(illegal_objs)>0:

            for obj in illegal_objs:

                annotator.box_label(obj[:4], None, color=(0, 0, 255))

            self.flag = True

        return self.flag