dnt 0.2.4__py3-none-any.whl → 0.3.1.3__py3-none-any.whl

dnt/track/dsort/deep_sort/sort/nn_matching.py

@@ -1,7 +1,6 @@
 # vim: expandtab:ts=4:sw=4
 import numpy as np
 
-
 def _pdist(a, b):
     """Compute pair-wise squared distance between points in `a` and `b`.
 
@@ -19,7 +18,7 @@ def _pdist(a, b):
         contains the squared distance between `a[i]` and `b[j]`.
 
     """
-    a, b = np.asarray(a), np.asarray(b)
+    a, b = np.asarray(a), np.asarray(b)    
     if len(a) == 0 or len(b) == 0:
         return np.zeros((len(a), len(b)))
     a2, b2 = np.square(a).sum(axis=1), np.square(b).sum(axis=1)
@@ -27,7 +26,6 @@ def _pdist(a, b):
     r2 = np.clip(r2, 0., float(np.inf))
     return r2
 
-
 def _cosine_distance(a, b, data_is_normalized=False):
     """Compute pair-wise cosine distance between points in `a` and `b`.
 
@@ -49,8 +47,10 @@ def _cosine_distance(a, b, data_is_normalized=False):
 
     """
     if not data_is_normalized:
-        a = np.asarray(a) / np.linalg.norm(a, axis=1, keepdims=True)
-        b = np.asarray(b) / np.linalg.norm(b, axis=1, keepdims=True)
+        #a = np.asarray(a) / np.linalg.norm(a, axis=1, keepdims=True)
+        #b = np.asarray(b) / np.linalg.norm(b, axis=1, keepdims=True)
+        a = np.array(a, dtype=np.longdouble) / np.linalg.norm(a, axis=1, keepdims=True)
+        b = np.array(b, dtype=np.longdouble) / np.linalg.norm(b, axis=1, keepdims=True)
     return 1. - np.dot(a, b.T)
 
 

dnt/track/dsort/deep_sort/sort/preprocessing.py

@@ -2,7 +2,6 @@
 import numpy as np
 import cv2
 
-
 def non_max_suppression(boxes, max_bbox_overlap, scores=None):
     """Suppress overlapping detections.
 
@@ -37,7 +36,7 @@ def non_max_suppression(boxes, max_bbox_overlap, scores=None):
     if len(boxes) == 0:
         return []
 
-    boxes = boxes.astype(float)
+    boxes = boxes.astype(np.float64)
     pick = []
 
     x1 = boxes[:, 0]

dnt/track/dsort/dsort.py

@@ -1,37 +1,25 @@
-import os
+import os, sys
 import cv2
 import torch
 import numpy as np
 import pandas as pd
 from tqdm import tqdm
 
-from deep_sort import DeepSort
-from utils.parser import get_config
-
-def track(video_file:str, det_file:str, out_file:str = None, gpu:bool = True, 
-            reid_ckpt:str = './deep_sort/deep/checkpoint/ckpt.t7',
-            max_dist:float = 0.2, min_confidence:float = 0.3, nms_max_overlap: float = 1.0, 
-            max_iou_distance:float = 0.7, max_age:int = 70, n_init:int = 3, nn_budget:int = 100, 
-            video_index:int = None, total_videos:int = None):
-    
-    cwd = os.path.dirname(__file__)
-    #deepsort_cfg = os.path.join(cwd, deepsort_cfg)
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
-    #cfg = get_config()
-    #cfg.merge_from_file(deepsort_cfg)
+from deep_sort import DeepSort
+from config import Config
 
-    device = torch.device('cuda') if (torch.cuda.is_available() and gpu) else torch.device('cpu')
+def track(video_file:str, det_file:str, out_file:str = None, device:str = 'auto', half:bool = False,
+            cfg:dict = Config.get_cfg_dsort('default'), video_index:int = None, total_videos:int = None):
+  
+    #device = torch.device('cuda') if (torch.cuda.is_available() and gpu) else torch.device('cpu')
     cap = cv2.VideoCapture(video_file)
     if not cap.isOpened():
         raise IOError("Couldn't open webcam or video")
-
-    #deepsort = build_tracker(cfg, use_cuda=gpu)
-
-    deepsort = DeepSort(model_path=os.path.join(cwd,reid_ckpt), 
-                max_dist=max_dist, min_confidence=min_confidence, 
-                nms_max_overlap=nms_max_overlap, max_iou_distance=max_iou_distance, 
-                max_age=max_age, n_init=n_init, nn_budget=nn_budget, use_cuda=gpu)
-
+    
+    deepsort = DeepSort(cfg, device, half)
+    
     detections = pd.read_csv(det_file, header=None).to_numpy()
     start_frame = int(min(detections[:,0]))
     end_frame = int(max(detections[:,0]))
@@ -56,12 +44,12 @@ def track(video_file:str, det_file:str, out_file:str = None, gpu:bool = True,
         nrows, ncols = frame_dets.shape
 
         if nrows > 0:
-            bbox_xywh=[]
+            bbox_xywh = []
             for det in frame_dets:
                 bbox_xywh.append([det[2]+det[4]/2, det[3]+det[5]/2, det[4], det[5]])
             bbox_xywh = np.array(bbox_xywh)
             conf_score = np.array(frame_dets[:,6])
-
+            classes = np.array(frame_dets[:,7])
             outputs = deepsort.update(bbox_xywh, conf_score, im)
 
             if len(outputs) > 0:
@@ -78,9 +66,14 @@ def track(video_file:str, det_file:str, out_file:str = None, gpu:bool = True,
 
 if __name__ == "__main__":
 
-    video_file = "/mnt/d/videos/ped2stage/1026_2/videos/gh011293.mp4"
-    iou_file = "/mnt/d/videos/ped2stage/1026_2/dets/gh011293_iou_ped.txt"
-    out_file = "/mnt/d/videos/ped2stage/1026_2/tracks/gh011293_ped_track_2.txt"
+    '''
+    video_file = "/mnt/d/videos/ped2stage/videos/gh1293.mp4"
+    iou_file = "/mnt/d/videos/ped2stage/dets/gh1293_iou_ped.txt"
+    out_file = "/mnt/d/videos/ped2stage/tracks/gh1293_ped_track_2.txt"
+    '''
+    video_file = "/mnt/d/videos/samples/ped_veh.mp4"
+    iou_file = "/mnt/d/videos/samples/dets/ped_veh_iou.txt"
+    out_file = "/mnt/d/videos/samples/tracks/ped_veh_track.txt"
 
     track(video_file, iou_file, out_file)
     

dnt/track/re_class.py

@@ -0,0 +1,94 @@
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+from ..detect import Detector
+from ..engine.iob import iobs
+
+class ReClass:
+    def __init__(self, num_frames:int=25, threshold:float=0.75, model:str='rtdetr', device:str='auto',
+                 default_class:int=0, match_class:list=[1, 36]) -> None:
+        self.detector = Detector(model=model, device=device)
+        self.num_frames = num_frames
+        self.threshold = threshold
+        self.default_class = default_class
+        self.match_class = match_class
+           
+    def match_mmv(self, track:pd.DataFrame, dets:pd.DataFrame)->tuple:
+    
+        score = 0
+        cnt = 0
+        for idx, row in track.iterrows():
+            bboxes = row[['x', 'y', 'w', 'h']].values.reshape(1, -1)
+            det = dets[dets['frame'] == row['frame']]
+            if len(det) > 0:
+                match_bboxes = det[['x', 'y', 'w', 'h']].values
+                _, overlaps_mmv = iobs(bboxes, match_bboxes)
+                max_overlap = np.max(overlaps_mmv)
+                if max_overlap >= self.threshold:
+                    score += max_overlap
+                    cnt += 1
+
+        if cnt > 0:
+            avg_score = score/cnt
+        else:
+            avg_score = 0
+        hit = True if avg_score >= self.threshold else False
+
+        return hit, avg_score
+
+    def re_classify(self, tracks:pd.DataFrame, input_video:str, track_ids:list=None, 
+                 out_file:str=None, verbose:bool=True)->pd.DataFrame:
+        """
+        Re-classify tracks
+        Parameters:
+            tracks: DataFrame with target tracks
+            input_video: Path to video
+            track_ids: List of track IDs for re-classify, if None re-classify all tracks, default None
+            default_cls: Default class to assign if no match found, default 0 (pedestrian)
+            match_cls: List of classes to match, default [1, 36] (bicycle, skateboard/scooter)
+            out_file: Path to save re-classified tracks, default None
+        Returns:
+            DataFrame with re-classified tracks (track_id, cls, avg_score)
+        """
+
+        if track_ids is None:
+            track_ids = tracks['track'].unique().tolist()
+
+        results = []
+        pbar = tqdm(total=len(track_ids), unit='track', desc='Re-classifying tracks')
+        for track_id in track_ids:
+            
+            target_track = tracks[tracks['track'] == track_id].copy()
+            target_track['area'] = target_track['w'] * target_track['h']
+            target_track.sort_values(by='area', inplace=True, ascending=False)
+
+            if len(target_track) >= self.num_frames:
+                top_frames = target_track.head(self.num_frames)
+            else:
+                top_frames = target_track
+
+            dets = self.detector.detect_frames(input_video, top_frames['frame'].values.tolist())
+
+            matched = [] 
+            for cls in self.match_class:
+                match_dets = dets[dets['class'] == cls]
+                hit, avg_score = self.match_mmv(top_frames, match_dets)
+                if hit:
+                    matched.append((cls, avg_score))
+            
+            if len(matched) > 0:
+                cls, avg_score = max(matched, key=lambda x: x[1])
+            else:
+                cls = self.default_class
+                avg_score = 0
+
+            results.append([track_id, cls, round(avg_score, 2)])
+            if verbose:
+                pbar.update()
+        pbar.close()
+
+        df = pd.DataFrame(results, columns=['track', 'cls', 'avg_score'])
+        if out_file:
+            df.to_csv(out_file, index=False)
+
+        return df   

dnt/track/sort/sort.py

@@ -283,8 +283,12 @@ def track(det_file, out_file, max_age=1, min_inits=3, iou_threshold=0.3, video_i
     df = pd.DataFrame(results)
     df[3] = df[3] - df[1]
     df[4] = df[4] - df[2]
+    df[6] = -1
+    df[7] = -1
+    df[8] = -1
+    df[9] = -1
     df = df.astype('int')
-    df[[0,5,1,2,3,4]].to_csv(out_file, index=False, header=None)
+    df[[0,5,1,2,3,4,6,7,8,9]].to_csv(out_file, index=False, header=None)
 
 if __name__ == '__main__':
   pass

dnt/track/tracker.py

@@ -1,37 +1,53 @@
 import os, sys
 sys.path.append(os.path.dirname(__file__))
 
+import torch
 from dsort import track as track_dsort
 from sort import track as track_sort
+from botsort import track as track_botsort
+from config import Config
+import pandas as pd
+from tqdm import tqdm
+import numpy as np
+from ..engine import interpolate_bbox, interpolate_bboxes, cluster_by_gap
 
-class Tracker:
-    def __init__(self, method:str='sort', 
-                 sort_cfg: dict = {'max_age':1, 'min_inits':3, 'iou_threshold':0.3},
-                 deepsort_cfg: dict = {'reid_ckpt': './deep_sort/deep/checkpoint/ckpt.t7', 'max_dist': 0.2, 'min_confidence': 0.3,
-                                    'nms_max_overlap': 0.5, 'max_iou_distance': 0.7, 'max_age': 70, 'n_init': 3, 'nn_budget': 100}, 
-                 gpu:bool=True):
+class Tracker(object):
+    def __init__(self, cfg: dict = None, device:str='auto', half:bool=False):
         '''
-        
+        Parameters:
+            cfg: dict - Configuration for tracking method
+            device: str - Device to run the tracking method, default is 'auto', 'cuda','cpu', 'mps'
+            half: bool - If True, use half precision for tracking, default is False
         '''
-        self.method = method
-        self.sort_cfg = sort_cfg
-        self.dsort_cfg = deepsort_cfg
-        self.gpu = gpu 
+        if cfg is None:
+            self.cfg = Config.get_cfg_dsort()
+        else:
+            self.cfg = cfg
+        self.device = device
+        self.half = half
         
-    
     def track(self, det_file:str, out_file:str, video_file:str=None, video_index:int=None, total_videos:int=None):
-        if self.method == 'sort':
-            track_sort(det_file, out_file, self.sort_cfg['max_age'], self.sort_cfg['min_inits'], 
-                       self.sort_cfg['iou_threshold'], video_index, total_videos)
-        elif self.method == 'dsort':
+        '''
+        Parameters:
+        - det_file:     Detection file path
+        - out_file:     Output track file path
+        - video_file:   Video file path
+        - video_index:  Index of video in the batch
+        - total_videos: Total number of videos in the batch
+        '''
+
+        if self.cfg['method'] == 'sort':
+            track_sort(det_file, out_file, self.cfg['max_age'], self.cfg['min_inits'], 
+                       self.cfg['iou_threshold'], video_index, total_videos)
+        elif self.cfg['method'] == 'dsort':
             if video_file:
-                track_dsort(video_file=video_file, det_file=det_file, out_file=out_file, gpu=self.gpu, reid_ckpt = self.dsort_cfg['reid_ckpt'],
-                            max_dist=self.dsort_cfg['max_dist'], min_confidence=self.dsort_cfg['min_confidence'], 
-                            nms_max_overlap=self.dsort_cfg['nms_max_overlap'], max_iou_distance=self.dsort_cfg['max_iou_distance'],
-                            max_age=self.dsort_cfg['max_age'], n_init=self.dsort_cfg['max_age'], nn_budget=self.dsort_cfg['nn_budget'],
+                track_dsort(video_file=video_file, det_file=det_file, out_file=out_file, device=self.device, half=self.half, cfg=self.cfg,
                             video_index=video_index, total_videos=total_videos)
             else:
-                print('Invalid video file for deep sort tracking!')
+                print('No video file exists!')
+        elif self.cfg['method'] == 'botsort':
+            track_botsort(video_file=video_file, det_file=det_file, out_file=out_file, cfg=self.cfg,
+                          video_index=video_index, total_videos=total_videos)
         else:
             print('Invalid tracking method!')
     
@@ -56,7 +72,7 @@ class Tracker:
                     continue 
             
             video_file = None
-            if self.method=="dsort":
+            if self.cfg['method']=="dsort":
                 video_file = video_files[count-1]
 
             self.track(det_file=det_file, out_file=track_file, video_file=video_file, video_index=count, total_videos=total_videos)
@@ -64,17 +80,178 @@ class Tracker:
             results.append(track_file)
 
         return results
+        
+    @staticmethod
+    def export_track_header():
+        return ['frame', 'track', 'x', 'y', 'w', 'h', 'score', 'cls', 'infill', 'cluster']
     
     @staticmethod
-    def export_default_cfg(method:str = 'dsort'):
+    def infill_frames(tracks:pd.DataFrame, ids:list[int] = None, method:str='cubic', inplace:bool=True, info:str='', 
+                      video_index:int=None, video_tot:int=None, verbose:bool=True) -> pd.DataFrame:
         '''
-        Export default tracking model configuration
+        Paramters:
+        - tracks: the track dataframe need to be fill
+        - ids: track ids need to be fill, if None, all ids will be processed
+        - method: interpolation method, 'cubic' (default), 'linear', 'nearest'
+        - inplace: if combine filled and raw frames in the output, default is True.
+        Return:
+        - A dataframe contains infilled frames (inplace=False), or infilled+raw (inplace=True)
         '''
-        if method == 'sort':
-            return {'max_age':1, 'min_inits':3, 'iou_threshold':0.3}
-        elif method == 'dsort':
-            return {'reid_ckpt': './deep_sort/deep/checkpoint/ckpt.t7', 'max_dist': 0.2, 'min_confidence': 0.3,
-                                    'nms_max_overlap': 0.5, 'max_iou_distance': 0.7, 'max_age': 70, 'n_init': 3, 'nn_budget': 100}
+        results = []
+
+        tracks.columns = Tracker.export_track_header()
+        if ids is None:
+            ids = tracks['track'].unique()
+        
+        pbar = tqdm(total=len(ids), unit=' tracks')
+        if video_index and video_tot: 
+            pbar.set_description_str("Infliing frames for {} tracks, {} of {}".format(info, video_index, video_tot))
         else:
-            return None
+            pbar.set_description_str("Inflling frames for {} tracks".format(info))
+        for id in ids:
+            frames = tracks[tracks['track']==id].copy().sort_values(by='frame')
+            f_min = frames['frame'].min()
+            f_max = frames['frame'].max()
+
+            if (f_max-f_min+1) > len(frames):
+                raw_fids = frames['frame'].values.tolist()
+                missed_fids = Tracker.__find_missing_number(raw_fids)
+
+                raw_bboxes = frames[['x', 'y', 'w', 'h']].to_numpy()
+                infilled_bboxes = interpolate_bboxes(boxes = raw_bboxes, frames = np.array(raw_fids), target_frames=np.array(missed_fids), 
+                                                     method=method)
+
+                d = {'frame':missed_fids, 'track':id, 'x': infilled_bboxes[:,0], 'y':infilled_bboxes[:,1], 
+                                          'w':infilled_bboxes[:,2], 'h':infilled_bboxes[:,3], 'score':frames['score'].iloc[0], 
+                                          'cls':frames['cls'].iloc[0], 'infill':1, 'cluster':frames['cluster'].iloc[0]}
+                df = pd.DataFrame(d)
+                df = pd.concat([frames, df], ignore_index=True).sort_values(by='frame')
+                results.append(df)
+
+            if verbose:
+                pbar.update()         
+
+        pbar.close()
+
+        if len(results)>0:
+            df = pd.concat(results, ignore_index=True)
+            if inplace:
+                df = pd.concat([tracks, df], ignore_index=True).sort_values(by=['frame', 'track'])
+            return df
+        else:
+            if inplace:
+                return tracks
+            else:
+                return None
+    
+    @staticmethod
+    def cluster_frames(tracks:pd.DataFrame, ids:list[int] = None, gap_thres:int=100, keep_thres:int=25, inplace:bool=True, 
+                      video_index:int=None, video_tot:int=None, verbose:bool=True) -> pd.DataFrame:
+        '''
+        Paramters:
+        - tracks: a dataframe of tracks need to be clustered by empty frames
+        - ids: track ids need to be clustered, if None, all track ids
+        - gap_thres: if empty frames > gap_thres, the track will be cut-off, default is 100
+        - keep_thres: if the frames of a clustered track is >= keep_thres, the track will be kept, default is 25 
+        - inplace: if combine filled and raw frames in the output, default is True.
+        Return:
+        - A dataframe contains infilled frames (inplace=False), or infilled+raw (inplace=True)
+        '''
+        results = []
+        del_ids = []
+
+        tracks.columns = Tracker.export_track_header()
+        if ids is None:
+            ids = tracks['track'].unique()
+        tracks_grouped = tracks.groupby('track')
+
+        id_index = max(ids)
+
+        pbar = tqdm(total=len(ids), unit=' track')
+        if video_index and video_tot: 
+            pbar.set_description_str("Clustering frames {} of {}".format(video_index, video_tot))
+        else:
+            pbar.set_description_str("Clustering frames")
+        for id in ids:
+            #frames = tracks[tracks['track']==id].copy().sort_values(by='frame')
+            frames = tracks_grouped.get_group(id)
+            fids = frames['frame'].values
+            clusters = cluster_by_gap(fids, gap_thres)
+
+            if len(clusters) > 1:
+                for cluster in clusters:
+                    frame_length = max(cluster) - min(cluster) + 1
+                    if frame_length >= keep_thres:
+                        #d = tracks[(tracks['track']==id) & (tracks['frame'].isin(cluster))].copy()
+                        d = frames[frames['frame'].isin(cluster)].copy()
+                        id_index += 1
+                        d['track'] = id_index
+                        d['cluster'] = id
+                        results.append(d)
+                del_ids.append(id)
+
+            if verbose:
+                pbar.update()
+    
+        pbar.close()
+        
+        df = pd.concat(results, ignore_index=True)
+        if inplace:
+            tracks_del = tracks[~tracks['track'].isin(del_ids)].copy()
+            df = pd.concat([tracks_del, df], ignore_index=True).sort_values(by=['frame', 'track'])
+
+        return df
+    
+    @staticmethod
+    def del_short_tracks(tracks:pd.DataFrame, keep_thres:int=25,
+                      video_index:int=None, video_tot:int=None, verbose:bool=True) -> pd.DataFrame:
+        '''
+        Paramters:
+        - tracks: a dataframe of tracks need to be clustered by empty frames
+        - ids: track ids need to be clustered, if None, all track ids
+        - gap_thres: if empty frames > gap_thres, the track will be cut-off, default is 100
+        - keep_thres: if the frames of a clustered track is >= keep_thres, the track will be kept, default is 25 
+        - inplace: if combine filled and raw frames in the output, default is True.
+
+        Return:
+        - A dataframe contains infilled frames (inplace=False), or infilled+raw (inplace=True)
+        '''
+        del_ids = []
+
+        tracks.columns = Tracker.export_track_header()
+        ids = tracks['track'].unique()
+        tracks_grouped = tracks.groupby('track')
+
+        pbar = tqdm(total=len(ids), unit=' track')
+        if video_index and video_tot: 
+            pbar.set_description_str("Scan short tracks {} of {}".format(video_index, video_tot))
+        else:
+            pbar.set_description_str("Scan short tracks")
+        for id in ids:
+            frames = tracks_grouped.get_group(id)
+            #frames = tracks[tracks['track']==id].copy().sort_values(by='frame')
+            frame_max = max(frames['frame'].values)
+            frame_min = min(frames['frame'].values)
+            frame_length = frame_max - frame_min + 1
+            if frame_length < keep_thres:
+                del_ids.append(id)
+
+            if verbose:
+                pbar.update()
+        pbar.close()
+        
+        tracks_del = tracks[~tracks['track'].isin(del_ids)].copy()
+        return tracks_del
+    
+    @staticmethod
+    def __find_missing_number(arr: list[int]) -> list[int]:
+        full_set = set(range(min(arr), max(arr) + 1))
+        arr_set = set(arr)
+        missing_numbers = list(full_set - arr_set)
+        return missing_numbers
+   
+        
+
+        
+
     

{dnt-0.2.4.dist-info → dnt-0.3.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dnt
-Version: 0.2.4
+Version: 0.3.1.3
 Summary: A Python tool for video-based traffic analytiscs
 Home-page: https://its.cutr.usf.edu/dnt/
 Author: Zhenyu Wang
@@ -13,23 +13,43 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
 License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: pandas
-Requires-Dist: matplotlib
 Requires-Dist: torch
 Requires-Dist: torchvision
 Requires-Dist: torchaudio
-Requires-Dist: ultralytics
+Requires-Dist: ultralytics >=8.2
+Requires-Dist: cython
+Requires-Dist: cython-bbox
 Requires-Dist: easydict
+Requires-Dist: faiss-cpu
+Requires-Dist: faiss-gpu
 Requires-Dist: filterpy
+Requires-Dist: gdown
+Requires-Dist: geopandas
+Requires-Dist: h5py
+Requires-Dist: lap
+Requires-Dist: loguru
+Requires-Dist: matplotlib
+Requires-Dist: motmetrics
+Requires-Dist: ninja
+Requires-Dist: numpy
 Requires-Dist: numpy-indexed
-Requires-Dist: opencv-python
 Requires-Dist: opencv-contrib-python
-Requires-Dist: geopandas
-Requires-Dist: shapely
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
+Requires-Dist: opencv-python
+Requires-Dist: pandas
+Requires-Dist: Pillow
+Requires-Dist: prettytable
+Requires-Dist: pycocotools
+Requires-Dist: pyyaml
 Requires-Dist: scikit-image
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: shapely
+Requires-Dist: sympy
+Requires-Dist: tabulate
+Requires-Dist: tensorboard
+Requires-Dist: termcolor
+Requires-Dist: thop
 Requires-Dist: tqdm
 Requires-Dist: vidgear
+Requires-Dist: yacs