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

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

@@ -8,7 +8,6 @@ from . import kalman_filter
 
 INFTY_COST = 1e+5
 
-
 def min_cost_matching(
         distance_metric, max_distance, tracks, detections, track_indices=None,
         detection_indices=None):
@@ -76,7 +75,6 @@ def min_cost_matching(
             matches.append((track_idx, detection_idx))
     return matches, unmatched_tracks, unmatched_detections
 
-
 def matching_cascade(
         distance_metric, max_distance, cascade_depth, tracks, detections,
         track_indices=None, detection_indices=None):
@@ -142,7 +140,6 @@ def matching_cascade(
     unmatched_tracks = list(set(track_indices) - set(k for k, _ in matches))
     return matches, unmatched_tracks, unmatched_detections
 
-
 def gate_cost_matrix(
         kf, cost_matrix, tracks, detections, track_indices, detection_indices,
         gated_cost=INFTY_COST, only_position=False):

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/deep_sort/sort/track.py

@@ -64,7 +64,7 @@ class Track:
     """
 
     def __init__(self, mean, covariance, track_id, n_init, max_age,
-                 feature=None):
+                 feature=None, cls=None):
         self.mean = mean
         self.covariance = covariance
         self.track_id = track_id
@@ -73,6 +73,7 @@ class Track:
         self.time_since_update = 0
 
         self.state = TrackState.Tentative
+        self.cls = cls
         self.features = []
         if feature is not None:
             self.features.append(feature)

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

@@ -134,5 +134,5 @@ class Tracker:
         mean, covariance = self.kf.initiate(detection.to_xyah())
         self.tracks.append(Track(
             mean, covariance, self._next_id, self.n_init, self.max_age,
-            detection.feature))
+            detection.feature, detection.cls))
         self._next_id += 1

dnt/track/dsort/dsort.py

@@ -1,37 +1,41 @@
-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)
-
-    #cfg = get_config()
-    #cfg.merge_from_file(deepsort_cfg)
-
-    device = torch.device('cuda') if (torch.cuda.is_available() and gpu) else torch.device('cpu')
+from config import Config
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+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):
+    '''
+    Track objects in a video using Deep SORT.
+    Args:
+        video_file (str): Path to the input video file.
+        det_file (str): Path to the detection results file.
+        out_file (str): Path to save the tracking results.
+        device (str): Device to run the model on ('cpu' or 'cuda').
+        half (bool): Whether to use half precision.
+        cfg (dict): Configuration dictionary for Deep SORT.
+        video_index (int): Index of the current video in a batch.
+        total_videos (int): Total number of videos in a batch.
+    '''
+    #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,17 +60,24 @@ 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])
-
-            outputs = deepsort.update(bbox_xywh, conf_score, im)
+            classes = np.array(frame_dets[:,7])
+            outputs = deepsort.update(bbox_xywh, conf_score, classes, im)
 
             if len(outputs) > 0:
                 for output in outputs:
-                    results.append([pos_frame, output[4], output[0], output[1], output[2]-output[0], output[3]-output[1], -1, -1, -1, -1])
+                    results.append([pos_frame,
+                                    output[4],
+                                    output[0],
+                                    output[1],
+                                    output[2]-output[0],
+                                    output[3]-output[1],
+                                    output[5],
+                                    -1, -1, -1])
 
         pbar.update()
 
@@ -77,10 +88,9 @@ def track(video_file:str, det_file:str, out_file:str = None, gpu:bool = True,
         df.to_csv(out_file, index=False, header=None)
 
 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/sample/traffic.mp4"
+    iou_file = "/mnt/d/videos/sample/dets/traffic_det.txt"
+    out_file = "/mnt/d/videos/sample/tracks/traffic_track.txt"
 
     track(video_file, iou_file, out_file)
     

dnt/track/re_class.py

@@ -0,0 +1,117 @@
+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',
+                 weights:str='x',
+                 device:str='auto',
+                 default_class:int=0,
+                 match_class:list=[1, 36]) -> None:
+        """
+        Re-classify tracks based on detection results
+        Parameters:
+            num_frames: Number of frames to consider for re-classification, default 25
+            threshold: Threshold for matching, default 0.75
+            model: Detection model to use, default 'rtdetr'
+            weights: Weights for the detection model, default 'x'
+            device: Device to use for detection, default 'auto'
+            default_class: Default class to assign if no match found, default 0 (pedestrian)
+            match_class: List of classes to match, default [1, 36] (bicycle, skateboard/scooter)
+        """
+        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 = []
+        if verbose:
+            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()
+        if verbose:
+            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

@@ -202,7 +202,7 @@ class Sort(object):
   def update(self, dets=np.empty((0, 5))):
     """
     Params:
-      dets - a numpy array of detections in the format [[x1,y1,x2,y2,score],[x1,y1,x2,y2,score],...]
+      dets - a numpy array of detections in the format [[x1,y1,x2,y2,score]
     Requires: this method must be called once for each frame even with empty detections (use np.empty((0, 5)) for frames without detections).
     Returns the a similar array, where the last column is the object ID.
 
@@ -246,9 +246,9 @@ class Sort(object):
 
 def track(det_file, out_file, max_age=1, min_inits=3, iou_threshold=0.3, video_index = None, total_videos = None):
   
-  tracker = Sort(max_age=max_age, 
-                       min_hits=min_inits,
-                       iou_threshold=iou_threshold)
+  tracker = Sort(max_age=max_age,
+                 min_hits=min_inits,
+                 iou_threshold=iou_threshold)
   dets = np.loadtxt(det_file, delimiter=',')
   start_frame = int(dets[:,0].min())
   end_frame = int(dets[:,0].max())
@@ -265,7 +265,6 @@ def track(det_file, out_file, max_age=1, min_inits=3, iou_threshold=0.3, video_i
     if len(dets_frame)>0:
       dets_revised[:,[0,1]] = dets_frame[:,[2,3]]
       dets_revised[:,2] = dets_frame[:,2] + dets_frame[:,4]
-
       dets_revised[:,3] = dets_frame[:,3] + dets_frame[:,5]
       dets_revised[:,4] = dets_frame[:,6] / 100
 
@@ -283,8 +282,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,54 @@
-import os, sys
-sys.path.append(os.path.dirname(__file__))
-
+import pandas as pd
+import os
+import sys
 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
 
-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):
+from tqdm import tqdm
+import numpy as np
+from ..engine import interpolate_bbox, interpolate_bboxes, cluster_by_gap
+
+sys.path.append(os.path.dirname(__file__))
+
+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 +73,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 +81,181 @@ 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:
+            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()
+        
+        if results == []:
             return None
+        
+        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
+   
+        
+
+        
+