fixed issue with closed file

app.py

@@ -394,85 +394,53 @@ if app_mode =='About App':
             
         ''')
     
-elif app_mode =='Run on Test Videos':
-    # placeholder = st.empty()
-    category = st.sidebar.selectbox('Choose Category',
-                                    np.sort(test_files_df['Category'].unique(), axis=-1, kind='mergesort'))
-    # print(category)
-    mask = (test_files_df['Category']==category)
-    test_files_df_category=test_files_df[mask]
-    cls = st.sidebar.selectbox('Choose Class',
+elif app_mode == 'Run on Test Videos':
+    category = st.sidebar.selectbox(
+        'Choose Category',
+        np.sort(test_files_df['Category'].unique(), axis=-1, kind='mergesort')
+    )
+    mask = (test_files_df['Category'] == category)
+    test_files_df_category = test_files_df[mask]
+
+    cls = st.sidebar.selectbox(
+        'Choose Class',
         np.sort(test_files_df_category['Class'].unique(), axis=-1, kind='mergesort')
     )
-    mask = (test_files_df['Class']==cls)
-    filename = st.sidebar.selectbox('Choose File',
+    mask = (test_files_df['Class'] == cls)
+    filename = st.sidebar.selectbox(
+        'Choose File',
         np.sort(test_files_df_category[mask]['Filename'].unique(), axis=-1, kind='mergesort')
     )
-    # print(f'test/{category}/{cls}/{filename}')
-    # mask = (include_df['Filepath'].str.contains(key[0])) & (include_df['type']==key[2]) & (include_df['expression']==key[1])
-    # stframe = st.empty()
-    
-    if st.sidebar.button("Start", type="primary"):
-        mask = (testing_df['FileName'] == filename) & (testing_df['Type']==category)& (testing_df['Expression']==cls)
-        # filtered_df = current_test_df.sort_
 
-        window_size=20
-        current_test_df=testing_df[mask]
-        X_test_filtered,y_test_filtered = create_timeseries_data(current_test_df,feature_columns_new,label_columns,window_size=window_size)
-        # y_filtered_encoded=to_categorical(y_test_filtered, num_classes=len(df['Expression_encoded'].unique()))
-        X_test_filtered=np.array(X_test_filtered)
-
-        # encoded_translation=model(frame.reshape(1,frame.shape[0],frame.shape[1]))
-        st.set_option('deprecation.showfileUploaderEncoding', False)
+    if st.sidebar.button("Start", type="primary"):
+        # ✅ reset state for fresh run
+        frame_wise_outputs = {}
 
-        # use_webcam = st.sidebar.button('Use Webcam')
-        # record = st.sidebar.checkbox("Record Video")
-        # if record:
-        #     st.checkbox("Recording", value=True)
+        mask = (
+            (testing_df['FileName'] == filename) &
+            (testing_df['Type'] == category) &
+            (testing_df['Expression'] == cls)
+        )
+        current_test_df = testing_df[mask]
 
-        st.sidebar.markdown('---')
-        st.markdown(
-        """
-        <style>
-        [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
-            width: 400px;
-        }
-        [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
-            width: 400px;
-            margin-left: -400px;
-        }
-        </style>
-        """,
-        unsafe_allow_html=True,
-            )
+        window_size = 20
+        X_test_filtered, y_test_filtered = create_timeseries_data(
+            current_test_df, feature_columns_new, label_columns, window_size=window_size
+        )
+        X_test_filtered = np.array(X_test_filtered)
 
         st.sidebar.markdown('---')
-
-        st.markdown(' ## Output')
+        st.markdown(" ## Output")
 
         runtime_progress = st.empty()
-
         with runtime_progress.container():
-            df1 = pd.DataFrame([['--','--']], columns=['Frames Processed','Detected Class'])
-
+            df1 = pd.DataFrame([['--', '--']], columns=['Frames Processed', 'Detected Class'])
             my_table = st.table(df1)
-        # kpi1, kpi2 = st.columns(2)
-
-        # with kpi1:
-        #     st.markdown("**Frames Processed**")
-        #     kpi1_text = st.markdown(f'0/{current_test_df.shape[0]}')
 
-        # with kpi2:
-        #     st.markdown("**Detected Class**")
-        #     kpi2_text = st.markdown("--")
-        
         view = st.empty()
-
         st.markdown("<hr/>", unsafe_allow_html=True)
-        stframes = st.empty()#[st.empty() for _ in range(20)]
-        # video_file_buffer = st.sidebar.file_uploader("Upload a video", type=[ "mp4", "mov",'avi','asf', 'm4v' ])
-        # tfflie = tempfile.NamedTemporaryFile(delete=False)
 
+        # ✅ download video
         vid_file = hf_hub_download(
             repo_id="sunilsarolkar/isl-test-data",
             filename=f'test/{category}/{cls}/{filename}',
@@ -480,187 +448,121 @@ elif app_mode =='Run on Test Videos':
         )
 
         vid = cv2.VideoCapture(vid_file)
+        if not vid.isOpened():
+            st.error(f"Could not open video: {vid_file}")
+            return
 
+        # ✅ parse video metadata
         ffprobe_result = ffprobe(vid_file)
         info = json.loads(ffprobe_result.json)
         videoinfo = [i for i in info["streams"] if i["codec_type"] == "video"][0]
         input_fps = videoinfo["avg_frame_rate"]
-        # input_fps = float(input_fps[0])/float(input_fps[1])
         input_pix_fmt = videoinfo["pix_fmt"]
         input_vcodec = videoinfo["codec_name"]
         postfix = info["format"]["format_name"].split(",")[0]
-        # print(f'input_vcodec-{input_vcodec}')
-
-        width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        fps_input = int(vid.get(cv2.CAP_PROP_FPS))
-
-        #codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
-        # codec = cv2.VideoWriter_fourcc('V','P','0','9')
-        # out = cv2.VideoWriter('output1.mp4', codec, fps_input, (width, height))
-
-        # st.sidebar.text('Input Video')
-        # st.sidebar.video(tfflie.name)
-        fps = 0
-        i = 0
-
-
-
-        # cap = cv2.VideoCapture(video_file,)
-        totalFrames=int(vid.get(cv2.CAP_PROP_FRAME_COUNT))
-        window_size=20
-        # print('current_test_df',current_test_df)
-        # print('totalFrames',totalFrames)
-        window=[]
-    
-    
-        prevTime = 0
-        postfix = info["format"]["format_name"].split(",")[0]
 
+        totalFrames = int(vid.get(cv2.CAP_PROP_FRAME_COUNT))
+        st.write(f"Opened video with {totalFrames} frames")
 
         output_file = f"/tmp/output_{uuid.uuid4().hex}.{postfix}"
+        writer = None
+        window = []
+        weighted_avg_dict = {}
+        idx = 0
+        prevTime = 0
 
-        # height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        fps_input = int(vid.get(cv2.CAP_PROP_FPS))
-
-        #codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
-        
-        # codec = cv2.VideoWriter_fourcc('m','p','4','v')
-        out = None
-        writer=None
-        weighted_avg_dict={}
-        
-        idx=0
         try:
-            for _, row in current_test_df.iterrows():#enumerate(file_df.rolling(window=20, step=20,min_periods=1)):
-                # print(f'captured frame#{idx}')
-                if not vid.isOpened():
-                    st.error(f"Could not open video: {vid_file}")
+            for _, row in current_test_df.iterrows():
+                ret, frame = vid.read()
+                if not ret:
+                    break
+
+                if len(window) < window_size:
+                    # burn-in period (first 20 frames)
+                    canvas = util.drawStickmodel(
+                        frame,
+                        eval(row['bodypose_circles']),
+                        eval(row['bodypose_sticks']),
+                        eval(row['handpose_edges']),
+                        eval(row['handpose_peaks'])
+                    )
+                    canvas_with_plot = util.draw_bar_plot_below_image(
+                        canvas, {}, f'Prediction bar plot - Frame {idx+1} [no predictions]', canvas
+                    )
+                    canvas_with_plot = util.add_padding_to_bottom(canvas_with_plot, (255,255,255), 100)
+
+                    if writer is None:
+                        input_framesize = canvas_with_plot.shape[:2]
+                        writer = Writer(output_file, input_fps, input_framesize, input_pix_fmt, input_vcodec)
+
+                    writer(canvas_with_plot)
+                    with runtime_progress.container():
+                        df1 = pd.DataFrame([[f'{idx+1}/{current_test_df.shape[0]}', '<model will output after 20 frames>']],
+                                           columns=['Frames Processed', 'Detected Class'])
+                        my_table = st.table(df1)
+                    window.append(frame)
+                    with view.container():
+                        st.image(canvas_with_plot, channels='BGR', use_column_width=True)
+
                 else:
-                    if(vid.isOpened()):
-                        ret, frame = vid.read()
-                        
-                        
-                        if len(window)<window_size:
-                            canvas=util.drawStickmodel(frame,eval(row['bodypose_circles']),eval(row['bodypose_sticks']),eval(row['handpose_edges']),eval(row['handpose_peaks']))
-                            canvas_with_plot=util.draw_bar_plot_below_image(canvas,{}, f'Prediction bar plot - Frame number {idx+1} [** no predictions]',canvas)
-                            canvas_with_plot=util.draw_bar_plot_below_image(canvas_with_plot,weighted_avg_dict, f'Weighted avg - Frame number {idx+1} [** no predictions]',canvas)
-                            canvas_with_plot=util.add_padding_to_bottom(canvas_with_plot,(255,255,255),100)# Adds padding at bottom
-                            
-                            if writer is None:                        
-                                input_framesize = canvas_with_plot.shape[:2]
-                                writer = Writer(output_file, input_fps, input_framesize, input_pix_fmt,
-                                                input_vcodec)
-
-                            # if out is None:
-                            #     out=cv2.VideoWriter(output_file, codec, fps_input, frame.shape[:2])
-                            
-
-                            writer(canvas_with_plot)
-                            # out.write(canvas)
-                            with runtime_progress.container():
-                                df1 = pd.DataFrame([[f'{idx+1}/{current_test_df.shape[0]}','<model will output after 20 frames>']], columns=['Frames Processed','Detected Class'])
-
-                                my_table = st.table(df1)
-                            window.append(frame)
-                            # kpi1_text.write(f"<h1 style='text-align: center; color: red;'>{idx+1}/{current_test_df.shape[0]}</h1>", unsafe_allow_html=True)
-                            # kpi2_text.write(f"<h1 style='text-align: center; color: red;'>--</h1>", unsafe_allow_html=True)
-                            with view.container():
-                                st.image(canvas_with_plot,channels = 'BGR',use_column_width=True)
-                        else:
-
-                            window[:-1] = window[1:]
-                            window[-1]=frame
-                            translation_model=get_translator_model()
-                            # testing_df[]
-                            
-                            encoded_translation = translation_model(X_test_filtered[idx-20].reshape(1,X_test_filtered[idx-20].shape[0],X_test_filtered[idx-20].shape[1]))
-                            encoded_translation=encoded_translation[0].cpu().detach().numpy()
-                            sorted_index=np.argsort(encoded_translation)[::-1]
-                            maxindex=np.argmax(encoded_translation)
-
-                            top_3_probs = encoded_translation.argsort()[-3:][::-1]  # Get indices of top 3 probabilities (descending order)
-                            top_3_categories = [expression_mapping[i] for i in top_3_probs]  # Convert indices to category names (assuming class_names list exists)
-                            top_3_values = encoded_translation[top_3_probs]  # Get corresponding probabilities
-                            # print(f'{idx} {encoded_translation[maxindex]:0.4f} {maxindex}-{expression_mapping[maxindex]} ')#{[(pi,encoded_translation[pi],expression_mapping[pi]) for pi in sorted_index]}
-                            for category, prob in zip(top_3_categories, top_3_values):
-                                if category not in frame_wise_outputs:
-                                    frame_wise_outputs[category]=[]
-                                frame_wise_outputs[category].append(prob)
-                            current_prob={}
-
-                            for category, prob in zip(top_3_categories, top_3_values):
-                                current_prob[category]=prob
-
-                            for key in frame_wise_outputs:
-                                weighted_avg_dict[key]=weighted_average(frame_wise_outputs[key],[len(frame_wise_outputs[key]) for i in range(len(frame_wise_outputs[key]))])
-
-                            sorted_dict = dict(sorted(weighted_avg_dict.items(), key=lambda item: item[1], reverse=True))
-                            canvas=util.drawStickmodel(frame,eval(row['bodypose_circles']),eval(row['bodypose_sticks']),eval(row['handpose_edges']),eval(row['handpose_peaks']))
-                            canvas_with_plot=util.draw_bar_plot_below_image(canvas,current_prob, f'Prediction at frame window({idx-20+1}-{idx+1})',canvas)
-                            canvas_with_plot=util.draw_bar_plot_below_image(canvas_with_plot,weighted_avg_dict, f'Weighted avg till window {idx+1}',canvas)
-                            canvas_with_plot=util.add_padding_to_bottom(canvas_with_plot,(255,255,255),100)
-                            writer(canvas_with_plot)
-
-                            
-                            currTime = time.time()
-                            fps = 1 / (currTime - prevTime)
-                            prevTime = currTime
-                            # out.write(frame)
-                            # if record:
-                            #     #st.checkbox("Recording", value=True)
-                            #     out.write(frame)
-                            #Dashboard
-
-                            max_prob = float('-inf')  # Initialize with negative infinity
-                            max_key = None
-
-                            for exp, prob in weighted_avg_dict.items():
-                                if prob > max_prob:
-                                    max_prob = prob
-                                    max_key = exp
-                            with runtime_progress.container():
-                                df1 = pd.DataFrame([[f'{idx+1}/{current_test_df.shape[0]}',f'{max_key} ({max_prob*100:.2f}%)']], columns=['Frames Processed','Detected Class'])
-                                my_table = st.table(df1)
-                            # kpi1_text.write(f"<h1 style='text-align: center; color: red;'>{idx+1}/{current_test_df.shape[0]}</h1>", unsafe_allow_html=True)
-                            # kpi2_text.write(f"<h1 style='text-align: center; color: red;'>{max_key} ({max_prob*100:.2f}%)</h1>", unsafe_allow_html=True)
-                            # with placeholder.container():
-                            #     # st.write(weighted_avg_dict)
-                            #     # data = {
-                            #     #     "I": 0.7350964583456516,
-                            #     #     "Hello": 0.1078806109726429,
-                            #     #     "you": 0.11776176246348768,
-                            #     #     "you (plural)": 0.12685142129916568
-                            #     # }
-
-                            #     # Convert the dictionary to a Pandas DataFrame for easier plotting
-                            #     df = pd.DataFrame.from_dict(weighted_avg_dict, orient='index', columns=['Values'])
-
-                            #     # Create a bar chart with Streamlit
-                            #     st.bar_chart(df)
-                            # frame = cv2.resize(frame,(0,0),fx = 0.8 , fy = 0.8)
-                            # frame = image_resize(image = frame, width = 640)
-                            with view.container():
-                                st.image(canvas_with_plot,channels = 'BGR',use_column_width=True)
-
-                        idx=idx+1
-                    
-
-            # st.text('Video Processed')
+                    # inference after burn-in
+                    window[:-1] = window[1:]
+                    window[-1] = frame
+
+                    translation_model = get_translator_model()
+                    encoded_translation = translation_model(
+                        X_test_filtered[idx-20].reshape(1, X_test_filtered[idx-20].shape[0], X_test_filtered[idx-20].shape[1])
+                    )
+                    encoded_translation = encoded_translation[0].cpu().detach().numpy()
+                    top_3_probs = encoded_translation.argsort()[-3:][::-1]
+                    top_3_categories = [expression_mapping[i] for i in top_3_probs]
+                    top_3_values = encoded_translation[top_3_probs]
+
+                    for category, prob in zip(top_3_categories, top_3_values):
+                        frame_wise_outputs.setdefault(category, []).append(prob)
+
+                    current_prob = dict(zip(top_3_categories, top_3_values))
+                    for key, values in frame_wise_outputs.items():
+                        weighted_avg_dict[key] = weighted_average(values, [len(values)]*len(values))
+
+                    canvas = util.drawStickmodel(
+                        frame,
+                        eval(row['bodypose_circles']),
+                        eval(row['bodypose_sticks']),
+                        eval(row['handpose_edges']),
+                        eval(row['handpose_peaks'])
+                    )
+                    canvas_with_plot = util.draw_bar_plot_below_image(
+                        canvas, current_prob, f'Prediction at window({idx-20+1}-{idx+1})', canvas
+                    )
+                    canvas_with_plot = util.draw_bar_plot_below_image(
+                        canvas_with_plot, weighted_avg_dict, f'Weighted avg till frame {idx+1}', canvas
+                    )
+                    canvas_with_plot = util.add_padding_to_bottom(canvas_with_plot, (255,255,255), 100)
+                    writer(canvas_with_plot)
+
+                    # update display
+                    max_key, max_prob = max(weighted_avg_dict.items(), key=lambda kv: kv[1])
+                    with runtime_progress.container():
+                        df1 = pd.DataFrame([[f'{idx+1}/{current_test_df.shape[0]}',
+                                             f'{max_key} ({max_prob*100:.2f}%)']],
+                                           columns=['Frames Processed','Detected Class'])
+                        my_table = st.table(df1)
+                    with view.container():
+                        st.image(canvas_with_plot, channels='BGR', use_column_width=True)
+
+                idx += 1
+
+            # ✅ after loop
             with view.container():
-                if writer is not None:  # ✅ safeguard
-                    writer.close()
-                    output_video = open(output_file,'rb')
-                    out_bytes = output_video.read()
-                    st.video(out_bytes)
-                    print(f'Output file - {output_file}')
+                if writer is not None:
+                    writer.close()  # block until ffmpeg finishes
+                    with open(output_file, 'rb') as f:
+                        st.video(f.read())
+                    st.success(f"Output saved to {output_file}")
                 else:
-                    st.warning("No video was processed, writer is empty.")
-                # out.release()
-                
-                print(f'Output file - {output_file}')
+                    st.warning("No video was processed this run.")
+
         finally:
             vid.release()
-            if writer is not None:
-                writer.close()
-        cv2.destroyAllWindows()
+            cv2.destroyAllWindows()