Update app.py

app.py

@@ -20,6 +20,7 @@ import tempfile
 import time
 import matplotlib.pyplot as plt
 from pathlib import Path
+import plotly.express as px
 
 # Set page config
 st.set_page_config(
@@ -462,7 +463,7 @@ def list_bigquery_resources():
     return resources
 
 def process_video_file(video_file, analysis_types):
-    """Process an uploaded video file with enhanced Vision AI detection"""
+    """Process an uploaded video file with enhanced Vision AI detection and slow down output for better visibility"""
     # Create a temporary file to save the uploaded video
     with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
         temp_file.write(video_file.read())
@@ -491,9 +492,13 @@ def process_video_file(video_file, analysis_types):
     if int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) > max_frames:
         st.info("⚠️ Video is longer than 10 seconds. Only the first 10 seconds will be processed.")
     
-    # Create video writer
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    # Slow down the output video by reducing the fps (60% of original speed)
+    output_fps = fps * 0.6
+    st.info(f"Output video will be slowed down to {output_fps:.1f} FPS (60% of original speed) for better visualization.")
+    
+    # Create video writer with higher quality settings
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # MP4 codec
+    out = cv2.VideoWriter(output_path, fourcc, output_fps, (width, height), isColor=True)
     
     # Process every Nth frame to reduce API calls but increase from 10 to 5 for more detail
     process_every_n_frames = 5
@@ -556,28 +561,28 @@ def process_video_file(video_file, analysis_types):
                                   for vertex in obj.bounding_poly.normalized_vertices]
                             box = np.array(box, np.int32).reshape((-1, 1, 2))
                             
-                            # Draw more detailed box
-                            cv2.polylines(frame, [box], True, (0, 255, 0), 2)
+                            # Draw more noticeable box with thicker lines
+                            cv2.polylines(frame, [box], True, (0, 255, 0), 3)
                             
                             # Calculate box size for better placement of labels
                             x_min = min([p[0][0] for p in box])
                             y_min = min([p[0][1] for p in box])
                             confidence = int(obj.score * 100)
                             
-                            # Enhanced label with confidence and border
+                            # Enhanced label with confidence and border - larger text for visibility
                             label_text = f"{obj.name}: {confidence}%"
-                            text_size = cv2.getTextSize(label_text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)[0]
+                            text_size = cv2.getTextSize(label_text, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)[0]
                             
-                            # Background rectangle for text visibility
+                            # Larger background rectangle for text visibility
                             cv2.rectangle(frame, 
-                                         (int(x_min), int(y_min) - text_size[1] - 10),
-                                         (int(x_min) + text_size[0] + 10, int(y_min)),
-                                         (0, 0, 0), -1)
+                                        (int(x_min), int(y_min) - text_size[1] - 10),
+                                        (int(x_min) + text_size[0] + 10, int(y_min)),
+                                        (0, 0, 0), -1)
                             
-                            # Draw the label text
+                            # Draw the label text with larger font
                             cv2.putText(frame, label_text, 
                                       (int(x_min) + 5, int(y_min) - 5),
-                                      cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+                                      cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
                     
                     if "Face Detection" in analysis_types:
                         faces = client.face_detection(image=vision_image)
@@ -587,9 +592,9 @@ def process_video_file(video_file, analysis_types):
                         for face in faces.face_annotations:
                             vertices = face.bounding_poly.vertices
                             points = [(vertex.x, vertex.y) for vertex in vertices]
-                            # Draw face box
+                            # Draw face box with thicker lines
                             pts = np.array(points, np.int32).reshape((-1, 1, 2))
-                            cv2.polylines(frame, [pts], True, (0, 0, 255), 2)
+                            cv2.polylines(frame, [pts], True, (0, 0, 255), 3)
                             
                             # Enhanced face info
                             emotions = []
@@ -609,13 +614,13 @@ def process_video_file(video_file, analysis_types):
                             # Add detailed emotion text
                             cv2.putText(frame, emotion_text, 
                                       (int(x_min), int(y_min) - 10),
-                                      cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+                                      cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
                             
                             # Draw enhanced landmarks
                             for landmark in face.landmarks:
                                 px = int(landmark.position.x)
                                 py = int(landmark.position.y)
-                                cv2.circle(frame, (px, py), 2, (255, 255, 0), -1)
+                                cv2.circle(frame, (px, py), 3, (255, 255, 0), -1)  # Larger circles
                     
                     if "Text" in analysis_types:
                         text = client.text_detection(image=vision_image)
@@ -631,25 +636,25 @@ def process_video_file(video_file, analysis_types):
                             if len(words) > 5:
                                 short_text += "..."
                                 
-                            # Add text summary to top of frame
+                            # Add text summary to top of frame with better visibility
                             cv2.rectangle(frame, (10, 60), (10 + len(short_text)*10, 90), (0, 0, 0), -1)
                             cv2.putText(frame, f"Text: {short_text}", 
-                                      (10, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+                                      (10, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
                         
                         # Draw text boxes with improved visibility
                         for text_annot in text.text_annotations[1:]:
                             box = [(vertex.x, vertex.y) for vertex in text_annot.bounding_poly.vertices]
                             pts = np.array(box, np.int32).reshape((-1, 1, 2))
-                            cv2.polylines(frame, [pts], True, (255, 0, 0), 1)
+                            cv2.polylines(frame, [pts], True, (255, 0, 0), 2)  # Thicker lines
                     
                     # Add Labels analysis for more detail
                     if "Labels" in analysis_types:
                         labels = client.label_detection(image=vision_image, max_results=5)
                         
-                        # Add labels to the frame
+                        # Add labels to the frame with better visibility
                         y_pos = 120
-                        cv2.rectangle(frame, (10, y_pos-20), (200, y_pos+20*len(labels.label_annotations)), (0, 0, 0), -1)
-                        cv2.putText(frame, "Scene labels:", (15, y_pos), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+                        cv2.rectangle(frame, (10, y_pos-20), (250, y_pos+20*len(labels.label_annotations)), (0, 0, 0), -1)
+                        cv2.putText(frame, "Scene labels:", (15, y_pos), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
                         
                         # Track stats and show labels
                         for i, label in enumerate(labels.label_annotations):
@@ -659,15 +664,19 @@ def process_video_file(video_file, analysis_types):
                             else:
                                 detection_stats["labels"][label.description] = 1
                                 
-                            # Display on frame
+                            # Display on frame with larger text
                             cv2.putText(frame, f"- {label.description}: {int(label.score*100)}%", 
-                                      (15, y_pos + 20*(i+1)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+                                      (15, y_pos + 20*(i+1)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
                 
                 except Exception as e:
                     # Show error on frame
                     cv2.putText(frame, f"API Error: {str(e)[:30]}", 
                               (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
             
+            # Add hint about slowed down speed
+            cv2.putText(frame, "Playback: 60% speed for better visualization", 
+                      (width - 400, height - 30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 200, 0), 2)
+            
             # Write the frame to output video
             out.write(frame)
         
@@ -730,8 +739,8 @@ def load_bigquery_table(dataset_id, table_id, limit=1000):
     }
 
 def main():
-    # Header
-    st.markdown('<div class="main-header">Google Cloud AI Analyzer</div>', unsafe_allow_html=True)
+    # Header - Updated title
+    st.markdown('<div class="main-header">Cosmick Cloud AI Analyzer</div>', unsafe_allow_html=True)
     
     # Navigation
     selected = option_menu(
@@ -748,6 +757,9 @@ def main():
         with st.sidebar:
             st.markdown("### Analysis Settings")
             
+            # Add mode selection
+            processing_mode = st.radio("Processing Mode", ["Single Image", "Batch Processing (up to 5 images)"])
+            
             # Analysis types selection
             st.write("Choose analysis types:")
             analysis_types = []
@@ -774,45 +786,166 @@ def main():
             st.info("This application analyzes images using Google Cloud Vision AI. Upload an image to get started.")
         
         # Main content
-        uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
-        
-        if uploaded_file is not None:
-            # Convert uploaded file to image
-            image = Image.open(uploaded_file)
+        if processing_mode == "Single Image":
+            st.markdown("## Single Image Analysis")
+            uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
             
-            # Apply quality adjustment if needed
-            if quality < 100:
-                img_byte_arr = io.BytesIO()
-                image.save(img_byte_arr, format='JPEG', quality=quality)
-                image = Image.open(img_byte_arr)
+            if uploaded_file is not None:
+                # Convert uploaded file to image
+                image = Image.open(uploaded_file)
+                
+                # Apply quality adjustment if needed
+                if quality < 100:
+                    img_byte_arr = io.BytesIO()
+                    image.save(img_byte_arr, format='JPEG', quality=quality)
+                    image = Image.open(img_byte_arr)
+                
+                # Show original image
+                st.markdown('<div class="subheader">Original Image</div>', unsafe_allow_html=True)
+                st.image(image, use_column_width=True)
+                
+                # Add analyze button
+                if st.button("Analyze Image"):
+                    if not analysis_types:
+                        st.warning("Please select at least one analysis type.")
+                    else:
+                        with st.spinner("Analyzing image..."):
+                            # Call analyze function
+                            annotated_img, labels, objects, text = analyze_image(image, analysis_types)
+                            
+                            # Display results
+                            display_results(annotated_img, labels, objects, text)
+                            
+                            # Add download button for the annotated image
+                            buf = io.BytesIO()
+                            annotated_img.save(buf, format="PNG")
+                            byte_im = buf.getvalue()
+                            
+                            st.download_button(
+                                label="Download Annotated Image",
+                                data=byte_im,
+                                file_name="annotated_image.png",
+                                mime="image/png"
+                            )
+        
+        else:  # Batch Processing mode
+            st.markdown("## Batch Image Analysis")
+            st.info("Upload up to 5 images for batch processing.")
             
-            # Show original image
-            st.markdown('<div class="subheader">Original Image</div>', unsafe_allow_html=True)
-            st.image(image, use_column_width=True)
+            uploaded_files = st.file_uploader("Choose images...", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
             
-            # Add analyze button
-            if st.button("Analyze Image"):
-                if not analysis_types:
-                    st.warning("Please select at least one analysis type.")
-                else:
-                    with st.spinner("Analyzing image..."):
-                        # Call analyze function
-                        annotated_img, labels, objects, text = analyze_image(image, analysis_types)
+            if uploaded_files:
+                # Limit to 5 images
+                if len(uploaded_files) > 5:
+                    st.warning("Maximum 5 images allowed. Only the first 5 will be processed.")
+                    uploaded_files = uploaded_files[:5]
+                
+                # Display thumbnails of uploaded images
+                st.markdown('<div class="subheader">Uploaded Images</div>', unsafe_allow_html=True)
+                cols = st.columns(len(uploaded_files))
+                for i, uploaded_file in enumerate(uploaded_files):
+                    with cols[i]:
+                        image = Image.open(uploaded_file)
+                        st.image(image, caption=f"Image {i+1}", use_column_width=True)
+                
+                # Add analyze button for batch processing
+                if st.button("Analyze All Images"):
+                    if not analysis_types:
+                        st.warning("Please select at least one analysis type.")
+                    else:
+                        # Initialize containers for batch summary
+                        all_labels = {}
+                        all_objects = {}
                         
-                        # Display results
-                        display_results(annotated_img, labels, objects, text)
+                        # Process each image
+                        for i, uploaded_file in enumerate(uploaded_files):
+                            with st.spinner(f"Analyzing image {i+1} of {len(uploaded_files)}..."):
+                                # Convert uploaded file to image
+                                image = Image.open(uploaded_file)
+                                
+                                # Apply quality adjustment if needed
+                                if quality < 100:
+                                    img_byte_arr = io.BytesIO()
+                                    image.save(img_byte_arr, format='JPEG', quality=quality)
+                                    image = Image.open(img_byte_arr)
+                                
+                                # Analyze image
+                                annotated_img, labels, objects, text = analyze_image(image, analysis_types)
+                                
+                                # Update batch summaries
+                                for label, confidence in labels.items():
+                                    if label in all_labels:
+                                        all_labels[label] = max(all_labels[label], confidence)
+                                    else:
+                                        all_labels[label] = confidence
+                                
+                                for obj, confidence in objects.items():
+                                    if obj in all_objects:
+                                        all_objects[obj] = max(all_objects[obj], confidence)
+                                    else:
+                                        all_objects[obj] = confidence
+                                
+                                # Create expander for each image result
+                                with st.expander(f"Results for Image {i+1}", expanded=i==0):
+                                    # Display results for this image
+                                    display_results(annotated_img, labels, objects, text)
+                                    
+                                    # Add download button for each annotated image
+                                    buf = io.BytesIO()
+                                    annotated_img.save(buf, format="PNG")
+                                    byte_im = buf.getvalue()
+                                    
+                                    st.download_button(
+                                        label=f"Download Annotated Image {i+1}",
+                                        data=byte_im,
+                                        file_name=f"annotated_image_{i+1}.png",
+                                        mime="image/png"
+                                    )
+                        
+                        # Display batch summary
+                        st.markdown('<div class="subheader">Batch Analysis Summary</div>', unsafe_allow_html=True)
                         
-                        # Add download button for the annotated image
-                        buf = io.BytesIO()
-                        annotated_img.save(buf, format="PNG")
-                        byte_im = buf.getvalue()
+                        col1, col2 = st.columns(2)
                         
-                        st.download_button(
-                            label="Download Annotated Image",
-                            data=byte_im,
-                            file_name="annotated_image.png",
-                            mime="image/png"
-                        )
+                        with col1:
+                            if all_labels:
+                                st.markdown("#### Common Labels Across Images")
+                                # Sort by confidence
+                                sorted_labels = dict(sorted(all_labels.items(), key=lambda x: x[1], reverse=True))
+                                for label, confidence in sorted_labels.items():
+                                    st.markdown(f'<div class="label-item">{label}: {confidence}%</div>', unsafe_allow_html=True)
+                        
+                        with col2:
+                            if all_objects:
+                                st.markdown("#### Common Objects Across Images")
+                                # Sort by confidence
+                                sorted_objects = dict(sorted(all_objects.items(), key=lambda x: x[1], reverse=True))
+                                for obj, confidence in sorted_objects.items():
+                                    st.markdown(f'<div class="object-item">{obj}: {confidence}%</div>', unsafe_allow_html=True)
+                        
+                        # Create visualization for batch summary if there are labels or objects
+                        if all_labels or all_objects:
+                            st.markdown("#### Visual Summary")
+                            
+                            # Create label chart
+                            if all_labels:
+                                fig_labels = px.bar(
+                                    x=list(all_labels.keys()),
+                                    y=list(all_labels.values()),
+                                    labels={'x': 'Label', 'y': 'Confidence (%)'},
+                                    title='Top Labels Across All Images'
+                                )
+                                st.plotly_chart(fig_labels)
+                            
+                            # Create object chart
+                            if all_objects:
+                                fig_objects = px.bar(
+                                    x=list(all_objects.keys()),
+                                    y=list(all_objects.values()),
+                                    labels={'x': 'Object', 'y': 'Confidence (%)'},
+                                    title='Top Objects Across All Images'
+                                )
+                                st.plotly_chart(fig_objects)
     
     elif selected == "Video Analysis":
         st.markdown('<div class="subheader">Video Analysis</div>', unsafe_allow_html=True)
@@ -1138,6 +1271,176 @@ def main():
                     st.dataframe(df[num_cols].describe())
             else:
                 st.info("Select an existing dataset and table from the sidebar and click 'Load Selected Table', or upload a CSV file in the 'Upload Data' tab.")
+        
+        with upload_tab:
+            st.markdown("### Upload Data to BigQuery")
+            
+            # File uploader for CSV files
+            uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])
+            
+            if uploaded_file is not None:
+                # Display file details
+                file_details = {
+                    "Filename": uploaded_file.name,
+                    "File size": f"{uploaded_file.size / 1024:.2f} KB"
+                }
+                
+                # Show file preview
+                try:
+                    df_preview = pd.read_csv(uploaded_file)
+                    st.write("### File Preview")
+                    st.dataframe(df_preview.head(5))
+                    
+                    # Store dataframe in session state for other tabs
+                    st.session_state["query_results"] = df_preview
+                    
+                    # Upload button
+                    if st.button("Upload to BigQuery"):
+                        with st.spinner("Uploading to BigQuery..."):
+                            try:
+                                # Upload the file
+                                append = replace_data == "Append to existing data"
+                                result = upload_csv_to_bigquery(uploaded_file, dataset_id, table_id, append=append)
+                                
+                                # Show success message
+                                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")
@@ -1161,6 +1464,17 @@ def main():
         
         st.info("Note: Make sure your Google Cloud credentials are properly set up to use this application.")
 
+    # At the end of the main function, add this footer
+    # Add footer with attribution
+    st.markdown("""
+    <div style='position: fixed; bottom: 0; width: 100%; background-color: #f8f9fa; 
+         text-align: center; padding: 10px; border-top: 1px solid #e9ecef;'>
+        <p style='color: #6c757d; font-size: 14px;'>
+            Powered by Google Cloud with additional tools
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
 if __name__ == "__main__":
     # Use GOOGLE_CREDENTIALS directly - no need for file or GOOGLE_APPLICATION_CREDENTIALS
     try: