Bug fixes

.gitignore

@@ -13,4 +13,5 @@ models/*
 *.jpg
 *.aris
 *.log
+*.pdf
 *.DS_STORE

InferenceConfig.py

@@ -20,7 +20,7 @@ NMS_IOU  = 0.25 # NMS IOU
 MAX_AGE = 20 # time until missing fish get's new id
 MIN_HITS = 11 # minimum number of frames with a specific fish for it to count
 MIN_LENGTH = 0.3 # minimum fish length, in meters
-MAX_LENGTH = 1.5 # maximum fish length, in meters
+MAX_LENGTH = 0 # maximum fish length, in meters
 IOU_THRES = 0.01 # IOU threshold for tracking
 MIN_TRAVEL = 0 # Minimum distance a track has to travel
 DEFAULT_TRACKER = TrackerType.BYTETRACK

app.py

@@ -17,6 +17,8 @@ from InferenceConfig import InferenceConfig
 
 WEBAPP_VERSION = "1.0"
 
+enable_annotation_editor = False
+
 #Initialize State & Result
 state = {
     'files': [],
@@ -31,7 +33,15 @@ result = {}
 
 
 # Called when an Aris file is uploaded for inference
-def on_aris_input(file_list, model_id, conf_thresh, iou_thresh, min_hits, max_age, associative_tracker, boost_power, boost_decay, byte_low_conf, byte_high_conf, min_length, max_length, min_travel, output_formats):
+def on_aris_input(
+        file_list, 
+        model_id, 
+        conf_thresh, iou_thresh, 
+        min_hits, max_age, 
+        associative_tracker, boost_power, boost_decay, byte_low_conf, byte_high_conf, 
+        min_length, max_length, min_travel, 
+        output_formats
+    ):
 
     print(output_formats)
 
@@ -61,20 +71,25 @@ def on_aris_input(file_list, model_id, conf_thresh, iou_thresh, min_hits, max_ag
         state['config'].enable_sort_track()
 
     print(" ")
-    print("Running with:")
+    print("Inference with:")
     print(state['config'].to_dict())
     print(" ")
 
     # Update loading_space to start inference on first file
     return {
         inference_handler: gr.update(value = str(np.random.rand()), visible=True),
-        components['cancelBtn']: gr.update(visible=True),
-        components['skipBtn']: gr.update(visible=True),
+        components['cancel_btn']: gr.update(visible=True),
         master_tabs: gr.update(selected=1)
     }
 
 # Called when a result zip file is uploaded for result review
-def on_result_upload(zip_list, aris_list):
+def on_result_upload():
+    return {
+        master_tabs: gr.update(selected=1),
+        result_uploader: gr.update(value=str(np.random.rand()))
+    }
+
+def on_result_upload_finish(zip_list, aris_list):
 
     if (zip_list == None): 
         zip_list = [("static/example/example_result.zip", None)]
@@ -87,7 +102,6 @@ def on_result_upload(zip_list, aris_list):
     state['outputs'] = ["Annotated Video", "Manual Marking", "PDF"]
 
     component_updates = { 
-        master_tabs: gr.update(selected=1),
         tab_labeler: gr.update(value = len(zip_list))
     }
 
@@ -214,8 +228,7 @@ def cancel_inference():
     return {
         master_tabs: gr.update(selected=0),
         inference_handler: gr.update(visible=False),
-        components['cancelBtn']: gr.update(visible=False),
-        components['skipBtn']: gr.update(visible=False)
+        components['cancel_btn']: gr.update(visible=False)
     }
 
 
@@ -257,11 +270,11 @@ def load_annotation(_, progress=gr.Progress()):
         annotation_info, state['frame_index'] = init_frames(annotation_dataset, result['json_result'][result_index], state['frame_index'], gp=set_progress)
     
         # save as html element
-        annotation_storage = "<p id='annotation_info' style='display:none'>" + json.dumps(annotation_info) + "</p>"
+        annotation_content = "<p id='annotation_info' style='display:none'>" + json.dumps(annotation_info) + "</p>"
 
         return {
             annotation_editor: gr.update(), 
-            annotation_progress: gr.update(value=annotation_storage)
+            annotation_progress: gr.update(value=annotation_content)
         }
 
     # If complete, start annotation editor    
@@ -296,7 +309,7 @@ demo = gr.Blocks()
 with demo:
     with gr.Blocks() as inner_body:
 
-        # Title of page
+        # Title of page + style
         gr.HTML(
             """
             <h1 align="center" style="font-size:xxx-large">Caltech Fisheye</h1>
@@ -349,6 +362,9 @@ with demo:
 
 
                 # Define annotation progress bar for event listeres, but unrender since it will be displayed later on
+                result_uploader = gr.HTML("", visible=False)
+                components['result_uploader'] = result_uploader
+
                 annotation_progress = gr.HTML("", visible=False).unrender()
                 components['annotation_progress'] = annotation_progress
                 
@@ -356,35 +372,35 @@ with demo:
                 vis_components = Result_Gradio(prepare_annotation, components)
                 
             # Master Tab for annotation editing
-            with gr.Tab("Annotation Editor", id=2):
-
-                # Draw the annotation loading bar here
-                annotation_progress.render()
-
-                # Add annotation editor component
-                annotation_editor = gr.HTML("", visible=False)
-
-                annotation_storage = gr.HTML("", visible=False)
-
-                # Event listener for opening annotation 
-                annotation_progress.change(load_annotation, annotation_progress, [annotation_editor, annotation_progress], _js="""
-                    () => {
-                        info_string = document.getElementById("annotation_info").innerHTML;
-                        info = JSON.parse(info_string);
-                        console.log(info)
-                        if (info.length == 0) {
-                            window.annotation_info = [];
-                            return false;
-                        } 
-                        window.annotation_info = window.annotation_info.concat(info)
-                        console.log(window.annotation_info)
-                        return true;
-                    }
-                """)
-                
-                # Event listener for running javascript defined in 'annotation_editor.js'
-                with open('gradio_scripts/annotation_editor.js', 'r') as f:
-                    annotation_editor.change(lambda x: gr.update(), None, annotation_editor, _js=f.read())
+            if enable_annotation_editor:
+                with gr.Tab("Annotation Editor", id=2):
+
+                    # Draw the annotation loading bar here
+                    annotation_progress.render()
+
+                    # Add annotation editor component
+                    annotation_editor = gr.HTML("", visible=False)
+
+                    # Event listener for opening annotation 
+                    annotation_progress.change(load_annotation, annotation_progress, [annotation_editor, annotation_progress], _js="""
+                        () => {
+                            info_string = document.getElementById("annotation_info").innerHTML;
+                            info = JSON.parse(info_string);
+                            console.log(info)
+                            if (info.length == 0) {
+                                window.annotation_info = [];
+                                return false;
+                            } 
+                            window.annotation_info = window.annotation_info.concat(info)
+                            console.log(window.annotation_info)
+                            return true;
+                        }
+                    """)
+                    
+                    # Event listener for running javascript defined in 'annotation_editor.js'
+                    # show_annotation
+                    with open('gradio_scripts/annotation_editor.js', 'r') as f:
+                        annotation_editor.change(lambda x: gr.update(), None, annotation_editor, _js=f.read())
 
     # Disclaimer at the bottom of page
     gr.HTML(
@@ -403,7 +419,7 @@ with demo:
     tab_labeler = components['tab_labeler']
 
 
-    inference_comps = [inference_handler, master_tabs, components['cancelBtn'], components['skipBtn']]
+    inference_comps = [inference_handler, master_tabs, components['cancel_btn']]
 
     # When a file is uploaded to the input, tell the inference_handler to start inference
     input.upload(on_aris_input, [input] + components['hyperparams'], inference_comps)
@@ -416,14 +432,14 @@ with demo:
     result_handler.change(on_result_ready, None, vis_components + [inference_handler])
 
     # Cancel and skip buttons
-    components['cancelBtn'].click(cancel_inference, None, inference_comps, cancels=[inference_event])
-    components['skipBtn'].click(cancel_inference, None, inference_comps, cancels=[inference_event])
+    components['cancel_btn'].click(cancel_inference, None, inference_comps, cancels=[inference_event])
 
     # Button to load a previous result and view visualization
-    components['preview_result_btn'].click(
-        on_result_upload, 
+    components['open_result_btn'].click(on_result_upload, None, [result_uploader, master_tabs])
+    components['result_uploader'].change(
+        on_result_upload_finish, 
         [components['result_input'], components['result_aris_input']], 
-        vis_components + [master_tabs, tab_labeler]
+        vis_components + [tab_labeler]
     )
 
 demo.queue().launch()

gradio_scripts/pdf_handler.py

@@ -42,7 +42,7 @@ def make_pdf(i, state, result, table_headers):
         draw_combined_fish_graphs(pdf, json_result)
 
         for i, fish in enumerate(json_result['fish']):
-            generate_fish_tracks(pdf, json_result, i)
+            draw_fish_tracks(pdf, json_result, dataset, i)
 
         # We can also set the file's metadata via the PdfPages object:
         d = pdf.infodict()
@@ -166,6 +166,7 @@ def calculate_fish_paths(result, dataset, id):
     fish = result['metadata']['FISH'][id]
     start_frame = fish['START_FRAME']
     end_frame = fish['END_FRAME']
+    fps = result['metadata']['FRAME_RATE']
 
     # Extract base frame (first frame for that fish)
     w, h = 1, 2
@@ -175,13 +176,15 @@ def calculate_fish_paths(result, dataset, id):
         images = dataset.didson.load_frames(start_frame=start_frame, end_frame=start_frame+1)
         img = images[0]
 
+        w, h = img.shape
+
         frame_height = 2
         scale_factor = frame_height / h
         h = frame_height
         w = int(scale_factor*w)
 
     fish['base_frame'] = img
-    fish['scaled_frame_size'] = (w, h)
+    fish['scaled_frame_size'] = (h, w)
 
 
     # Find frames for this fish
@@ -214,7 +217,7 @@ def calculate_fish_paths(result, dataset, id):
                 last_y = Y[-1]
                 dx = result['image_meter_width']*(last_x - x)/(missed+1)
                 dy = result['image_meter_height']*(last_y - y)/(missed+1)
-                v = math.sqrt(dx*dx + dy*dy)
+                v = math.sqrt(dx*dx + dy*dy) * fps
 
             # Interpolate over missing frames
             if missed > 0:    
@@ -243,30 +246,72 @@ def calculate_fish_paths(result, dataset, id):
 
 
 def draw_combined_fish_graphs(pdf, result):
+
     vel = []
     log_vel = []
+    eps = 0.00000000001
     for fish in result['metadata']['FISH']:
-        vel += fish['path']['V']
-        log_vel += [math.log(v) for v in fish['path']['V']]
+        for v in fish['path']['V']:
+            vel += [v]
+            if v > 0:
+                log_vel += [math.log(v)]
+
+    fig, axs = plt.subplots(2, 2, sharex=False, sharey=False, figsize=STANDARD_FIG_SIZE)
+
+    # Title
+    fig.suptitle('Fish velocities', fontsize=40, horizontalalignment='center', weight='bold')
 
-    fig, axs = plt.subplots(2, 2, sharey=True, figsize=STANDARD_FIG_SIZE)
     axs[0,0].hist(log_vel, bins=20)
     axs[0,0].set_title('Fish Log-Velocities between frames')
-    axs[0,0].set_xlabel("Log-Velocity (log(m/frame))")
+    axs[0,0].set_xlabel("Log-Velocity (log(m/s))")
+
     axs[0,1].hist(vel, bins=20)
     axs[0,1].set_title('Fish Velocities between frames')
-    axs[0,1].set_xlabel("Velocity (m/frame)")
+    axs[0,1].set_xlabel("Velocity (m/s)")
+
+    for fish in result['metadata']['FISH']:
+        data = []
+        for v in fish['path']['V']:
+            if v > 0: data += [math.log(v)]
+        n, bin_c = make_hist(data)
+        axs[1,0].plot(bin_c, n)
+    axs[1,0].set_title('Fish Log-Velocities between frames (per fish)')
+    axs[1,0].set_xlabel("Log-Velocity (log(m/s))")
+
+    for fish in result['metadata']['FISH']:
+        data = fish['path']['V']
+        n, bin_c = make_hist(data)
+        axs[1,1].plot(bin_c, n)
+    axs[1,1].set_title('Fish Velocities between frames (per fish)')
+    axs[1,1].set_xlabel("Velocity (m/s)")
 
     pdf.savefig(fig)
     plt.close(fig)
     
 
-def generate_fish_tracks(pdf, result, id):
+def make_hist(data):
+    '''histogram and return vectors for plotting'''
+    
+    # figure out the bins
+    min_bin = np.min(data)
+    max_bin = np.max(data)
+    PTS_PER_BIN = 6 #np.sqrt(len(data)) #300
+    bin_sz = (max_bin-min_bin)/(len(data)/PTS_PER_BIN)
+    bins = np.arange(min_bin-bin_sz,max_bin+2*bin_sz,bin_sz)
+    bin_centers = (bins[0:-1]+bins[1:])/2 # bin centers
+    
+    # compute the histogram
+    n,b = np.histogram(data,bins=bins,density=False)
+    return n,bin_centers
+
+def draw_fish_tracks(pdf, result, dataset, id):
 
     fish = result['metadata']['FISH'][id]
     start_frame = fish['START_FRAME']
     end_frame = fish['END_FRAME']
 
+    print(fish)
+
     fig, ax = plt.subplots(figsize=STANDARD_FIG_SIZE)
     plt.axis('off')
 
@@ -277,7 +322,7 @@ def generate_fish_tracks(pdf, result, id):
         plt.imshow(img, extent=(0, h, 0, w), cmap=plt.colormaps['Greys'])
 
     # Title
-    plt.text(h/2,1.1,f'Fish {id+1} (frames {start_frame}-{end_frame})',fontsize=40, color="red", horizontalalignment='center', zorder=5)
+    plt.text(h/2,2,f'Fish {id+1} (frames {start_frame}-{end_frame})',fontsize=40, color="black", horizontalalignment='center', zorder=5)
 
     X = fish['path']['X']
     Y = fish['path']['Y']
@@ -302,9 +347,6 @@ def generate_fish_tracks(pdf, result, id):
         colors.append(col)
         ax.plot([h*(1-Y[i-1]), h*(1-Y[i])], [w*(1-X[i-1]), w*(1-X[i])], color=col, linewidth=1)
     
-    print(len(X))
-    print(len(Y))
-    print(len(colors))
     for i in range(1, len(X)):
         ax.plot(h*(1-Y[i]), w*(1-X[i]), color=colors[i], marker='o', markersize=3)
     
@@ -312,4 +354,64 @@ def generate_fish_tracks(pdf, result, id):
     plt.ylim([0, w])
     plt.xlim([0, h])
     pdf.savefig(fig)
-    plt.close(fig)
+    plt.close(fig)
+
+
+
+
+
+
+
+    if (dataset is not None):
+        indices = [start_frame, int(2/3*start_frame + end_frame/3), int(1/3*start_frame + 2/3*end_frame), end_frame]
+        fig, axs = plt.subplots(2, len(indices), sharex=False, sharey=False, figsize=STANDARD_FIG_SIZE)
+        
+        print("id", id)
+        print('indices', indices)
+        for i, frame_index in enumerate(indices):
+            img = dataset.didson.load_frames(start_frame=frame_index, end_frame=frame_index+1)[0]
+            box = None
+            for fi in range(frame_index, min(frame_index+10, len(result['frames']))):
+                for ann in result['frames'][fi]['fish']:
+                    if ann['fish_id'] == id+1:
+                        box = ann['bbox']
+                        frame_index = fi
+                        break
+
+            batch_i = math.floor(frame_index/32)
+            fi = frame_index - batch_i*32
+            batch = dataset[batch_i]
+            (rgb_img, _, shapes) = batch[fi]
+            rgb_img = rgb_img.permute(1, 2, 0)
+            print(type(batch))
+            print(type(rgb_img))
+            print(rgb_img.shape)
+            
+            print("box", i, box)
+            if box is not None:
+                h, w = img.shape
+                print(w, h)
+                x1, x2, y1, y2 = int(box[0]*w), int(box[2]*w), int(box[1]*h), int(box[3]*h)
+                cx, cy = int((x2 + x1)/2), int((y2 + y1)/2)
+                s = min(int(max(x2 - x1, y2 - y1)*5/2), cx, cy, w-cx, h-cy)
+                print(x1, x2, y1, y2)
+                print(cx, cy, s)
+                cropped_img = img[cy-s:cy+s, cx-s:cx+s]
+                axs[0, i].imshow(cropped_img, extent=(cx-s, cx+s, cy-s, cy+s), cmap=plt.colormaps['Greys_r'])
+                axs[0, i].plot([x1, x1, x2, x2, x1], [y1, y2, y2, y1, y1], color="red")
+                axs[0, i].set_title('Frame ' + str(frame_index))
+
+                h, w, _ = rgb_img.shape
+                print(w, h)
+                x1, x2, y1, y2 = int(box[0]*w), int(box[2]*w), int(box[1]*h), int(box[3]*h)
+                cx, cy = int((x2 + x1)/2), int((y2 + y1)/2)
+                s = min(int(max(x2 - x1, y2 - y1)*5/2), cx, cy, w-cx, h-cy)
+                print(x1, x2, y1, y2)
+                print(cx, cy, s)
+                cropped_img = rgb_img[cy-s:cy+s, cx-s:cx+s, :]
+                axs[1, i].imshow(cropped_img, extent=(cx-s, cx+s, cy-s, cy+s), cmap=plt.colormaps['Greys_r'])
+                axs[1, i].plot([x1, x1, x2, x2, x1], [y1, y2, y2, y1, y1], color="red")
+                axs[1, i].set_title('Frame ' + str(frame_index))
+        
+        pdf.savefig(fig)
+        plt.close(fig)

gradio_scripts/result_ui.py

@@ -41,8 +41,10 @@ def update_result(i, state, result, inference_handler):
 
     annotation_avaliable = not (result["aris_input"][i] == None)
 
-    if 'pdf' in state['outputs']:
+    if 'PDF' in state['outputs']:
+        print("making pdf")
         make_pdf(state['index']-1, state, result, table_headers)
+        print("done pdf")
 
     # Check if files exist
     video_path = result["path_video"][i]
@@ -78,9 +80,7 @@ def Result_Gradio(prepare_annotation, components):
     components['tab_labeler'] = gr.Text(value="", visible=False, elem_id="tab_labeler")
     components['tab_labeler'].change(lambda x: x, None, None, _js=js_update_tab_labels)
 
-    with gr.Row():
-        components['cancelBtn'] = gr.Button("Cancel Inference", visible=False)
-        components['skipBtn'] = gr.Button("Skip this file", visible=False)
+    components['cancel_btn'] = gr.Button("Cancel Inference", visible=False)
 
     # List of all UI components that will recieve outputs from the result_handler
     visual_components = []

gradio_scripts/upload_ui.py

@@ -19,43 +19,43 @@ def Upload_Gradio(gradio_components):
             gr.HTML("<p align='center' style='font-size: large;font-style: italic;'>Submit an .aris file to analyze result.</p>")
             
             default_settings = InferenceConfig()
-            settings = []
+            hyperparams = []
             with gr.Accordion("Advanced Settings", open=False):
                 default_model = default_settings.find_model(models)
-                settings.append(gr.Dropdown(label="Model", value=default_model, choices=list(models.keys())))
+                hyperparams.append(gr.Dropdown(label="Model", value=default_model, choices=list(models.keys())))
 
                 gr.Markdown("Detection Parameters")
                 with gr.Row():
-                    settings.append(gr.Slider(0, 1, value=default_settings.conf_thresh, label="Confidence Threshold", info="Confidence cutoff for detection boxes"))
-                    settings.append(gr.Slider(0, 1, value=default_settings.nms_iou, label="NMS IoU", info="IoU threshold for non-max suppression"))
+                    hyperparams.append(gr.Slider(0, 1, value=default_settings.conf_thresh, label="Confidence Threshold", info="Confidence cutoff for detection boxes"))
+                    hyperparams.append(gr.Slider(0, 1, value=default_settings.nms_iou, label="NMS IoU", info="IoU threshold for non-max suppression"))
 
                 gr.Markdown("Tracking Parameters")
                 with gr.Row():
-                    settings.append(gr.Slider(0, 100, value=default_settings.min_hits, label="Min Hits", info="Minimum number of frames a fish has to appear in to count"))
-                    settings.append(gr.Slider(0, 100, value=default_settings.max_age, label="Max Age", info="Max age of occlusion before track is split"))
+                    hyperparams.append(gr.Slider(0, 100, value=default_settings.min_hits, label="Min Hits", info="Minimum number of frames a fish has to appear in to count"))
+                    hyperparams.append(gr.Slider(0, 100, value=default_settings.max_age, label="Max Age", info="Max age of occlusion before track is split"))
 
                 default_tracker = TrackerType.toString(default_settings.associative_tracker)
                 tracker = gr.Dropdown(["None", "Confidence Boost", "ByteTrack"], value=default_tracker, label="Associative Tracking")
-                settings.append(tracker)
+                hyperparams.append(tracker)
                 with gr.Row(visible=default_tracker=="Confidence Boost") as track_row:
-                    settings.append(gr.Slider(0, 5, value=default_settings.boost_power, label="Boost Power", info=""))
-                    settings.append(gr.Slider(0, 1, value=default_settings.boost_decay, label="Boost Decay", info=""))
+                    hyperparams.append(gr.Slider(0, 5, value=default_settings.boost_power, label="Boost Power", info=""))
+                    hyperparams.append(gr.Slider(0, 1, value=default_settings.boost_decay, label="Boost Decay", info=""))
                     tracker.change(lambda x:  gr.update(visible=(x=="Confidence Boost")), tracker, track_row)
                 with gr.Row(visible=default_tracker=="ByteTrack") as track_row:
-                    settings.append(gr.Slider(0, 1, value=default_settings.byte_low_conf, label="Low Conf Threshold", info=""))
-                    settings.append(gr.Slider(0, 1, value=default_settings.byte_high_conf, label="High Conf Threshold", info=""))
+                    hyperparams.append(gr.Slider(0, 1, value=default_settings.byte_low_conf, label="Low Conf Threshold", info=""))
+                    hyperparams.append(gr.Slider(0, 1, value=default_settings.byte_high_conf, label="High Conf Threshold", info=""))
                     tracker.change(lambda x:  gr.update(visible=(x=="ByteTrack")), tracker, track_row)
 
                 gr.Markdown("Other")
                 with gr.Row():
-                    settings.append(gr.Slider(0, 3, value=default_settings.min_length, label="Min Length", info="Minimum length of fish (meters) in order for it to count"))
-                    settings.append(gr.Slider(0, 3, value=default_settings.max_length, label="Max Length", info="Maximum length of fish (meters) in order for it to count"))
-                    settings.append(gr.Slider(0, 10, value=default_settings.min_travel, label="Min Travel", info="Minimum travel distance of track (meters) in order for it to count"))
+                    hyperparams.append(gr.Slider(0, 3, value=default_settings.min_length, label="Min Length", info="Minimum length of fish (meters) in order for it to count"))
+                    hyperparams.append(gr.Slider(0, 3, value=default_settings.max_length, label="Max Length", info="Maximum length of fish (meters) in order for it to count"))
+                    hyperparams.append(gr.Slider(0, 10, value=default_settings.min_travel, label="Min Travel", info="Minimum travel distance of track (meters) in order for it to count"))
 
-                gradio_components['hyperparams'] = settings
+                gradio_components['hyperparams'] = hyperparams
 
             with gr.Row():
-                settings.append(gr.CheckboxGroup(["Annotated Video", "Manual Marking", "PDF"], label="Output formats", interactive=True, value=["Annotated Video", "Manual Marking"]))
+                hyperparams.append(gr.CheckboxGroup(["Annotated Video", "Manual Marking", "PDF"], label="Output formats", interactive=True, value=["Annotated Video", "Manual Marking"]))
 
             #Input field for aris submission
             gradio_components['input'] = File(file_types=[".aris", ".ddf"], type="binary", label="ARIS Input", file_count="multiple")
@@ -74,4 +74,4 @@ def Upload_Gradio(gradio_components):
             gradio_components['result_aris_input'] = File(file_types=[".aris", ".ddf"], type="binary", label="Upload aris file (optional)", file_count="multiple")
             
             # Button for initializing review
-            gradio_components['preview_result_btn'] = gr.Button("View Result")
+            gradio_components['open_result_btn'] = gr.Button("View Result")

inference.py

@@ -19,7 +19,7 @@ import torchvision
 
 from InferenceConfig import InferenceConfig, TrackerType
 from lib.fish_eye.tracker import Tracker
-from lib.fish_eye.associative import Associate
+from lib.fish_eye.bytetrack import Associate
 
 
 ### Configuration options
@@ -458,7 +458,11 @@ def non_max_suppression(
     # width filter
     pix2width = image_meter_width/image_pixel_width
     width = prediction[..., 2]*pix2width
-    wc = width < max_length
+    if max_length > 0:
+        wc = width < max_length
+    else:
+        # If max_length is 0, ignore
+        wc = width > max_length
 
 
     # Settings

lib/fish_eye/tracker.py

@@ -6,7 +6,7 @@ import numpy as np
 
 from fish_length import Fish_Length
 from lib.fish_eye.sort import Sort
-from lib.fish_eye.associative import Associate
+from lib.fish_eye.bytetrack import Associate
 import lib
 
 class Tracker:
@@ -36,7 +36,7 @@ class Tracker:
                     if (score < min_score):
                         min_score = score
                         conf = det[4]
-            elif type(self.algorithm) == lib.fish_eye.associative.Associate:
+            elif type(self.algorithm) == lib.fish_eye.bytetrack.Associate:
                 for det in dets[0]:
                     score = sum(abs(det[0:4] - track[0:4]))
                     if (score < min_score):