XZNSH-Code-AI/Bank_second_part/detect_process/tools_function.py

import cv2
import os
from deepdiff import DeepDiff



# 图像文件夹
def get_video_list(path):
        video_ext = [".mp4", ".avi",".MP4"]
        video_names = []
        for maindir, subdir, file_name_list in os.walk(path):
            for filename in file_name_list:
                apath = os.path.join(maindir, filename)
                ext = os.path.splitext(apath)[1]
                if ext in video_ext:
                    video_names.append(apath)
        return video_names


# # 截取裁剪需要的视频帧
# def save_seg_video(video_name, frameToStart, frametoStop, videoWriter, bbox):
#     cap = video_name
#     cap.set(cv2.CAP_PROP_POS_FRAMES, frameToStart)  # 设置初始帧数
#     count = frameToStart
    
#     while True:
#         success, frame = cap.read()

#         if not success or count > frametoStop:
#             break

#         if count >= frameToStart:
#             # 裁剪视频画面
#             frame_target = frame[int(bbox[1]):int(bbox[3]), int(bbox[0]):int(bbox[2])]
#             videoWriter.write(frame_target)

#         count += 1

#     cap.release()

# 截取裁剪需要的视频帧
def save_seg_video(video_name,frameToStart,frametoStop,videoWriter,bbox,size):

    cap = cv2.VideoCapture(video_name)
    count = 0
    while True:
        success,frame = cap.read()
        if success:
            count += 1
            if count <= frametoStop and count > frameToStart:  # 选取起始帧
                # print('correct= ', count)
                
                #裁剪视频画面
                frame_target = frame[bbox[1]:bbox[3], bbox[0]:bbox[2]]  # (split_height, split_width)
                try:
                    frame_target = cv2.resize(frame_target,size)
                    videoWriter.write(frame_target)

                except Exception as e:
                    print('----------------------------------',size,'----------------------------------')
                    print(e)
                    
        if not success or count >= frametoStop:
            break

    videoWriter.release()
    cap.release()


# 获得字典中所有values值（这个值是列表）
def get_dict_values(lst):
        """
        获取列表中所有字典的 values 值（如果值是列表）
        
        参数:
        lst: 包含字典的列表
        
        返回值:
        values: 包含所有字典的 values 值的列表（如果值是列表）
        """
        return [value for dictionary in lst for value in dictionary.values() if isinstance(value, list)]


    # 解析检测后的结果，为检测后的结果排序
def analysis_sort_list(re_list):

        # print('result_dict:',result_dict)

        # 获得检测列表
        # re_list = result_dict['start_bbox']
        # print('re_list:',re_list)

        # 获得列表中所有字典的values值
        # re_bbox_list = Process_tools.get_dict_values(re_list)

        # 为检测出来的标注框排序
        sorted_lst = sorted(re_list, key=lambda x: x[0])

        return sorted_lst


    #对比重叠率高的两个部分，并结合标注框，保存最大的标注框
def contrast_bbox(e_bbox,r_bbox):

    e_bbox_min = e_bbox[:2]
    r_bbox_min = r_bbox[:2]

    bbox_min = [min(x, y) for x, y in zip(e_bbox_min, r_bbox_min)]

    e_bbox_max = e_bbox[-2:]
    r_bbox_max = r_bbox[-2:]

    bbox_max = [max(x, y) for x, y in zip(e_bbox_max, r_bbox_max)]

    bbox = bbox_min + bbox_max

    return bbox


    # 解析result_list列表
def analysis_re01_list(example_list,result_list):

    '''
    example_dict:对比的参照
    result_dict: 需要与参照对比的结果

    example_sorted_lst：返回值中，原先有现在没有部分
    re_dict_sorted_lst：返回值中，现在有原先没有部分

    cut_list：原先有，现在也有的部分

    '''
    # 第一次检测到目标的帧率和信息
    # example_dict_fps = list(example_dict.keys())[0]
    # example_sorted_lst = Process_tools.analysis_sort_list(example_list)

    # 当前帧检测结果中所有的检测结果数值
    # re_dict_fps = list(result_dict.keys())[0]
    # re_dict_sorted_lst = Process_tools.analysis_sort_list(result_list)

    # 保存前后帧率连续的范围、筛选出相同的部分
    cut_list = []
    example_temp = []
    re_temp = []

    for i,ex_bbox_dict in enumerate(example_list):

        ex_bbox = ex_bbox_dict['result']

        for j,re_bbox in enumerate(result_list):

            iou = calculate_iou(box1=ex_bbox, box2=re_bbox)

                # print(iou)
                
            if iou > 0.5:

                # bbox = Process_tools.contrast_bbox(e_bbox=ex_bbox,r_bbox=re_bbox)

                # cut_list.append({i:re_bbox})
                cut_list.append(re_bbox)
                example_temp.append(ex_bbox)
                re_temp.append(re_bbox)

                break
        
    # print('example_temp:',example_temp)
    # print('re_temp:',re_temp)
    example_sorted_lst = [item for item in example_list if item['result'] not in example_temp]
    re_dict_sorted_lst = [item for item in result_list if item not in re_temp]

    return cut_list,example_sorted_lst,re_dict_sorted_lst


# 计算前后帧率重叠范围
def calculate_iou(box1, box2):
    """
    计算两个边界框之间的IoU值
        
    参数:
    box1: 边界框1的坐标（x1, y1, x2, y2）
    box2: 边界框2的坐标（x1, y1, x2, y2）
        
    返回值:
    iou: 两个边界框之间的IoU值
    """
    x1 = max(box1[0], box2[0])
    y1 = max(box1[1], box2[1])
    x2 = min(box1[2], box2[2])
    y2 = min(box1[3], box2[3])
        
    # 计算交集区域面积
    intersection_area = max(0, x2 - x1 + 1) * max(0, y2 - y1 + 1)
        
    # 计算边界框1和边界框2的面积
    box1_area = (box1[2] - box1[0] + 1) * (box1[3] - box1[1] + 1)
    box2_area = (box2[2] - box2[0] + 1) * (box2[3] - box2[1] + 1)
        
    # 计算并集区域面积
    union_area = box1_area + box2_area - intersection_area
        
    # 计算IoU值
    iou = intersection_area / union_area
        
    return iou

# 修正坐标参数
def para_correction(images_size,bbox,dertpara):

        '''
        修正检测后标注框过小的情况,如果有修正参数则使用修正参数，如果没有就按照坐标值扩大两倍

        '''
        
    # if dertpara:
    #     pass
    # else:
        w = (bbox[2] - bbox[0]) / int(dertpara)
        h = (bbox[3] - bbox[1]) / int(dertpara)

        bbox_extand_list_x = [bbox[0] - w,bbox[2] + w]
        bbox_extand_list_y = [bbox[1] - h,bbox[3] + h]
            
        bbox_list_x = contrast(size=images_size[0],bbox_extand_list=bbox_extand_list_x)
        bbox_list_y = contrast(size=images_size[1],bbox_extand_list=bbox_extand_list_y)

        bbox_list = [bbox_list_x[0],bbox_list_y[0],bbox_list_x[1],bbox_list_y[1]]

        return bbox_list

def para_correction_back(x1, y1, x2, y2):

        '''
        修正检测后标注框还原

        '''
        
    # if dertpara:
    #     pass
    # else:
        # x1, y1, x2, y2 = bbox[0], bbox[1],bbox[2],bbox[3] # 原始坐标
        width = x2 - x1
        height = y2 - y1

        scaled_width = int(width * 1.2)
        scaled_height = int(height * 1.2)

        restored_width = int(scaled_width / 1.2)
        restored_height = int(scaled_height / 1.2)

        restored_x1 = x1 + (width - restored_width) // 2
        restored_y1 = y1 + (height - restored_height) // 2
        restored_x2 = restored_x1 + restored_width
        restored_y2 = restored_y1 + restored_height

        bbox_list = [restored_x1,restored_y1,restored_x2,restored_y2]

        return bbox_list
        

def para_list_correction(images_size,bbox_list,dertpara):

    updata_result_list = []

    for bbox in bbox_list:

        updata_bbox = para_correction(images_size,bbox,dertpara)

        updata_result_list.append(updata_bbox)
        
    return updata_result_list

# 对比数值是否在这个范围内
def contrast(size,bbox_extand_list):

    '''
    对比数值是否在这个范围内
    '''
    
    # print('bbox_extand_list:',bbox_extand_list)
    # print('size:',size)
    bbox_list = []

    for x in bbox_extand_list:

        # print('size:',size)
            
        if 0 <= int(x) <= int(size):
            # print('in:',x,size)
            bbox_list.append(x)
        if int(x) > int(size):
            # print('>:',x,size)
            bbox_list.append(size)
        if int(x) < 0:
            # print('<:',x,size)
            bbox_list.append(0)
    
    # print('bbox_list:',bbox_list)

    return bbox_list


def change_list_dict(fps1,re_list):

    '''
    给列表的结果设置对应帧率
    '''

    bbox_list_all = []

    for bbox_list in re_list:

        bbox_dict = {'fps':fps1,'result':bbox_list}
        bbox_list_all.append(bbox_dict)
        
    return bbox_list_all


def statistics_fps(fps_now,re_list,parameter):

    '''
    统计时长，返回时间满足截取要求的目标坐标
    '''

    time_out_list = []

    for bbox_dict in re_list:

        con_fps = int(fps_now) - int(bbox_dict["fps"])

        if con_fps > parameter:

            time_out_list.append(bbox_dict)
    
    return time_out_list


def change_dict_list(dict_list):
    '''
    从字典列表得到bbox列表
    '''

    bbox_list = []

    for dicts1 in dict_list:

        bbox_list.append(dicts1['result'])
        
    return bbox_list


def select_list(result_list):

    '''
    筛选列表中的空列表
    '''
    if result_list:
        result_only = []

        for result in result_list:

            if result == None :
                pass
            else:

                # result_bbox = select_bbox(result)
                result_only.append(result)
            
        return result_only

def select_bbox(bbox_list):

    # bbox_list_return = []

    # print('bbox:',bbox_list)
    left_top = [min(bbox_list, key=lambda p: p[0])[0], min(bbox_list, key=lambda p: p[1])[1]]
    right_bottom = [max(bbox_list, key=lambda p: p[0])[0], max(bbox_list, key=lambda p: p[1])[1]]

    bbox_list_return = left_top + right_bottom

    
    # print('bbox_list:',bbox_list_return)
 
    return bbox_list_return

# 对比两字典中的值是否完全一致
def compare_dicts(dict1, list_of_dicts):
    for d in list_of_dicts:
        diff = DeepDiff(dict1, d)

        if not diff:
            return False
    return True