pybaseutils 2.4.7__tar.gz → 2.4.9__tar.gz

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybaseutils
-Version: 2.4.7
+Version: 2.4.9
 Summary: pybaseutils
 Home-page: https://github.com/PanJinquan/base-utils
 Author: PanJinquan

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/pybaseutils/__init__.py

@@ -8,4 +8,4 @@
 # --------------------------------------------------------
 """
 
-__version__ = '2.4.7'
+__version__ = '2.4.9'

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/pybaseutils/base/list_queue.py

@@ -113,6 +113,11 @@ class Queue():
             return data1 + data2
         return []
 
+    def clear(self):
+        """清空队列"""
+        with self.queue.mutex:
+            self.queue.queue.clear()
+
 
 if __name__ == '__main__':
     q = Queue(maxsize=3)

pybaseutils-2.4.9/pybaseutils/base/producer_consumer.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+"""
+# --------------------------------------------------------
+# @Author : Pan
+# @E-mail : 
+# @Date   : 2025-10-29 16:52:22
+# @Brief  :
+# --------------------------------------------------------
+"""
+import os
+import numpy as np
+import time
+import threading
+from typing import List, Dict, Callable
+from pybaseutils import thread_utils, file_utils, image_utils, base64_utils
+from pybaseutils.cvutils import video_utils
+from pybaseutils.base import list_queue
+
+thread_lock = threading.Lock()
+
+
+class ProducerConsumer:
+    def __init__(self, winsize=3, overlap=0.0, max_workers=2, **kwargs) -> None:
+        """
+        :param winsize:
+        :param overlap:
+        :param max_workers:
+        :param kwargs:
+        """
+        self.tag = self.__class__.__name__
+        self.log = kwargs.get('log', print) if kwargs.get('log', print) else print
+        self.winsize = winsize
+        self.overlap = overlap
+        self.max_workers = max_workers
+        self.kwargs = kwargs
+        self.producer = list_queue.Queue(maxsize=self.winsize)  # 生产者
+        self.consumer = list_queue.Queue(maxsize=self.winsize)  # 消费者
+        self.producer_end = False  # 生产者是否结束
+        self.consumer_end = False  # 消费者是否结束
+
+    def stop_producer(self):
+        """
+        停止生产者线程
+        :return:
+        """
+        self.producer_end = True
+        self.log("stop producer")
+
+    def stop_consumer(self):
+        """
+        停止消费者线程
+        :return:
+        """
+        self.consumer_end = True
+        self.log("stop consumer")
+
+    def task(self, data: List, *args, **kwargs):
+        """
+        任务函数，处理输入数据
+        :param data: 输入数据
+        :return: 处理结果
+        """
+        self.log(f"args  ={args},kwargs={kwargs}")
+        time.sleep(3)
+        result = "收到消息：" + file_utils.get_time(format="s")
+        return result
+
+    def task_consumer(self, task, *args, **kwargs):
+        """消费者任务"""
+        self.log(f"start consumer thread")
+        self.consumer_end = False
+        pool = thread_utils.ThreadPool(max_workers=self.max_workers)
+        future = []
+        while True:
+            # winsize = self.producer.qsize() if self.producer_end else self.winsize
+            if self.producer_end and self.producer.qsize() <= self.winsize:
+                winsize, overlap = self.producer.qsize(), 0  # TODO 如果生产者已经结束，则一次性处理剩余的数据
+            else:
+                winsize, overlap = self.winsize, self.overlap
+            while self.producer.qsize() >= winsize > 0 and len(future) < self.max_workers:
+                data = self.producer.get_window(winsize=winsize, overlap=overlap, block=False)  # 提取窗口数据
+                f = pool.submit(task, data, args, **kwargs)
+                future.append(f)
+                self.log(f"tid={id(f)} producer={self.producer.qsize()} consumer={self.consumer.qsize()} "
+                         f"winsize={winsize} future={len(future)} ")
+            if not future: time.sleep(0.1)
+            tmp = []
+            for f in future:
+                try:
+                    self.consumer.put(f.result(timeout=0.1))
+                except Exception as e:
+                    tmp.append(f)
+            future = tmp
+            # 生产者队列空，且停止发送数据(pend=True)
+            if len(future) == 0 and self.producer_end and self.producer.qsize() == 0:
+                print(f"finish consumer thread")
+                break
+        self.stop_consumer()  # 消费者停止处理数据
+
+    def start_consumer(self, task: Callable, *args, **kwargs):
+        """启动消费者线程
+        :param task: 任务函数
+        :param args: 任务函数参数
+        :param kwargs: 任务函数参数
+        :return:
+        """
+        thread = threading.Thread(target=self.task_consumer, args=args, kwargs={"task": task, **kwargs})
+        thread.daemon = True
+        thread.start()
+
+
+def example(text, video, realtime=False, freq=2, wintime=3, overlap=0.5, max_workers=2, delay=20, vis=True, **kwargs):
+    """
+    实时分析功能，从视频中提取帧进行分析
+    :param text: 用户问题/任务描述
+    :param video: 视频文件路径或者摄像头ID
+    :param realtime: 是否实时处理视频帧，实时处理会丢弃很多视频帧，非实时会处理所有视频帧，但视频播放会很卡顿
+    :param freq: 视频帧提取频率（Hz）
+    :param wintime:  窗口时间长度，单位秒
+    :param overlap: 滑动窗口重叠比例
+    :param max_workers: 视频处理线程数
+    :return:
+    """
+    winsize = int(wintime * freq)
+    pc = ProducerConsumer(winsize=winsize, overlap=overlap, max_workers=max_workers, **kwargs)
+    # TODO 打开视频文件或摄像头
+    w, h, num_frames, fps = image_utils.get_video_info(video)
+    fpm = 1 / fps
+    interval = int(fps / freq) if fps > 0 else 1
+    video_cap = video_utils.video_iterator(video, save_video=None)
+    pc.start_consumer(task=pc.task, text=text, freq=freq)  # 启动消费者线程
+    # TODO 主线程处理视频帧
+    for data_info in video_cap:
+        t1 = time.time()
+        image = data_info["frame"][:, :, ::-1]  # BGR to RGB
+        image = image_utils.resize_image(image, size=(None, 640))
+        data_info["frame"] = image
+        # TODO 视频抽帧，放入生产者队列，非实时处理会阻塞，实时处理会丢弃旧的视频帧
+        if data_info['count'] % interval == 0:
+            # data_info['text'] = text
+            # data_info['freq'] = freq
+            pc.producer.put(data_info, block=not realtime)
+        if vis: image_utils.show_image("image", image, delay=1, use_rgb=True)
+        if data_info["finish"]: pc.stop_producer()  # 标记生产者是否结束
+        td = time.time() - t1  # 秒
+        time.sleep(max(0.0, fpm - td))  # 保证视频有40ms延时
+        while pc.consumer.qsize() > 0 or (pc.producer_end and not pc.consumer_end):
+            result = pc.consumer.pop(block=False, timeout=0.005)
+            if result: print("result={}".format(result))
+
+
+if __name__ == '__main__':
+    text = "请分析这个视频"
+    video_file = "/home/PKing/Videos/video4.mp4"
+    example(text=text, video=video_file, freq=2)

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/pybaseutils/base64_utils.py

@@ -159,8 +159,8 @@ if __name__ == "__main__":
         print(image_file)
         src = image_utils.read_image(image_file, use_rgb=True)
         image_base64 = image2base64(src, prefix="data:image/jpeg;base64,", )
-        img = Image.fromarray(src)
-        data = {"image": img, "file": image_file}
+        pltimg = Image.fromarray(src)
+        data = {"image": pltimg, "file": image_file}
         data = serialization(data)
         data = deserialization(data)
         dst = data["image"]

pybaseutils-2.4.9/pybaseutils/cvutils/camera.py

@@ -0,0 +1,90 @@
+import cv2
+import time
+import numpy as np
+import subprocess
+
+
+class CameraCapture(object):
+    def __init__(self, video: str or int = 0, size=(1920, 1080), fps=30):
+        """
+        :param video: 视频设备路径或索引（如 0 或 "/dev/video0"）
+        :param size: 视频分辨率 (宽, 高)
+        :param fps: 视频帧率
+        """
+        self.size = size
+        self.fps = fps
+        self.stopped = False
+        if isinstance(video, int): video = f"/dev/video{video}"
+        # 构建 FFmpeg 命令
+        # -re: 以原生帧率读取（模拟直播流）
+        # -fflags nobuffer: 关键！禁用缓冲区
+        # -flags low_delay: 关键！低延迟模式
+        # -probesize 32: 减小探测包大小，加快启动
+        # -pix_fmt bgr24: 直接输出 BGR 格式，方便 OpenCV/Numpy 使用，避免后续转换
+        command = [
+            'ffmpeg',
+            '-re',  # 按帧率读取
+            '-fflags', 'nobuffer',  # 无缓冲
+            '-flags', 'low_delay',  # 低延迟
+            '-probesize', '32',  # 快速探测
+            '-i', video,  # 输入设备
+            '-f', 'rawvideo',  # 输出原始视频流
+            '-pix_fmt', 'bgr24',  # 像素格式 BGR (OpenCV 格式)
+            '-s', f'{size[0]}x{size[1]}',  # 分辨率
+            '-r', str(fps),  # 帧率
+            '-'  # 输出到 stdout
+        ]
+        # 启动进程
+        self.pipe = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=10 ** 8)
+        print(f"command: {' '.join(command)}")
+
+    def read(self):
+        if self.stopped:
+            self.stop()
+            return False, None
+        # 读取一帧的数据量 (宽 * 高 * 3通道)
+        buf = self.pipe.stdout.read(self.size[0] * self.size[1] * 3)
+        if len(buf) != self.size[0] * self.size[1] * 3:
+            self.stop()
+            return False, None  # 读取失败或结束
+        # 将字节流转换为 numpy 数组
+        frame = np.frombuffer(buf, dtype=np.uint8).reshape((self.size[1], self.size[0], 3))
+        return True, frame
+
+    def release(self):
+        self.stop()
+
+    def stop(self):
+        self.stopped = True
+        time.sleep(0.1)
+        self.pipe.terminate()  # 终止进程
+        try:
+            outs, errs = self.pipe.communicate(timeout=2)
+        except subprocess.TimeoutExpired as err:
+            # 如果 communicate 也超时（极少见），强制杀死
+            self.pipe.kill()
+            self.pipe.communicate()  # 再次尝试清理
+            print(err)
+
+    def display(self):
+        while True:
+            t1 = time.time()
+            ret, frame = self.read()
+            t2 = time.time()
+            if not ret:
+                break
+            t21 = (t2 - t1) * 1000
+            print(f"image shape: {frame.shape},耗时: {t21:.3f}ms")
+            cv2.imshow('FFmpeg Low Latency', frame)
+            if cv2.waitKey(30) & 0xFF == ord('q'):
+                break
+
+
+if __name__ == '__main__':
+    fps = 30
+    width = 1920
+    height = 1080
+    video = 0  # Windows 下可能是 0 或 "video=Integrated Webcam"
+    # video = "/home/PKing/Videos/demo-src.mp4"  # Windows 下可能是 0 或 "video=Integrated Webcam"
+    cap = CameraCapture(video=video, size=(width, height), fps=fps)
+    cap.display()

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/pybaseutils/cvutils/video_utils.py

@@ -11,6 +11,7 @@ import os
 import cv2
 import numpy as np
 import math
+import time as timelib
 from typing import Callable
 from tqdm import tqdm
 from pybaseutils import image_utils, file_utils
@@ -23,6 +24,26 @@ get_video_info = image_utils.get_video_info
 get_video_writer = image_utils.get_video_writer
 
 
+def get_usb_camera(video=-1, max_index=50):
+    """
+    获取当前系统中连接的USB摄像头索引。
+    :param video: 视频路径或摄像头索引,默认值为-1表示自动检测。当video>=0时,不进行检测，直接返回video。
+    :param max_index: 最大检测索引范围,默认值为50。
+    :return: 一摄像头索引,camera=-1表示未检测到摄像头。
+    """
+    if video >= 0: return video
+    print("正在检测USB摄像头ID...")
+    camera = -1
+    for i in range(max_index):
+        cap = cv2.VideoCapture(i)
+        if cap.isOpened():
+            camera = i
+            cap.release()
+            break
+    print("检测到USB摄像头ID={}".format(camera))
+    return camera
+
+
 def merge_video(video1, video2, output="./output.mp4"):
     cmd = f'ffmpeg -i {video1} -i {video2} -filter_complex "[0:v:0][1:v:0]concat=n=2:v=1:a=0[outv]" -map "[outv]" {output}'
 
@@ -147,11 +168,11 @@ def video2frames(video_file, out_dir=None, task: Callable = None, interval=1, si
             frame_file = os.path.join(out_dir, "{}_{:0=5d}.jpg".format(filename, count))
             cv2.imwrite(frame_file, frame)
             data_info["file"] = frame_file
-        frames.append(data_info)
+        if not out_dir: frames.append(data_info)
     return frames
 
 
-def video2frames_similarity(video_file, out_dir=None, func=None, interval=1, thresh=0.3, vis=True, **kwargs):
+def video2frames_similarity(video_file, out_dir=None, func=None, prefix="", interval=1, thresh=0.3, vis=True, **kwargs):
     """
     视频抽帧图像
     :param video_file: 视频文件
@@ -162,7 +183,8 @@ def video2frames_similarity(video_file, out_dir=None, func=None, interval=1, thr
     :return:
     """
     sm = monitor.StatusMonitor()
-    name = os.path.basename(video_file).split(".")[0]
+    name = os.path.basename(video_file).split(".")[0].replace("-", "_")
+    if prefix: name = f"{prefix}_{name}"
     if not out_dir:  out_dir = os.path.join(os.path.dirname(video_file), name)
     video_cap = get_video_capture(video_file)
     width, height, num_frames, fps = get_video_info(video_cap, **kwargs)
@@ -181,13 +203,13 @@ def video2frames_similarity(video_file, out_dir=None, func=None, interval=1, thr
                 last_frame = curr_frame.copy()
             diff = sm.get_frame_similarity(curr_frame, last_frame, size=(256, 256), vis=False)
             if diff > thresh:
-                frame_file = os.path.join(out_dir, "{}_{:0=4d}.jpg".format(name, count))
+                frame_file = os.path.join(out_dir, "{}_{:0=6d}.jpg".format(name, count))
                 last_frame = curr_frame.copy()
                 cv2.imwrite(frame_file, curr_frame)
                 frame_files.append(frame_file)
             if vis:
                 text = "TH={},diff={:3.3f}".format(thresh, diff)
-                image = image_utils.draw_text(curr_frame, point=(10, 70), color=(0, 255, 0),
+                image = image_utils.draw_text(curr_frame, point=(10, 100), color=(0, 255, 0),
                                               text=text, drawType="simple")
                 image = image_utils.cv_show_image("image", image, delay=5)
         count += 1
@@ -245,7 +267,7 @@ def video2video(video_file: int or str, save_video: str or int, interval=1, size
     :param interval: 间隔
     :return:
     """
-    video_capture(video_file=video_file, save_video=save_video, interval=interval, size=size, freq=freq, task=task,
+    video_capture(video=video_file, save_video=save_video, interval=interval, size=size, freq=freq, task=task,
                   vis=vis, **kwargs)
 
 
@@ -284,11 +306,11 @@ def resize_video(video_file, save_video, size=(), start=0, interval=1, vis=True,
     video_writer.release()
 
 
-def video_capture(video_file: int or str, save_video: str or int = None, interval=1, size=(), freq=0,
+def video_capture(video: int or str, save_video: str or int = None, interval=1, size=(), freq=0,
                   task: Callable = None, vis=True, **kwargs):
     """
     读取摄像头或者视频流
-    :param video_file: String 视频文件，如*.avi,*.mp4,...
+    :param video: String 视频文件，如*.avi,*.mp4,...
                        Int 摄像头ID，如0，1，2
     :param save_video: 保存task视频处理后的结果
     :param interval: 抽帧处理间隔
@@ -299,13 +321,13 @@ def video_capture(video_file: int or str, save_video: str or int = None, interva
                  title: 控制显示窗口名
     :return:
     """
-    video_file = file_utils.str2number(video_file)
-    if isinstance(video_file, str) and os.path.isfile(video_file):
-        assert os.path.exists(video_file), f"video_file={video_file}"
-    video_cap = image_utils.get_video_capture(video_file, fps=None)
-    w, h, num_frames, fps = image_utils.get_video_info(video_cap, **kwargs)
+    video = file_utils.str2number(video)
+    if isinstance(video, str) and os.path.isfile(video):
+        assert os.path.exists(video), f"video={video}"
+    cap = image_utils.get_video_capture(video, fps=None)
+    w, h, num_frames, fps = image_utils.get_video_info(cap, **kwargs)
     time = kwargs.get("time", tuple())  # TODO 开始播放时间time[0]，结束播放时间time[1]，单位秒S
-    clip = kwargs.get("clip", tuple())  # TODO 开始播放位置index[0]，结束播放位置index[1]
+    clip = kwargs.get("clip", tuple())  # TODO 开始播放位置clip[0]，结束播放位置clip[1]
     start, end = 0, -1
     if time and fps > 0:
         start, end = int(time[0] * fps), int(time[1] * fps)
@@ -319,10 +341,10 @@ def video_capture(video_file: int or str, save_video: str or int = None, interva
     count = 0
     video_writer = None
     while True:
-        ret, frame = video_cap.read()
+        ret, frame = cap.read()
         if count % interval == 0 and count >= start:
             # TODO 设置抽帧的位置，但某些格式视频容易出现问题
-            # if isinstance(video_file, str): video_cap.set(cv2.CAP_PROP_POS_FRAMES, count)
+            # if isinstance(video, str): video_cap.set(cv2.CAP_PROP_POS_FRAMES, count)
             # ret, frame = video_cap.read()
             if not ret or 0 < end < count or frame is None: break
             if size: frame = image_utils.resize_image(frame, size=size)
@@ -333,23 +355,23 @@ def video_capture(video_file: int or str, save_video: str or int = None, interva
                 if not video_writer: video_writer = image_utils.get_video_writer(save_video, w, h, save_fps)
                 video_writer.write(frame)
         count += 1
-    video_cap.release()
+    cap.release()
     if video_writer:
         print("save video:{}".format(save_video))
         video_writer.release()
 
 
-def video_iterator(video_file, save_video: str or int = None, interval=1, size=(), freq=0,
+def video_iterator(video, save_video: str or int = None, interval=1, size=(), freq=0,
                    task: Callable = None, vis=False, **kwargs):
     """
     读取摄像头或者视频流迭代器
     Usage:
         from pybaseutils.cvutils import video_utils
-        video_cap = video_utils.video_iterator(video_file, save_video, time=(4, 10))
-        for data_info in video_cap:
+        cap = video_utils.video_iterator(video, save_video, time=(4, 10))
+        for data_info in cap:
             frame = data_info["frame"]
             ...
-    :param video_file: String 视频文件，如*.avi,*.mp4,...
+    :param video: String 视频文件，如*.avi,*.mp4,...
                        Int 摄像头ID，如0，1，2
     :param save_video: 保存task视频处理后的结果
     :param interval: 抽帧处理间隔，当interval=-1，表示当interval=fps,即一秒一帧
@@ -360,20 +382,20 @@ def video_iterator(video_file, save_video: str or int = None, interval=1, size=(
                  delay: 控制显示延时,默认10S
                  title: 控制显示窗口名，默认video
                  time: 开始播放时间time[0]，结束播放时间time[1]，单位秒S
-                 clip: 开始播放位置index[0]，结束播放位置index[1]
+                 clip: 开始播放位置clip[0]，结束播放位置clip[1]
                  speed: 保存视频的播放速度，默认是播放帧率
                  save_fps: 保存视频的帧率，默认是播放帧率
     :return: frame, count, w, h, fps =data_info['frame'],data_info['count'],data_info['w'],data_info['h'],data_info['fps']
              当输入是视频文件时，返回视频偏移量time和duration都是播放时间，单位S，差异不大
              当输入是摄像头时， 返回视频偏移量time是视频播放时间，duration是根据count计算的播放的时间
     """
-    video_file = file_utils.str2number(video_file)
-    if isinstance(video_file, str) and os.path.isfile(video_file):
-        assert os.path.exists(video_file), f"video_file={video_file}"
-    video_cap = image_utils.get_video_capture(video_file, fps=None)
-    w, h, num_frames, fps = image_utils.get_video_info(video_cap, **kwargs)
+    video = file_utils.str2number(video)
+    if isinstance(video, str) and os.path.isfile(video):
+        assert os.path.exists(video), f"video={video}"
+    cap = image_utils.get_video_capture(video, fps=None)
+    w, h, num_frames, fps = image_utils.get_video_info(cap, **kwargs)
     time = kwargs.get("time", tuple())  # TODO 开始播放时间time[0]，结束播放时间time[1]，单位秒S
-    clip = kwargs.get("clip", tuple())  # TODO 开始播放位置index[0]，结束播放位置index[1]
+    clip = kwargs.get("clip", tuple())  # TODO 开始播放位置clip[0]，结束播放位置clip[1]
     start, end = 0, -1
     if time and fps > 0:
         start, end = int(time[0] * fps), int(time[1] * fps)
@@ -390,16 +412,17 @@ def video_iterator(video_file, save_video: str or int = None, interval=1, size=(
     data_info = {}
     t0 = -1
     while True:
-        ret, frame = (False, None) if use_fast else video_cap.read()
-        t = video_cap.get(cv2.CAP_PROP_POS_MSEC) / 1000  # 获得视频偏移量毫秒为单位
+        systime = timelib.time()
+        ret, frame = (False, None) if use_fast else cap.read()  # 读取视频很快，但读取USB摄像头比较耗时
+        t = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000  # 获得视频偏移量毫秒为单位
         if t0 < 0 < t: t0 = t
         if t0 > 0: t = t - t0  # 获得视频偏移量毫秒为单位
         finish = 0 < end <= (count + interval)
         if count % interval == 0 and count >= start:
             # TODO 设置抽帧的位置，但某些格式视频容易出现问题
-            if use_fast and isinstance(video_file, str):
-                video_cap.set(cv2.CAP_PROP_POS_FRAMES, count)
-                ret, frame = video_cap.read()
+            if use_fast and isinstance(video, str):
+                cap.set(cv2.CAP_PROP_POS_FRAMES, count)
+                ret, frame = cap.read()
             if not ret or 0 < end <= count or frame is None: break
             if size: frame = image_utils.resize_image(frame, size=size)
             if task: frame = task(frame, **kwargs)
@@ -407,7 +430,7 @@ def video_iterator(video_file, save_video: str or int = None, interval=1, size=(
             d = round(count / fps, 3)  # TODO 通过fps计算播放时间
             t = round(t, 3)  # 通过视频偏移量计算播放时间
             data_info = {"count": count, "time": t, "frame": frame, "w": w, "h": h, "fps": fps,
-                         "finish": finish, 'duration': d}
+                         "finish": finish, 'duration': d, 'systime': systime}
             # TODO 返回data_info
             yield data_info
             frame = data_info["frame"]
@@ -416,8 +439,9 @@ def video_iterator(video_file, save_video: str or int = None, interval=1, size=(
                 h, w = frame.shape[:2]
                 if not video_writer: video_writer = image_utils.get_video_writer(save_video, w, h, save_fps)
                 video_writer.write(frame)
+            if data_info['finish']: break  # 控制结束
         count += 1
-    video_cap.release()
+    cap.release()
     if video_writer:
         print("save video:{}".format(save_video))
         video_writer.release()

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/pybaseutils/dataloader/parser_labelme.py

@@ -14,6 +14,7 @@ import glob
 import random
 import numbers
 import json
+import traceback
 from tqdm import tqdm
 from pybaseutils import image_utils, file_utils, json_utils, text_utils
 from pybaseutils.dataloader.base_dataset import Dataset, ConcatDataset
@@ -145,21 +146,26 @@ class LabelMeDataset(Dataset):
         class_name = []
         for image_id in tqdm(image_ids, desc="check data"):
             image_file, anno_file, image_id = self.get_image_anno_file(image_id)
-            if not os.path.exists(anno_file):
-                continue
-            if not os.path.exists(image_file):
-                continue
-            annotation, width, height = self.load_annotations(anno_file)
-            data_info = self.parser_annotation(annotation, self.total_names, size=(width, height),
-                                               min_points=self.min_points,
-                                               unique=self.unique)
-            if self.use_kpt:
-                data_info = self.get_kpts_info(data_info, anno_file=anno_file, check_kpt=self.check_kpt, disp=True)
-            labels = data_info["labels"]
-            if len(labels) == 0:
+            try:
+                if not os.path.exists(anno_file):
+                    continue
+                if not os.path.exists(image_file):
+                    continue
+                annotation, width, height = self.load_annotations(anno_file)
+                data_info = self.parser_annotation(annotation, self.total_names, size=(width, height),
+                                                   min_points=self.min_points,
+                                                   unique=self.unique)
+                if self.use_kpt:
+                    data_info = self.get_kpts_info(data_info, anno_file=anno_file, check_kpt=self.check_kpt, disp=True)
+                labels = data_info["labels"]
+                if len(labels) == 0:
+                    continue
+                dst_ids.append(image_id)
+                class_name += labels
+            except Exception as e:
+                traceback.print_exc()
+                print(anno_file)
                 continue
-            dst_ids.append(image_id)
-            class_name += labels
         if self.class_name is None:
             class_name = sorted(list(set(class_name)))
             self.class_name, self.class_dict = self.parser_classes(class_name)
@@ -417,8 +423,8 @@ class LabelMeDataset(Dataset):
             with open(anno_file, "r") as f:
                 annotation: dict = json.load(f)
             annos = annotation.get("shapes", [])
-            width = annotation.get('imageWidth', -1)
-            height = annotation.get('imageHeight', -1)
+            width = int(annotation.get('imageWidth', -1))
+            height = int(annotation.get('imageHeight', -1))
         except Exception as e:
             # print(e,"illegal annotation:{}".format(anno_file))
             annos = []

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/pybaseutils/dict_uils.py

@@ -15,7 +15,7 @@ from collections import defaultdict
 
 class Objects(object):
     def __init__(self, boxes, label, score, names=[], size=[], segms=None, masks=None, keypt=None,
-                 traid=None, trace=None, color=[], image=None):
+                 traid=None, trace=None, color=[], image=None, file=""):
         self.boxes = boxes  # 目标框(xmin,ymin,xmax,ymax)
         self.score = score  # 目标框置信度
         self.label = label  # 目标框类别
@@ -28,6 +28,7 @@ class Objects(object):
         self.trace = trace  # 轨迹的历史boxes
         self.color = [(255, 0, 0)] * len(boxes)  # 目标框颜色
         self.size = size  # 原始图像大小
+        self.file = file  # 文件路径
         self.depth = None  # 深度图
         self.metas = defaultdict()  # 其他信息
 

{pybaseutils-2.4.7 → pybaseutils-2.4.9}/pybaseutils/file_utils.py

@@ -1579,6 +1579,7 @@ def zip_file(src, dst=None, s=None):
     return dst
 
 
+
 if __name__ == '__main__':
     from pybaseutils import time_utils