handled closure of opened file

app.py

@@ -394,53 +394,85 @@ if app_mode =='About App':
             
         ''')
     
-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',
+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',
         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"):
-        # ✅ reset state for fresh run
-        frame_wise_outputs = {}
+        mask = (testing_df['FileName'] == filename) & (testing_df['Type']==category)& (testing_df['Expression']==cls)
+        # filtered_df = current_test_df.sort_
 
-        mask = (
-            (testing_df['FileName'] == filename) &
-            (testing_df['Type'] == category) &
-            (testing_df['Expression'] == cls)
-        )
-        current_test_df = testing_df[mask]
+        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)
 
-        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)
+        # encoded_translation=model(frame.reshape(1,frame.shape[0],frame.shape[1]))
+        st.set_option('deprecation.showfileUploaderEncoding', False)
+
+        # use_webcam = st.sidebar.button('Use Webcam')
+        # record = st.sidebar.checkbox("Record Video")
+        # if record:
+        #     st.checkbox("Recording", value=True)
+
+        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,
+            )
 
         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}',
@@ -448,120 +480,187 @@ 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}")
-        else:
-            # ✅ 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_pix_fmt = videoinfo["pix_fmt"]
-            input_vcodec = videoinfo["codec_name"]
-            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
-
-            try:
-                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:
-                        # 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:
-                        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 this run.")
-
-            finally:
-                vid.release()
-                cv2.destroyAllWindows()
+
+        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]
+
+
+        output_file = f"/tmp/output_{uuid.uuid4().hex}.{postfix}"
+
+        # 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}")
+                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')
+            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}')
+                else:
+                    st.warning("No video was processed, writer is empty.")
+                # out.release()
+                
+                print(f'Output file - {output_file}')
+        finally:
+            vid.release()
+            if writer is not None:
+                writer.close()
+        cv2.destroyAllWindows()