deeleting video

.gitignore

@@ -1,6 +1,6 @@
 # Added
 tmp/
-
+*.mp4
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

app.py

@@ -33,15 +33,107 @@ import pathlib
 import multiprocessing as mp
 from time import time
 
-
-REPO_ID='SharkSpace/videos_examples'
-snapshot_download(repo_id=REPO_ID, token=os.environ.get('SHARK_MODEL'),repo_type='dataset',local_dir='videos_example')
+if not os.path.exists('videos_example'):
+    REPO_ID='SharkSpace/videos_examples'
+    snapshot_download(repo_id=REPO_ID, token=os.environ.get('SHARK_MODEL'),repo_type='dataset',local_dir='videos_example')
 
 theme = gr.themes.Soft(
     primary_hue="sky",
     neutral_hue="slate",
 )
 
+
+
+def add_border(frame, color = (255, 0, 0), thickness = 2):
+    # Add a red border to the image
+    relative = max(frame.shape[0],frame.shape[1])
+    top = int(relative*0.025)
+    bottom = int(relative*0.025)
+    left = int(relative*0.025)
+    right =  int(relative*0.025)
+    # Add the border to the image
+    bordered_image = cv2.copyMakeBorder(frame, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)
+    
+    return bordered_image 
+    
+def overlay_text_on_image(image, text_list, font=cv2.FONT_HERSHEY_SIMPLEX, font_size=0.5, font_thickness=1, margin=10, color=(255, 255, 255)):
+    relative = min(image.shape[0],image.shape[1])
+    y0, dy = margin, int(relative*0.1) # start y position and line gap
+    for i, line in enumerate(text_list):
+        y = y0 + i * dy
+        text_width, _ = cv2.getTextSize(line, font, font_size, font_thickness)[0]
+        cv2.putText(image, line, (image.shape[1] - text_width - margin, y), font, font_size, color, font_thickness, lineType=cv2.LINE_AA)
+    return image
+
+def overlay_logo(frame,logo, position=(10, 10)):
+    """
+    Overlay a transparent logo (with alpha channel) on a frame.
+
+    Parameters:
+    - frame: The main image/frame to overlay the logo on.
+    - logo_path: Path to the logo image.
+    - position: (x, y) tuple indicating where the logo starts (top left corner).
+    """
+    # Load the logo and its alpha channel
+    alpha_channel = np.ones(logo.shape[:2], dtype=logo.dtype)
+    print(logo.min(),logo.max())
+    logo = np.dstack((logo, alpha_channel))
+    
+    indexes = logo[:,:,1]>150
+    logo[indexes,3] = 0
+    l_channels = cv2.split(logo)
+    if len(l_channels) != 4:
+        raise ValueError("Logo doesn't have an alpha channel!")
+    l_b, l_g, l_r, l_alpha = l_channels
+    cv2.imwrite('l_alpha.png',l_alpha*255)
+    # Extract regions of interest (ROI) from both images
+    roi = frame[position[1]:position[1]+logo.shape[0], position[0]:position[0]+logo.shape[1]]
+
+    # Blend the logo using the alpha channel
+    for channel in range(0, 3):
+        roi[:, :, channel] = (l_alpha ) * l_channels[channel] + (1.0 - l_alpha ) * roi[:, :, channel]
+
+    return frame
+    
+    
+def add_danger_symbol_from_image(frame, top_pred):  
+    relative = max(frame.shape[0],frame.shape[1])
+    if top_pred['shark_sighted'] and top_pred['dangerous_dist']:
+        # Add the danger symbol
+        danger_symbol = cv2.imread('static/danger_symbol.jpeg')
+        danger_symbol = cv2.resize(danger_symbol, (int(relative*0.1), int(relative*0.1)), interpolation = cv2.INTER_AREA)[:,:,::-1]
+        frame = overlay_logo(frame,danger_symbol, position=(int(relative*0.05), int(relative*0.05)))
+    return frame
+
+def draw_cockpit(frame, top_pred,cnt):
+    # Bullet points:
+    high_danger_color = (255,0,0)
+    low_danger_color = yellowgreen = (154,205,50)
+    shark_sighted = 'Shark Detected: ' + str(top_pred['shark_sighted'])
+    human_sighted = 'Number of Humans: ' + str(top_pred['human_n'])
+    shark_size_estimate = 'Biggest shark size: ' + str(top_pred['biggest_shark_size'])
+    shark_weight_estimate = 'Biggest shark weight: ' + str(top_pred['biggest_shark_weight'])
+    danger_level = 'Danger Level: ' 
+    danger_level += 'High' if top_pred['dangerous_dist'] else 'Low'
+    danger_color = 'orangered' if top_pred['dangerous_dist'] else 'yellowgreen'
+    # Create a list of strings to plot
+    strings = [shark_sighted, human_sighted, shark_size_estimate, shark_weight_estimate, danger_level]
+    relative = max(frame.shape[0],frame.shape[1])
+    if top_pred['shark_sighted'] and top_pred['dangerous_dist'] and cnt%2 == 0:
+        frame  = add_border(frame, color=high_danger_color, thickness=int(relative*0.025))
+        frame = add_danger_symbol_from_image(frame, top_pred)
+    elif top_pred['shark_sighted'] and not top_pred['dangerous_dist'] and cnt%2 == 0:
+         frame  = add_border(frame, color=low_danger_color, thickness=int(relative*0.025))
+         frame = add_danger_symbol_from_image(frame, top_pred)
+    else: 
+        
+        frame  = add_border(frame, color=(0,0,0), thickness=int(relative*0.025))
+        
+    overlay_text_on_image(frame, strings, font=cv2.FONT_HERSHEY_SIMPLEX, font_size=relative*0.0007, font_thickness=1, margin=int(relative*0.05), color=(255, 255, 255))
+    return frame
+    
+    
+
 def process_video(input_video, out_fps = 'auto', skip_frames = 7):
     cap = cv2.VideoCapture(input_video)
 
@@ -62,42 +154,65 @@ def process_video(input_video, out_fps = 'auto', skip_frames = 7):
     cnt = 0
     
     while iterating:
+        print('overall count ', cnt)
+        
         if (cnt % skip_frames) == 0:
+            print('starting Frame: ', cnt)
             # flip frame vertically
             display_frame, result = inference_frame_serial(frame)
-            video.write(cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGB))
+            
             #print(result)
             top_pred = process_results_for_plot(predictions = result.numpy(),
                                                 classes = classes,
                                                 class_sizes = class_sizes_lower)
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            prediction_frame = cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGB)
+            
+            
+            #
+            #video.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
+            
+            if cnt*skip_frames %2==0 and top_pred['shark_sighted']: 
+                prediction_frame = cv2.resize(prediction_frame, (int(width), int(height)))
+                frame =prediction_frame
+                
+            if  top_pred['shark_sighted']: 
+                frame = draw_cockpit(frame, top_pred,cnt*skip_frames)
+            
+            frame = cv2.resize(frame, (int(width), int(height)))
+            video.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
+                
+            
             pred_dashbord = prediction_dashboard(top_pred = top_pred)
             #print('sending frame')
-            print(cnt)
-            yield cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGB), cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), None, pred_dashbord
+            print('finalizing frame:',cnt)
+            print(pred_dashbord.shape)
+            print(frame.shape)
+            print(prediction_frame.shape)
+            yield frame , None
+        
         cnt += 1
         iterating, frame = cap.read()
     
     video.release()
-    yield None, None, output_path, None
+    yield None,  output_path
 
 with gr.Blocks(theme=theme) as demo:
-    with gr.Row():
+    with gr.Row().style(equal_height=True,height='25%'):
         input_video = gr.Video(label="Input")
+        original_frames = gr.Image(label="Processed Frame").style( height=650)
+        #processed_frames = gr.Image(label="Shark Engine")
         output_video = gr.Video(label="Output Video")
-    
-    with gr.Row():
-        original_frames = gr.Image(label="Original Frame")
-        dashboard = gr.Image(label="Dashboard")
-        processed_frames = gr.Image(label="Shark Engine")
-
+        #dashboard = gr.Image(label="Events")
+        
     with gr.Row():
         paths = sorted(pathlib.Path('videos_example/').rglob('*.mp4'))
         samples=[[path.as_posix()] for path in paths if 'raw_videos'  in str(path)]
         examples = gr.Examples(samples, inputs=input_video)
         process_video_btn = gr.Button("Process Video")
 
-    process_video_btn.click(process_video, input_video, [processed_frames, original_frames, output_video, dashboard])
-
+    #process_video_btn.click(process_video, input_video, [processed_frames, original_frames, output_video, dashboard])
+    process_video_btn.click(process_video, input_video, [ original_frames, output_video])
 demo.queue()
 if os.getenv('SYSTEM') == 'spaces':
     demo.launch(width='40%',auth=(os.environ.get('SHARK_USERNAME'), os.environ.get('SHARK_PASSWORD')))

inference.py

@@ -53,11 +53,11 @@ classes = ['Beach',
  'Dolphin',
  'Miscellaneous',
  'Unidentifiable shark',
- 'Carpet shark',
+ 'C Shark',
  'Dusty shark',
  'Blue shark',
  'Great white shark',
- 'Copper shark',
+ 'Shark',
  'Nurse shark',
  'Silky shark',
  'Leopard shark',
@@ -106,11 +106,11 @@ class_sizes = {'Beach': None,
                'Dolphin': {'feet':[6.6, 13.1], 'meter': [2, 4], 'kg': [150, 650], 'pounds': [330, 1430]},
                'Miscellaneous': None,
                'Unidentifiable shark': {'feet': [2, 15], 'meter': [0.6, 4.5], 'kg': [50, 1000], 'pounds': [110, 2200]},
-               'Carpet shark': {'feet': [4, 10], 'meter': [1.25, 3], 'kg': [50, 1000], 'pounds': [110, 2200]}, # Prob incorrect
+               'C Shark': {'feet': [4, 10], 'meter': [1.25, 3], 'kg': [50, 1000], 'pounds': [110, 2200]}, # Prob incorrect
                'Dusty shark': {'feet': [9, 14], 'meter': [3, 4.25], 'kg': [160, 180], 'pounds': [350, 400]},
                'Blue shark': {'feet': [7.9, 12.5], 'meter': [2.4, 3], 'kg': [60, 120], 'pounds': [130, 260]}, 
                'Great white shark': {'feet': [13.1, 20], 'meter': [4, 6], 'kg': [680, 1800], 'pounds': [1500, 4000]},
-               'Copper shark': {'feet': [7.2, 10.8], 'meter': [2.2, 3.3], 'kg': [130, 300], 'pounds': [290, 660]},
+               'Shark': {'feet': [7.2, 10.8], 'meter': [2.2, 3.3], 'kg': [130, 300], 'pounds': [290, 660]},
                'Nurse shark': {'feet': [7.9, 9.8], 'meter': [2.4, 3], 'kg': [90, 115], 'pounds': [200, 250]},
                'Silky shark': {'feet': [6.6, 8.2], 'meter': [2, 2.5], 'kg': [300, 380], 'pounds': [660, 840]},
                'Leopard shark': {'feet': [3.9, 4.9], 'meter': [1.2, 1.5], 'kg': [11, 20], 'pounds': [22, 44]},
@@ -132,10 +132,11 @@ classes_is_shark_id = [i for i, x in enumerate(classes_is_shark) if x == 1]
 classes_is_human_id = [i for i, x in enumerate(classes_is_human) if x == 1]
 classes_is_unknown_id = [i for i, x in enumerate(classes_is_unknown) if x == 1]
 
-REPO_ID = "SharkSpace/maskformer_model"
-FILENAME = "mask2former"
 
-snapshot_download(repo_id=REPO_ID, token= os.environ.get('SHARK_MODEL'),local_dir='model/')
+if not os.path.exists('model'):
+    REPO_ID = "SharkSpace/maskformer_model"
+    FILENAME = "mask2former"
+    snapshot_download(repo_id=REPO_ID, token= os.environ.get('SHARK_MODEL'),local_dir='model/')
 
 # Choose to use a config and initialize the detector
 config_file ='model/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py'

metrics.py

@@ -49,6 +49,7 @@ def add_class_sizes(top_pred = {}, class_sizes = None):
                 tmp_class_sizes = class_sizes[tmp_pred.lower()]
                 if tmp_class_sizes == None:
                     size_list.append(None)
+                    continue 
                 else:
                     size_list.append(tmp_class_sizes['feet'])
 
@@ -74,6 +75,7 @@ def add_class_weights(top_pred = {}, class_weights = None):
                 tmp_class_weights = class_weights[tmp_pred.lower()]
                 if tmp_class_weights == None:
                     weight_list.append(None)
+                    continue
                 else:
                     weight_list.append(tmp_class_weights['pounds'])
 
@@ -117,6 +119,8 @@ def get_min_distance_shark_person(top_pred, class_sizes = None, dangerous_distan
             'dangerous_dist': min_dist < dangerous_distance}
 
 def _calculate_dist_estimate(bbox1, bbox2, labels, class_sizes = None, measurement = 'feet'):
+    if class_sizes[labels[0]] == None or class_sizes[labels[1]] == None:
+        return 9999
     class_feet_size_mean = np.array([class_sizes[labels[0]][measurement][0], 
                                      class_sizes[labels[1]][measurement][0]]).mean()
     box_pixel_size_mean = np.array([np.linalg.norm(bbox1[[0, 1]] - bbox1[[2, 3]]), 

pre-requeriments.txt

@@ -1,5 +1,4 @@
 
-
 numpy==1.22.4
 opencv-python-headless==4.5.5.64
 openmim==0.1.5