Update app.py

app.py

@@ -1144,7 +1144,72 @@ def process_video_file(video_file, analysis_types, processing_mode="Hybrid (Goog
     # Display mode being used
     st.info(f"Processing with {processing_mode} mode")
     
-    # The rest of the video processing code would follow...
+    try:
+        frame_count = 0
+        while frame_count < max_frames:  # Limit to 10 seconds
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            frame_count += 1
+            
+            # Update progress
+            progress = int(frame_count / total_frames * 100)
+            progress_bar.progress(progress)
+            status_text.text(f"Processing frame {frame_count}/{total_frames} ({progress}%) - {frame_count/fps:.1f}s of 10s")
+            
+            # Add timestamp to frame
+            cv2.putText(frame, f"Time: {frame_count/fps:.2f}s", 
+                      (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+            
+            # Add processing mode indicator
+            cv2.putText(frame, f"Mode: {processing_mode}", 
+                      (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+            
+            # ... rest of the processing code ...
+            
+            # Write the frame to output video
+            out.write(frame)
+        
+        # Release resources
+        cap.release()
+        out.release()
+        
+        # Clear progress indicators
+        progress_bar.empty()
+        status_text.empty()
+        
+        # Read the processed video as bytes for download
+        with open(output_path, 'rb') as file:
+            processed_video_bytes = file.read()
+        
+        # Clean up temporary files
+        os.unlink(temp_video_path)
+        os.unlink(output_path)
+        
+        # Return results
+        results = {"detection_stats": detection_stats}
+        
+        # Store results in session state for chatbot context
+        st.session_state.analysis_results = results
+        
+        # Update vectorstore with new results
+        update_vectorstore_with_results(results)
+        
+        return processed_video_bytes, results
+        
+    except Exception as e:
+        # Clean up on error
+        cap.release()
+        if 'out' in locals():
+            out.release()
+        os.unlink(temp_video_path)
+        if os.path.exists(output_path):
+            os.unlink(output_path)
+        
+        # Return error information
+        st.error(f"Error processing video: {str(e)}")
+        return None, None
 
 def load_bigquery_table(dataset_id, table_id, limit=1000):
     """Load data directly from an existing BigQuery table"""
@@ -2273,4 +2338,277 @@ def main():
                                 st.success(f"Successfully uploaded to {dataset_id}.{table_id}")
                                 st.write(f"Rows: {result['num_rows']}")
                                 st.write(f"Size: {result['size_bytes'] / 1024:.2f} KB")
-                 
+                                st.write(f"Schema: {', '.join(result['schema'])}")
+                                
+                                # Store table info in session state
+                                st.session_state["table_info"] = {
+                                    "dataset_id": dataset_id,
+                                    "table_id": table_id,
+                                    "schema": result["schema"]
+                                }
+                            except Exception as e:
+                                st.error(f"Error uploading to BigQuery: {str(e)}")
+                except Exception as e:
+                    st.error(f"Error reading CSV file: {str(e)}")
+            else:
+                st.info("Upload a CSV file to load data into BigQuery")
+        
+        with query_tab:
+            st.markdown("### Query BigQuery Data")
+            
+            if "query_results" in st.session_state and "table_info" in st.session_state:
+                # Display info about the loaded data
+                table_info = st.session_state["table_info"]
+                st.write(f"Working with table: **{table_info['dataset_id']}.{table_info['table_id']}**")
+                
+                # Query input
+                default_query = f"SELECT * FROM `{credentials.project_id}.{table_info['dataset_id']}.{table_info['table_id']}` LIMIT 100"
+                query = st.text_area("SQL Query", default_query, height=100)
+                
+                # Execute query button
+                if st.button("Run Query"):
+                    with st.spinner("Executing query..."):
+                        try:
+                            # Run the query
+                            results = run_bigquery(query)
+                            
+                            # Store results in session state
+                            st.session_state["query_results"] = results
+                            
+                            # Display results
+                            st.write("### Query Results")
+                            st.dataframe(results)
+                            
+                            # Download button for results
+                            csv = results.to_csv(index=False)
+                            st.download_button(
+                                label="Download Results as CSV",
+                                data=csv,
+                                file_name="query_results.csv",
+                                mime="text/csv"
+                            )
+                        except Exception as e:
+                            st.error(f"Error executing query: {str(e)}")
+            else:
+                st.info("Load a table from BigQuery or upload a CSV file first")
+        
+        with visualization_tab:
+            st.markdown("### Visualize BigQuery Data")
+            
+            if "query_results" in st.session_state and not st.session_state["query_results"].empty:
+                df = st.session_state["query_results"]
+                
+                # Chart type selection
+                chart_type = st.selectbox(
+                    "Select Chart Type",
+                    ["Bar Chart", "Line Chart", "Scatter Plot", "Histogram", "Pie Chart"]
+                )
+                
+                # Column selection based on data types
+                numeric_cols = df.select_dtypes(include=['int64', 'float64']).columns.tolist()
+                all_cols = df.columns.tolist()
+                
+                if len(numeric_cols) < 1:
+                    st.warning("No numeric columns available for visualization")
+                else:
+                    if chart_type in ["Bar Chart", "Line Chart", "Scatter Plot"]:
+                        col1, col2 = st.columns(2)
+                        
+                        with col1:
+                            x_axis = st.selectbox("X-axis", all_cols)
+                        
+                        with col2:
+                            y_axis = st.selectbox("Y-axis", numeric_cols)
+                        
+                        # Optional: Grouping/color dimension
+                        color_dim = st.selectbox("Color Dimension (Optional)", ["None"] + all_cols)
+                        
+                        # Generate the visualization based on selection
+                        if st.button("Generate Visualization"):
+                            st.write(f"### {chart_type}: {y_axis} by {x_axis}")
+                            
+                            if chart_type == "Bar Chart":
+                                if color_dim != "None":
+                                    fig = px.bar(df, x=x_axis, y=y_axis, color=color_dim, 
+                                                 title=f"{y_axis} by {x_axis}")
+                                else:
+                                    fig = px.bar(df, x=x_axis, y=y_axis, title=f"{y_axis} by {x_axis}")
+                                st.plotly_chart(fig)
+                            
+                            elif chart_type == "Line Chart":
+                                if color_dim != "None":
+                                    fig = px.line(df, x=x_axis, y=y_axis, color=color_dim,
+                                                  title=f"{y_axis} by {x_axis}")
+                                else:
+                                    fig = px.line(df, x=x_axis, y=y_axis, title=f"{y_axis} by {x_axis}")
+                                st.plotly_chart(fig)
+                            
+                            elif chart_type == "Scatter Plot":
+                                if color_dim != "None":
+                                    fig = px.scatter(df, x=x_axis, y=y_axis, color=color_dim,
+                                                     title=f"{y_axis} vs {x_axis}")
+                                else:
+                                    fig = px.scatter(df, x=x_axis, y=y_axis, title=f"{y_axis} vs {x_axis}")
+                                st.plotly_chart(fig)
+                    
+                    elif chart_type == "Histogram":
+                        column = st.selectbox("Select Column", numeric_cols)
+                        bins = st.slider("Number of Bins", min_value=5, max_value=100, value=20)
+                        
+                        if st.button("Generate Visualization"):
+                            st.write(f"### Histogram of {column}")
+                            fig = px.histogram(df, x=column, nbins=bins, title=f"Distribution of {column}")
+                            st.plotly_chart(fig)
+                    
+                    elif chart_type == "Pie Chart":
+                        column = st.selectbox("Category Column", all_cols)
+                        value_col = st.selectbox("Value Column", numeric_cols)
+                        
+                        if st.button("Generate Visualization"):
+                            # Aggregate the data if needed
+                            pie_data = df.groupby(column)[value_col].sum().reset_index()
+                            st.write(f"### Pie Chart: {value_col} by {column}")
+                            fig = px.pie(pie_data, names=column, values=value_col, 
+                                         title=f"{value_col} by {column}")
+                            st.plotly_chart(fig)
+            else:
+                st.info("Load a table from BigQuery or upload a CSV file first")
+    
+    elif selected == "About":
+        st.markdown("## About This App")
+        st.write("""
+        This application uses Google Cloud Vision AI to analyze images and video streams. It can:
+        
+        - **Detect labels** in images
+        - **Identify objects** and their locations
+        - **Extract text** from images
+        - **Detect faces** and facial landmarks
+        - **Analyze real-time video** from your camera
+        
+        To use this app, you need to:
+        1. Set up Google Cloud Vision API credentials
+        2. Upload an image or use your camera
+        3. Select the types of analysis you want to perform
+        4. Click "Analyze Image" or start the video stream
+        
+        The app is built with Streamlit and Google Cloud Vision API.
+        """)
+        
+        st.info("Note: Make sure your Google Cloud credentials are properly set up to use this application.")
+
+    # Add the chatbot interface at the bottom of the page
+    chatbot_interface()
+
+if __name__ == "__main__":
+    # Use GOOGLE_CREDENTIALS directly - no need for file or GOOGLE_APPLICATION_CREDENTIALS
+    try:
+        if 'GOOGLE_CREDENTIALS' in os.environ:
+            # Create credentials object directly from JSON string
+            credentials_info = json.loads(os.environ['GOOGLE_CREDENTIALS'])
+            credentials = service_account.Credentials.from_service_account_info(credentials_info)
+            
+            # Initialize client with these credentials directly
+            client = vision.ImageAnnotatorClient(credentials=credentials)
+        else:
+            st.sidebar.error("GOOGLE_CREDENTIALS environment variable not found")
+            client = None
+    except Exception as e:
+        st.sidebar.error(f"Error with credentials: {str(e)}")
+        client = None
+
+    main() 
+
+# Add this function to your app
+def extract_video_frames(video_bytes, num_frames=5):
+    """Extract frames from video bytes for thumbnail display with improved key frame selection"""
+    import cv2
+    import numpy as np
+    import tempfile
+    from PIL import Image
+    import io
+    
+    # Save video bytes to a temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
+        temp_file.write(video_bytes)
+        temp_video_path = temp_file.name
+    
+    # Open the video file
+    cap = cv2.VideoCapture(temp_video_path)
+    
+    # Get video properties
+    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    
+    # Use more sophisticated frame selection based on content analysis
+    frames = []
+    frame_scores = []
+    sample_interval = max(1, frame_count // (num_frames * 3))  # Sample more frames than needed
+    
+    # First pass: collect frame scores
+    prev_frame = None
+    frame_index = 0
+    
+    while len(frame_scores) < num_frames * 3 and frame_index < frame_count:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_index)
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        # Convert to grayscale for analysis
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        gray = cv2.GaussianBlur(gray, (21, 21), 0)
+        
+        # Calculate frame score based on Laplacian variance (focus measure)
+        focus_score = cv2.Laplacian(gray, cv2.CV_64F).var()
+        
+        # Calculate frame difference if we have a previous frame
+        diff_score = 0
+        if prev_frame is not None:
+            frame_diff = cv2.absdiff(gray, prev_frame)
+            diff_score = np.mean(frame_diff)
+            
+        # Combined score: favor sharp frames with significant changes
+        combined_score = focus_score * 0.6 + diff_score * 0.4
+        frame_scores.append((frame_index, combined_score))
+        
+        # Store frame for next comparison
+        prev_frame = gray
+        frame_index += sample_interval
+    
+    # Second pass: select the best frames based on scores
+    # Sort by score and get top N frames
+    sorted_frames = sorted(frame_scores, key=lambda x: x[1], reverse=True)
+    best_frames = sorted_frames[:num_frames]
+    # Sort back by frame index to maintain chronological order
+    selected_frames = sorted(best_frames, key=lambda x: x[0])
+    
+    # Extract the selected frames
+    for idx, _ in selected_frames:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+        ret, frame = cap.read()
+        if ret:
+            # Apply subtle enhancement to frames
+            enhanced_frame = frame.copy()
+            # Auto color balance
+            lab = cv2.cvtColor(enhanced_frame, cv2.COLOR_BGR2LAB)
+            l, a, b = cv2.split(lab)
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+            cl = clahe.apply(l)
+            enhanced_lab = cv2.merge((cl, a, b))
+            enhanced_frame = cv2.cvtColor(enhanced_lab, cv2.COLOR_LAB2BGR)
+            
+            # Convert to RGB (from BGR)
+            frame_rgb = cv2.cvtColor(enhanced_frame, cv2.COLOR_BGR2RGB)
+            # Convert to PIL Image
+            pil_img = Image.fromarray(frame_rgb)
+            # Save to bytes
+            img_byte_arr = io.BytesIO()
+            pil_img.save(img_byte_arr, format='JPEG', quality=90)
+            frames.append(img_byte_arr.getvalue())
+    
+    # Clean up
+    cap.release()
+    import os
+    os.unlink(temp_video_path)
+    
+    return frames