dnt 0.2.0__tar.gz → 0.2.1__tar.gz

{dnt-0.2.0/dnt.egg-info → dnt-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dnt
-Version: 0.2.0
+Version: 0.2.1
 Summary: A Python tool for video-based traffic analytiscs
 Home-page: https://its.cutr.usf.edu/dnt/
 Author: Zhenyu Wang

dnt-0.2.1/dnt/analysis/__init__.py

@@ -0,0 +1,6 @@
+import os
+import sys
+
+sys.path.append(os.path.dirname(__file__))
+
+from stop import StopAnalyzer

dnt-0.2.1/dnt/analysis/speed.py

@@ -0,0 +1,15 @@
+import pandas as pd
+
+def frame_reflines(tracks, ref_lines, tolerance):
+    '''
+        tracks - a dataframe contains vehicle tracks without header  
+                frame, veh_id, leftup_x, leftup_y, w, h
+        ref_lineas - a list of ref_lines
+                [(pt1_x, pt1_y, pt2_x, pt2_y), (....), ...]
+        tolerance - allowed error to intersect (reserved) 
+
+        *************************************************************
+        return - a dataframe contains frames passing reference lines
+                veh_id, ref_line_index, frame
+    '''
+

dnt-0.2.1/dnt/analysis/stop.py

@@ -0,0 +1,241 @@
+from shapely.geometry import Point, Polygon, LineString, box
+import geopandas as gpd, pandas as pd
+from tqdm import tqdm
+
+class StopAnalyzer():
+    def __init__(self, h_coords, v_coords, event_dict, stop_iou=0.97, frame_buffer=5, verbose=True):
+        self.hzones = StopAnalyzer.gen_zones(h_coords)
+        self.vzones = StopAnalyzer.gen_zones(v_coords)
+        self.event_dict = event_dict
+        self.stop_iou = stop_iou
+        self.frame_buffer = frame_buffer
+        self.verbose = verbose
+    
+    def analysis(self, track_file, result_file=None, output_file=None, video_index=None, video_tot=None):
+        
+        tracks = pd.read_csv(track_file, header=None, sep=',')
+
+        tracks = self.__stop_scan(tracks, video_index, video_tot)
+        tracks = self.__event_identify(tracks, video_index, video_tot)
+        results = self.__event_count(tracks, video_index, video_tot)
+
+        if result_file:
+            results.to_csv(result_file, index=False)
+
+        if output_file:
+            tracks.to_csv(output_file, header=None, index=False)
+    
+    def __stop_scan(self, tracks, video_index, video_tot):
+        vehicles = tracks[1].unique()
+
+        pbar = tqdm(total=len(vehicles), unit=' tracks')
+        if video_index and video_tot:
+            pbar.set_description_str("Scan stops {} of {}".format(video_index, video_tot))
+        else:
+            pbar.set_description_str("Scan stops ")
+
+        for vehicle in vehicles:
+            track = tracks[tracks[1] == vehicle].sort_values(by=0)
+
+            for i in range(self.frame_buffer, len(track)):
+
+                index = track.iloc[i].name
+
+                bb0 = [track.iloc[i-self.frame_buffer, 2], track.iloc[i-self.frame_buffer, 3], 
+                       track.iloc[i-self.frame_buffer, 4], track.iloc[i-self.frame_buffer, 5]]
+                bb1 = [track.iloc[i, 2], track.iloc[i, 3], track.iloc[i, 4], track.iloc[i, 5]]
+                tracks.at[index, 6] = StopAnalyzer.iou(bb0, bb1)
+
+                center = Point(track.iloc[i,2]+track.iloc[i,4], track.iloc[i,3]+track.iloc[i,5])
+                for j in range(len(self.vzones)):
+                    if center.within(self.vzones[j]):
+                        tracks.loc[tracks[1]==vehicle, 7]=j
+                        break
+                
+                bb = box(track.iat[i, 2], track.iat[i, 3], track.iat[i, 2] + track.iat[i, 4], track.iat[i, 3] + track.iat[i, 5])
+                for j in range(len(self.hzones)):
+                    if bb.intersects(self.hzones[j]):
+                        if j > tracks.at[index, 8]:
+                            tracks.at[index, 8] = j
+            if self.verbose:
+                pbar.update()
+
+        pbar.close()
+
+        return tracks
+    
+    def __event_identify(self, tracks, video_index, video_tot):
+
+        pbar = tqdm(total=len(tracks), unit=' frames')
+        if video_index and video_tot:
+            pbar.set_description_str("Identify events {} of {}".format(video_index, video_tot))
+        else:
+            pbar.set_description_str("Identify events ")
+
+        for i in range(len(tracks)):
+
+            if tracks.iat[i, 6] >= self.stop_iou:
+        
+                vzone = tracks.iat[i, 7]
+                hzone = tracks.iat[i, 8]
+                frame = tracks.iat[i, 0]
+                veh = tracks.iat[i, 1]
+
+                vehs_inlane = tracks.loc[(tracks[0]==frame) & (tracks[1]!=veh) & (tracks[7]==vzone) & (tracks[8]>hzone)]
+
+                if len(vehs_inlane)==0:
+                    
+                    pre_key = -1
+                    for key in self.event_dict:
+
+                        if key >= pre_key:
+                            pre_key = key
+                            if tracks.iat[i, 8] in self.event_dict[key]:
+                                tracks.iat[i, 9] = key
+
+            if self.verbose:
+                pbar.update()
+        
+        pbar.close()
+
+        return tracks
+    
+    def __event_count(self, tracks, video_index, video_tot):
+
+
+        pbar = tqdm(unit='events')
+        results = []
+
+        for key in self.event_dict:
+
+            vehicles = tracks.loc[tracks[9]==key][1].unique()
+
+            if video_index and video_tot:
+                pbar.set_description_str("Count event {} for {} of {}".format(key, video_index, video_tot))
+            else:
+                pbar.set_description_str("Count event {}".format(key))
+
+            pbar.total = len(vehicles)
+            for vehicle in vehicles:
+
+                track = tracks[(tracks[1] == vehicle) & (tracks[9] == key)]
+
+                start_frame = int(track[0].min())
+                end_frame = int(track[0].max())
+                vzone = track[7].mode()[0]
+                results.append([key, vehicle, vzone, start_frame, end_frame])
+                
+                pbar.update()
+
+        results = pd.DataFrame(results, columns=['EVENT', 'TRACKID', 'LANE', 'START_FRAME', 'END_FRAME'])
+        pbar.close()
+
+        return results
+    
+    @staticmethod
+    def export_label(track_file, analysis_file, label_file, vid_field=1, label_field=10, frame_field=0,
+                     event_label=None, vid_disp=True, verbose=True):
+        
+        tracks = pd.read_csv(track_file, header=None)
+        results = pd.read_csv(analysis_file)
+
+        pbar = tqdm(total=len(tracks), desc='Generate labels ', unit=' frames')
+        for index, track in tracks.iterrows():
+
+            vid = int(track[vid_field])
+            
+            selected = results.loc[(results['START_FRAME']<=track[frame_field]) & 
+                                   (results['END_FRAME']>=track[frame_field]) &
+                                   (results['TRACKID']==track[vid_field])]
+            if len(selected)>0:
+                
+                event = selected.iloc[0]['EVENT']
+
+                if event_label:
+                    tracks.at[index, label_field] = str(vid)+"-"+str(event_label[event])
+                else:
+                    tracks.at[index, label_field] = str(vid)+"-"+str(event)
+
+            else:
+                if vid_disp:
+                    tracks.at[index, label_field] = str(vid)
+                else:
+                    tracks.at[index, label_field] = '-1'
+
+            if verbose:
+                pbar.update()
+
+        pbar.close()
+
+        tracks.to_csv(label_file, header=None, index=False)
+
+        if verbose:
+            print('Write to {}'.format(label_file))
+
+
+    @staticmethod
+    def iou(bb1, bb2):
+        """
+        Calculate the Intersection over Union (IoU) of two bounding boxes.
+        Parameters
+        ----------
+        bb1 : [x1, y1, w, h]
+            x1, y1 - top left corner
+            w, h - width and height
+        bb2 : [x1, y1, w, h]
+            x1, y1 - top left corner
+            w, h - width and height
+        Returns
+        -------
+        iou: float [0, 1]
+        """
+
+        assert bb1[0] < bb1[0] + bb1[2]
+        assert bb1[1] < bb1[1] + bb1[3]
+        assert bb2[0] < bb2[0] + bb2[2]
+        assert bb2[1] < bb2[1] + bb2[3]
+
+        # determine the coordinates of the intersection rectangle
+        x_left = max(bb1[0], bb2[0])
+        y_top = max(bb1[1], bb2[1])
+        x_right = min(bb1[0]+bb1[2], bb2[0]+bb2[2])
+        y_bottom = min(bb1[1]+bb1[3], bb2[1]+bb2[3])
+
+        if x_right < x_left or y_bottom < y_top:
+            return 0.0
+
+        # The intersection of two axis-aligned bounding boxes is always an
+        # axis-aligned bounding box
+        intersection_area = (x_right - x_left) * (y_bottom - y_top)
+
+        # compute the area of both AABBs
+        bb1_area = bb1[2] * bb1[3]
+        bb2_area = bb2[2] * bb2[3]
+
+        # compute the intersection over union by taking the intersection
+        # area and dividing it by the sum of prediction + ground-truth
+        # areas - the interesection area
+        iou = intersection_area / float(bb1_area + bb2_area - intersection_area)
+        assert iou >= 0.0
+        assert iou <= 1.0
+        return iou
+    
+    @staticmethod
+    def gen_zones(line_coords):
+        """
+            Generate a list of shapely polygons
+            Inputs:
+                line_coords: a list of line coords ([[(x11, y11),(x12, y12)], [(x21, y21),(x22, y22)], ...])
+            Returns:
+                A list of PloyGons  
+        """
+
+        zones = []
+        for i in range(1, len(line_coords)):
+            shell = line_coords[i-1] + [line_coords[i][1], line_coords[i][0]]
+            zones.append(Polygon(shell))        
+
+        return zones
+
+if __name__ == "__main__":
+    pass

{dnt-0.2.0 → dnt-0.2.1}/dnt/label/labeler.py

@@ -8,7 +8,7 @@ import os
 class Labeler:
     def __init__(self, method='opencv', frame_field=0,
              label_fields=[1], color_field=1, zoom_factor=1, line_thickness=1,
-             color_bgr = (0, 255, 0), compress_message=False):
+             color_bgr = (0, 255, 0), compress_message=False, nodraw_empty=True):
         
         self.method = method
         self.frame_field = frame_field
@@ -18,8 +18,10 @@ class Labeler:
         self.line_thickness=line_thickness
         self.color_bgr = color_bgr
         self.compress_message=compress_message
+        self.nodraw_empty = nodraw_empty
     
-    def draw(self, label_file, input_video, output_video, start_frame=None, end_frame=None, video_index=None, video_tot=None):
+    def draw(self, label_file, input_video, output_video, start_frame=None, end_frame=None, 
+             video_index=None, video_tot=None):
         tracks = pd.read_csv(label_file, header=None)
         
         cmap = plt.get_cmap('tab20b')
@@ -62,23 +64,31 @@ class Labeler:
             #boxes = tracks.loc[tracks.columns[0]==pos_frame].values.tolist()
             
             for box in boxes:
-                x1 = box[2]
-                y1 = box[3]
-                x2 = x1 + box[4]
-                y2 = y1 + box[5]
+                x1 = int(box[2])
+                y1 = int(box[3])
+                x2 = x1 + int(box[4])
+                y2 = y1 + int(box[5])
 
                 color = colors[int(box[self.color_field]) % len(colors)]
                 color = [i * 255 for i in color]
-
+                
                 label_txt = ''
                 for field in self.label_fields:
-                    label_txt += str(box[field]) + ' '
+                    if (str(box[field]).strip() == '-1'):
+                        if self.nodraw_empty:
+                            label_txt += ''
+                        else:
+                            label_txt += str(box[field]) + ' '
+                    else:
+                        label_txt += str(box[field]) + ' '
+                        
                 label_txt = label_txt.strip()
 
-                cv2.rectangle(frame, (x1, y1), (x2, y2), color, self.line_thickness)
-                cv2.rectangle(frame, (x1, int(y1-30*self.zoom_factor)), (x1+len(label_txt)*int(17*self.zoom_factor), y1), 
+                if label_txt:
+                    cv2.rectangle(frame, (x1, y1), (x2, y2), color, self.line_thickness)
+                    cv2.rectangle(frame, (x1, int(y1-30*self.zoom_factor)), (x1+len(label_txt)*int(17*self.zoom_factor), y1), 
                               color, -1)
-                cv2.putText(frame,str(label_txt),(int(x1), int(y1-int(10*self.zoom_factor))), 
+                    cv2.putText(frame,str(label_txt),(int(x1), int(y1-int(10*self.zoom_factor))), 
                             0, 0.75*self.zoom_factor, (255,255,255), 1)
 
             writer.write(frame)
@@ -127,7 +137,7 @@ class Labeler:
                 break
 
             for line in lines:
-                cv2.line(frame, (line[0], line[1]), (line[2], line[3]), self.color_bgr, self.line_thickness)
+                cv2.line(frame, (int(line[0]), int(line[1])), (int(line[2]), int(line[3])), self.color_bgr, self.line_thickness)
 
             writer.write(frame)
             key = cv2.waitKey(1) & 0xFF
@@ -243,6 +253,72 @@ class Labeler:
 
         return results
     
+    def draw_shapes(self, input_video, output_video, points=None, lines=None, polygons=None, 
+                    point_color=None, line_color=None, polygon_color=None, 
+                    start_frame=None, end_frame=None, video_index=None, video_tot=None):
+        cap = cv2.VideoCapture(input_video)
+        if not cap.isOpened():
+            raise IOError("Couldn't open webcam or video")
+
+        if start_frame is None:
+            start_frame = 0
+        if end_frame is None:
+            end_frame = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))-1
+
+        tot_frames = end_frame - start_frame + 1       
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        writer = cv2.VideoWriter(output_video, fourcc, fps, (width, height))
+
+        pbar = tqdm(total=tot_frames, unit=" frames")
+        if self.compress_message:
+            pbar.set_description_str("Labeling")
+        else:
+            if video_index and video_tot:
+                pbar.set_description_str("Labeling {} of {}".format(video_index, video_tot))
+            else:     
+                pbar.set_description_str("Labeling {} ".format(input_video))
+
+        cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+        while cap.isOpened():
+            pos_frame = int(cap.get(cv2.CAP_PROP_POS_FRAMES))
+            ret, frame = cap.read()
+            if (not ret) or (pos_frame>end_frame):
+                break
+            
+            if points is not None:
+                if point_color is None:
+                    point_color = self.color_bgr
+                for point in points:
+                    cv2.circle(frame, (point[0], point[1]), radius=self.line_thickness, color=point_color, thickness=-1)
+
+            if lines is not None:
+                if line_color is None:
+                    line_color = self.color_bgr
+                for line in lines:
+                    cv2.line(frame, (line[0], line[1]), (line[2], line[3]), line_color, self.line_thickness)
+            
+            if polygons is not None:
+                if polygon_color is None:
+                    polygon_color = self.color_bgr
+                for polygon in polygons:
+                    pts = np.array(polygon, np.int32)
+                    pts = pts.reshape((-1, 1, 2))
+                    cv2.polylines(frame, [pts], isClosed=True, color=polygon_color, thickness=self.line_thickness)
+
+            writer.write(frame)
+            key = cv2.waitKey(1) & 0xFF
+            if key == ord("q"):
+                break
+            
+            pbar.update()
+
+        cv2.destroyAllWindows()
+        cap.release()
+        writer.release()
+    
     @staticmethod
     def export_frames(input_video, frames, output_path):
     
@@ -281,11 +357,12 @@ class Labeler:
         return frame
     
 if __name__=='__main__':
-    video_file = "/mnt/f/videos/hfst/Standard_SCU7WH_2022-09-16_0630.02.001.mp4"    
-    iou_file = "/mnt/f/videos/hfst/Standard_SCU7WH_2022-09-16_0630.02.001_iou.txt"
-    track_file = "/mnt/f/videos/hfst/Standard_SCU7WH_2022-09-16_0630.02.001_track.txt"
-    label_file = "/mnt/f/videos/hfst/Standard_SCU7WH_2022-09-16_0630.02.001_track.mp4"
-
-    labeler = Labeler(video_file)
-    labeler.draw(track_file, label_file, zoom_factor=0.5)
+    video_file = "/mnt/d/videos/hfst/Standard_SCU7WH_2022-09-16_0630.02.001.mp4"    
+    iou_file = "/mnt/d/videos/hfst/Standard_SCU7WH_2022-09-16_0630.02.001_iou.txt"
+    track_file = "/mnt/d/videos/hfst/tracks/Standard_SCU7WH_2022-09-16_0630.02.001_track.txt"
+    label_video = "/mnt/d/videos/hfst/labels/Standard_SCU7WH_2022-09-16_0630.02.001_track.mp4"
+    label_file = "/mnt/d/videos/hfst/tracks/Standard_SCU7WH_2022-09-16_0630.02.001_label.txt"
+
+    labeler = Labeler(video_file, zoom_factor=0.5, nodraw_empty=True, label_fields=[6])
+    labeler.draw(label_file, video_file, label_video)
 

{dnt-0.2.0 → dnt-0.2.1/dnt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dnt
-Version: 0.2.0
+Version: 0.2.1
 Summary: A Python tool for video-based traffic analytiscs
 Home-page: https://its.cutr.usf.edu/dnt/
 Author: Zhenyu Wang

{dnt-0.2.0 → dnt-0.2.1}/dnt.egg-info/SOURCES.txt

@@ -8,6 +8,9 @@ dnt.egg-info/SOURCES.txt
 dnt.egg-info/dependency_links.txt
 dnt.egg-info/requires.txt
 dnt.egg-info/top_level.txt
+dnt/analysis/__init__.py
+dnt/analysis/speed.py
+dnt/analysis/stop.py
 dnt/detect/__init__.py
 dnt/detect/yolov8/__init__.py
 dnt/detect/yolov8/detector.py

{dnt-0.2.0 → dnt-0.2.1}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '0.2.0'
+VERSION = '0.2.1'
 DESCRIPTION = 'A Python tool for video-based traffic analytiscs'
 LONG_DESCRIPTION = ''