CameraMachine/python/utils/utils_func.py

import os
from hashlib import sha256, md5
from datetime import datetime
import requests
from natsort import ns, natsorted

def get_md5(file_path):
    data_md5 = None
    if os.path.isfile(file_path):
        f = open(file_path, 'rb')
        md5_obj = md5()
        md5_obj.update(f.read())
        hash_code = md5_obj.hexdigest()
        f.close()
        data_md5 = str(hash_code).lower()
    return data_md5

def get_modified_time(file_path):
    # 获取文件最后修改的时间戳
    timestamp = os.path.getmtime(file_path)
    # 将时间戳转换为datetime对象，并格式化为指定格式的字符串
    modified_time = datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
    return modified_time

def compare_two_times(time_str1, time_str2):
    # 定义时间格式
    time_format = "%Y-%m-%d %H:%M:%S"
    # 将时间字符串解析为datetime对象
    time1 = datetime.strptime(time_str1, time_format)
    time2 = datetime.strptime(time_str2, time_format)

    # 比较两个时间
    if time1 > time2:
        # print(f"{time_str1} 比 {time_str2} 新。")
        return "left_new"
    elif time1 < time2:
        # print(f"{time_str2} 比 {time_str1} 新。")
        return "right_new"
    else:
        # print("两个时间相等。")
        return "is_same"


async def download_file(url, file_path):
    try:
        root_path, file_name = os.path.split(file_path)
        check_path(root_path)
        response = requests.get(url)
        _content = response.content
        with open(file_path, 'wb') as f:
            f.write(_content)
        print("下载成功:{}".format(file_path))
    except:
        print("下载失败:{}".format(file_path))

def check_path(_path):
    if not os.path.exists(_path):
        # 创建多级目录
        os.makedirs(_path, exist_ok=True)
        # os.mkdir(_path)
    return True


# from module.view_control.MineQWidget import MineQWidget
def list_dir(path):
    listdir = os.listdir(path)
    return natsorted(listdir, alg=ns.PATH)


def get_folder(path):
    folder_list = []
    for _file in list_dir(path):
        file_path = "{}/{}".format(path, _file)
        if os.path.isdir(file_path):
            folder_list.append(
                {
                    "folder_path": file_path,
                    "folder_name": _file,
                    "root_path": path,
                    "label": "待处理",  # 是否需要继续处理
                }
            )
    return folder_list


def get_images(path):
    _Type = [".png", ".PNG", ".jpg", ".JPG", ".gif", ".GIF", ".jpge", ".JPGE", ".CR2"]
    image_list = []  # 过滤非图片数据
    for _file in list_dir(path):
        file_name, e = os.path.splitext(_file)
        file_path = "{}/{}".format(path, _file)
        if os.path.isdir(file_path):
            continue
        if e in _Type and "mask" not in file_name:
            image_list.append(
                {
                    "file_path": file_path,
                    "file_name": file_name,
                    "file": _file,
                    "root_path": path,
                    "e": e,
                }
            )
    return image_list


def httpGetHandler(url, params=None, headers=None):
    """
        发送GET请求
        :param endpoint: 请求的端点
        :param params: 查询参数
        :param headers: 请求头
        :return: 响应对象
        """
    try:
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()  # 如果响应状态码不是200，抛出异常
        return response
    except requests.exceptions.RequestException as e:
        print(f"GET请求失败: {e}")
        return None


def httpPosthandler(url, data=None, json=None, headers=None):
    """
        发送POST请求
        :param endpoint: 请求的端点
        :param data: 表单数据
        :param json: JSON数据
        :param headers: 请求头
        :return: 响应对象
        """
    try:
        response = requests.post(url, data=data, json=json, headers=headers)
        response.raise_for_status()  # 如果响应状态码不是200，抛出异常
        return response
    except requests.exceptions.RequestException as e:
        print(f"POST请求失败: {e}")
        return None


# 指定一个列表，指定一个需要移动的数据列表，移动到指定列表中的位置
def move_elements_inplace(lst, indices, target_index, is_real_same_folder=False):
    """
    在原地将列表中指定位置的两个元素移动到目标位置。

    :param lst: 要操作的列表
    :param indices: 一个包含两个整数的元组或列表，表示要移动的元素的索引
    :param target_index: 目标插入位置的索引
    """

    if not isinstance(indices, (list, tuple)) or len(indices) == 0:
        raise ValueError("Indices must be a non-empty list or tuple of integers.")

    # 添加到末尾
    if target_index == len(lst):
        if is_real_same_folder:
            # 倒序取出所有内容，并添加到末尾
            indices.sort(reverse=True)
            temp = []
            for i in indices:
                temp.append(lst.pop(i))
            while temp:
                lst.append(temp.pop(-1))

        # 重新写入索引
        for index, image_label in enumerate(lst):
            image_label.image_index = index
        return

    # 检查索引是否有效，并排序以确保按照正确的顺序处理
    valid_indices = sorted(set(indices))  # 去重并排序
    if not all(0 <= idx < len(lst) for idx in valid_indices):
        raise IndexError("One or more indices are out of range.")

    if not (0 <= target_index <= len(lst)):
        raise IndexError("Target index is out of range.")

    elements_to_move = [lst[idx] for idx in valid_indices]

    # 如果目标位置在所有待移动元素的最大索引之后，则不需要调整目标位置
    max_idx = max(valid_indices)
    if max_idx < target_index:
        pass
    else:
        # 计算需要减少的位置数（因为删除元素后，后续元素会向前移动）
        shift_count = sum(1 for idx in valid_indices if idx < target_index)
        target_index -= shift_count

    # 移除元素（从大索引开始以避免影响小索引处的元素）
    for idx in reversed(valid_indices):
        del lst[idx]

    # 插入元素到目标位置，保持它们原来的相对顺序
    for i, element in enumerate(elements_to_move):
        lst.insert(target_index + i, element)

    # 重新写入索引
    for index, image_label in enumerate(lst):
        image_label.image_index = index


# 给定一个图片路径，如果 是原始图下的则返回对应已扣图等信息。否则只返回基础信息
def get_cutout_image_info(source_image_path):
    if not os.path.exists(source_image_path):
        return None
    if os.path.isdir(source_image_path):
        return None

    data = {}
    source_root_path, source_file = os.path.split(source_image_path)
    source_file_name, source_file_extension = os.path.splitext(source_file)
    print("---------------source_root_path--------------------")
    print(source_root_path)
    print(source_root_path[-3:])
    # if source_root_path[-3:] != "原始图":
    #     return None

    data["source_image_path"] = source_image_path
    data["source_root_path"] = source_root_path
    data["source_file"] = source_file
    data["source_file_name"] = source_file_name
    data["source_file_extension"] = source_file_extension

    cutout_image_path = "{}/原始图_已抠图/{}.png".format(
        source_root_path[:-3], source_file_name
    )
    if not os.path.exists(cutout_image_path):
        data["cutout_image_path"] = None
        return data

    cutout_image_root_path, cutout_image_file = os.path.split(cutout_image_path)
    cutout_image_file_name, cutout_image_file_extension = os.path.splitext(
        cutout_image_file
    )
    data["cutout_image_path"] = cutout_image_path
    data["cutout_image_root_path"] = cutout_image_root_path
    data["cutout_image_file"] = cutout_image_file
    data["cutout_image_file_name"] = cutout_image_file_name
    data["cutout_image_file_extension"] = cutout_image_file_extension
    return data