Update app.py

app.py

@@ -8,6 +8,17 @@ from streamlit_option_menu import option_menu
 import json
 from google.oauth2 import service_account
 import google.auth
+import av
+from streamlit_webrtc import webrtc_streamer, VideoProcessorBase, RTCConfiguration
+import cv2
+from typing import List, Union
+from google.cloud import documentai_v1 as documentai
+import pandas as pd
+from google.cloud import bigquery
+from google.cloud.exceptions import NotFound
+import tempfile
+import time
+import matplotlib.pyplot as plt
 
 # Set page config
 st.set_page_config(
@@ -156,15 +167,241 @@ def display_results(annotated_img, labels, objects, text):
             st.markdown(f'<div class="text-item">{text}</div>', unsafe_allow_html=True)
             st.markdown('</div>', unsafe_allow_html=True)
 
+class VideoProcessor(VideoProcessorBase):
+    """Process video frames for real-time analysis"""
+    
+    def __init__(self, analysis_types: List[str]):
+        self.analysis_types = analysis_types
+        self.frame_counter = 0
+        self.process_every_n_frames = 10  # Process every 10th frame to reduce API calls
+        
+    def transform(self, frame: av.VideoFrame) -> av.VideoFrame:
+        self.frame_counter += 1
+        
+        # Process only every nth frame to reduce API usage
+        if self.frame_counter % self.process_every_n_frames != 0:
+            return frame
+            
+        img = frame.to_ndarray(format="bgr24")
+        
+        # Convert numpy array to PIL Image for Vision API
+        pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+        
+        # Process with Vision API
+        try:
+            # Create vision image
+            img_byte_arr = io.BytesIO()
+            pil_img.save(img_byte_arr, format='PNG')
+            content = img_byte_arr.getvalue()
+            vision_image = vision.Image(content=content)
+            
+            # Process with selected analysis types
+            if "Objects" in self.analysis_types:
+                objects = client.object_localization(image=vision_image)
+                # Draw boxes around detected objects
+                for obj in objects.localized_object_annotations:
+                    box = [(vertex.x * img.shape[1], vertex.y * img.shape[0])
+                          for vertex in obj.bounding_poly.normalized_vertices]
+                    box = np.array(box, np.int32).reshape((-1, 1, 2))
+                    cv2.polylines(img, [box], True, (0, 255, 0), 2)
+                    # Add label
+                    cv2.putText(img, f"{obj.name}: {int(obj.score * 100)}%", 
+                               (int(box[0][0][0]), int(box[0][0][1]) - 10),
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+            
+            if "Face Detection" in self.analysis_types:
+                faces = client.face_detection(image=vision_image)
+                for face in faces.face_annotations:
+                    vertices = face.bounding_poly.vertices
+                    points = [(vertex.x, vertex.y) for vertex in vertices]
+                    # Draw face box
+                    pts = np.array(points, np.int32).reshape((-1, 1, 2))
+                    cv2.polylines(img, [pts], True, (0, 0, 255), 2)
+                    
+                    # Draw landmarks
+                    for landmark in face.landmarks:
+                        px = int(landmark.position.x)
+                        py = int(landmark.position.y)
+                        cv2.circle(img, (px, py), 2, (255, 255, 0), -1)
+            
+            if "Text" in self.analysis_types:
+                text = client.text_detection(image=vision_image)
+                for text_annot in text.text_annotations[1:]:  # Skip the first one (full text)
+                    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(img, [pts], True, (255, 0, 0), 1)
+                    
+        except Exception as e:
+            # Log error but don't crash the stream
+            print(f"Error analyzing frame: {str(e)}")
+            
+        return av.VideoFrame.from_ndarray(img, format="bgr24")
+
+def analyze_document(file_content, processor_id, location="us"):
+    """Analyze document using Document AI"""
+    # Create Document AI client
+    client = documentai.DocumentProcessorServiceClient(credentials=credentials)
+    
+    # The full resource name of the processor
+    name = f"projects/{credentials.project_id}/locations/{location}/processors/{processor_id}"
+    
+    # Create document object
+    document = documentai.Document(
+        content=file_content,
+        mime_type="application/pdf"  # Adjust based on input type
+    )
+    
+    # Configure the process request
+    request = documentai.ProcessRequest(
+        name=name,
+        document=document
+    )
+    
+    # Process the document
+    result = client.process_document(request=request)
+    document = result.document
+    
+    # Extract text, entities, etc.
+    text = document.text
+    entities = {}
+    
+    # Extract entities and their values
+    for entity in document.entities:
+        entities[entity.type_] = entity.mention_text
+    
+    # Extract table data if available
+    tables = []
+    for page in document.pages:
+        for table in page.tables:
+            table_data = []
+            # Get header row
+            headers = []
+            for cell in table.header_rows[0].cells:
+                headers.append(text[cell.layout.text_anchor.text_segments[0].start_index:
+                                   cell.layout.text_anchor.text_segments[0].end_index])
+            
+            # Get data rows
+            for row in table.body_rows:
+                row_data = []
+                for cell in row.cells:
+                    if len(cell.layout.text_anchor.text_segments) > 0:
+                        cell_text = text[cell.layout.text_anchor.text_segments[0].start_index:
+                                       cell.layout.text_anchor.text_segments[0].end_index]
+                        row_data.append(cell_text)
+                    else:
+                        row_data.append("")
+                table_data.append(row_data)
+            
+            tables.append({"headers": headers, "data": table_data})
+    
+    return text, entities, tables
+
+def create_bigquery_table(dataset_id, table_id, schema=None):
+    """Create a BigQuery table if it doesn't exist"""
+    # Create client
+    bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
+    
+    # Create dataset if it doesn't exist
+    dataset_ref = bq_client.dataset(dataset_id)
+    try:
+        bq_client.get_dataset(dataset_ref)
+    except NotFound:
+        dataset = bigquery.Dataset(dataset_ref)
+        dataset.location = "US"
+        bq_client.create_dataset(dataset)
+        st.info(f"Dataset '{dataset_id}' created.")
+    
+    # Create table reference
+    table_ref = dataset_ref.table(table_id)
+    
+    # Check if table exists
+    try:
+        bq_client.get_table(table_ref)
+        st.info(f"Table '{table_id}' already exists.")
+        return table_ref
+    except NotFound:
+        # Create the table with schema if provided
+        if schema:
+            table = bigquery.Table(table_ref, schema=schema)
+        else:
+            table = bigquery.Table(table_ref)
+        
+        bq_client.create_table(table)
+        st.info(f"Table '{table_id}' created.")
+        return table_ref
+
+def upload_csv_to_bigquery(file, dataset_id, table_id, append=False):
+    """Upload a CSV file to BigQuery"""
+    # Create client
+    bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
+    
+    # Create a temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as temp_file:
+        temp_file.write(file.getvalue())
+        temp_file_path = temp_file.name
+    
+    # Configure the load job
+    job_config = bigquery.LoadJobConfig(
+        source_format=bigquery.SourceFormat.CSV,
+        skip_leading_rows=1,  # Skip header row
+        autodetect=True,  # Auto-detect schema
+    )
+    
+    if append:
+        job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND
+    else:
+        job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
+    
+    # Create table reference
+    dataset_ref = bq_client.dataset(dataset_id)
+    table_ref = dataset_ref.table(table_id)
+    
+    # Load the file
+    with open(temp_file_path, "rb") as source_file:
+        job = bq_client.load_table_from_file(
+            source_file, table_ref, job_config=job_config
+        )
+    
+    # Wait for the job to complete
+    job.result()
+    
+    # Clean up the temp file
+    os.unlink(temp_file_path)
+    
+    # Get the table
+    table = bq_client.get_table(table_ref)
+    
+    return {
+        "num_rows": table.num_rows,
+        "size_bytes": table.num_bytes,
+        "schema": [field.name for field in table.schema]
+    }
+
+def run_bigquery(query):
+    """Run a BigQuery query and return results"""
+    # Create client
+    bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
+    
+    # Run the query
+    query_job = bq_client.query(query)
+    
+    # Wait for the query to finish
+    results = query_job.result()
+    
+    # Convert to dataframe
+    df = results.to_dataframe()
+    
+    return df
+
 def main():
     # Header
-    st.markdown('<div class="main-header">Google Cloud Vision AI Analyzer</div>', unsafe_allow_html=True)
+    st.markdown('<div class="main-header">Google Cloud AI Analyzer</div>', unsafe_allow_html=True)
     
     # Navigation
     selected = option_menu(
         menu_title=None,
-        options=["Image Analysis", "About"],
-        icons=["image", "info-circle"],
+        options=["Image Analysis", "Video Analysis", "Document Analysis", "Data Analysis", "About"],
+        icons=["image", "camera-video", "file-text", "bar-chart", "info-circle"],
         menu_icon="cast",
         default_index=0,
         orientation="horizontal",
@@ -241,21 +478,393 @@ def main():
                             mime="image/png"
                         )
     
+    elif selected == "Video Analysis":
+        st.markdown('<div class="subheader">Real-Time Video Analysis</div>', unsafe_allow_html=True)
+        
+        # Analysis settings
+        st.sidebar.markdown("### Video Analysis Settings")
+        analysis_types = []
+        if st.sidebar.checkbox("Object Detection", value=True):
+            analysis_types.append("Objects")
+        if st.sidebar.checkbox("Face Detection"):
+            analysis_types.append("Face Detection")
+        if st.sidebar.checkbox("Text Recognition"):
+            analysis_types.append("Text")
+            
+        st.sidebar.markdown("---")
+        st.sidebar.warning("⚠️ Real-time analysis may use a significant amount of API calls. Use responsibly.")
+        
+        # Configure WebRTC
+        rtc_configuration = RTCConfiguration(
+            {"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]}
+        )
+        
+        # Display instructions
+        st.markdown("""
+        #### 📹 Real-Time Camera Analysis
+        
+        This feature analyzes your camera feed in real-time using Google Cloud Vision AI.
+        
+        **Instructions:**
+        1. Select the analysis types in the sidebar
+        2. Click the "START" button below to begin
+        3. Allow camera access when prompted
+        4. The app will analyze every few frames to reduce API usage
+        """)
+        
+        # Start WebRTC streamer
+        if analysis_types:
+            webrtc_ctx = webrtc_streamer(
+                key="vision-analyzer",
+                video_processor_factory=lambda: VideoProcessor(analysis_types),
+                rtc_configuration=rtc_configuration,
+                media_stream_constraints={
+                    "video": True,
+                    "audio": False
+                },
+            )
+        else:
+            st.warning("Please select at least one analysis type from the sidebar.")
+    
+    elif selected == "Document Analysis":
+        st.markdown('<div class="subheader">Document Processing & Analysis</div>', unsafe_allow_html=True)
+        
+        # Sidebar controls for document analysis
+        with st.sidebar:
+            st.markdown("### Document Analysis Settings")
+            
+            # Select document processor type
+            processor_type = st.selectbox(
+                "Select Document Type",
+                ["General Document", "Form Parser", "Invoice Parser", "Receipt Parser", "ID Document"]
+            )
+            
+            # Mapping of processor types to processor IDs (you would need to create these in GCP)
+            processor_mapping = {
+                "General Document": "your-general-processor-id",
+                "Form Parser": "your-form-processor-id",
+                "Invoice Parser": "your-invoice-processor-id",
+                "Receipt Parser": "your-receipt-processor-id",
+                "ID Document": "your-id-processor-id"
+            }
+            
+            st.markdown("---")
+            st.info("Upload a document to extract information using Google Document AI.")
+        
+        # Main content
+        uploaded_file = st.file_uploader(
+            "Upload a document (PDF, TIFF, JPG, PNG)", 
+            type=["pdf", "tiff", "jpg", "jpeg", "png"]
+        )
+        
+        if uploaded_file is not None:
+            # Display file details
+            file_details = {
+                "Filename": uploaded_file.name,
+                "File size": f"{uploaded_file.size / 1024:.2f} KB",
+                "File type": uploaded_file.type
+            }
+            st.write("### File Details")
+            for key, value in file_details.items():
+                st.write(f"**{key}:** {value}")
+            
+            # If it's an image file, display it
+            if uploaded_file.type.startswith('image/'):
+                st.image(uploaded_file, caption="Uploaded Document", use_column_width=True)
+            else:
+                st.info("PDF document uploaded (preview not available)")
+            
+            # Process button
+            if st.button("Process Document"):
+                with st.spinner("Processing document..."):
+                    # Get processor ID based on selection
+                    processor_id = processor_mapping[processor_type]
+                    
+                    # Get file content
+                    file_content = uploaded_file.getvalue()
+                    
+                    # Process document
+                    try:
+                        text, entities, tables = analyze_document(file_content, processor_id)
+                        
+                        # Display results
+                        st.markdown("### Document Analysis Results")
+                        
+                        # Show extracted information in tabs
+                        tab1, tab2, tab3 = st.tabs(["Text", "Extracted Fields", "Tables"])
+                        
+                        with tab1:
+                            st.markdown("#### Extracted Text")
+                            st.markdown('<div class="result-container">', unsafe_allow_html=True)
+                            st.write(text)
+                            st.markdown('</div>', unsafe_allow_html=True)
+                        
+                        with tab2:
+                            st.markdown("#### Extracted Fields")
+                            st.markdown('<div class="result-container">', unsafe_allow_html=True)
+                            if entities:
+                                for entity_type, value in entities.items():
+                                    st.markdown(f"**{entity_type}:** {value}")
+                            else:
+                                st.info("No fields extracted from this document.")
+                            st.markdown('</div>', unsafe_allow_html=True)
+                        
+                        with tab3:
+                            st.markdown("#### Extracted Tables")
+                            if tables:
+                                for i, table in enumerate(tables):
+                                    st.markdown(f"**Table {i+1}**")
+                                    df = pd.DataFrame(table["data"], columns=table["headers"])
+                                    st.dataframe(df)
+                            else:
+                                st.info("No tables found in this document.")
+                    
+                    except Exception as e:
+                        st.error(f"Error processing document: {str(e)}")
+    
+    elif selected == "Data Analysis":
+        st.markdown('<div class="subheader">BigQuery CSV Data Analysis</div>', unsafe_allow_html=True)
+        
+        # Sidebar controls for BigQuery
+        with st.sidebar:
+            st.markdown("### BigQuery Settings")
+            
+            # Dataset and table settings
+            dataset_id = st.text_input("Dataset ID", "my_dataset")
+            table_id = st.text_input("Table ID", "my_table")
+            
+            # Upload options
+            replace_data = st.radio(
+                "Upload Mode:",
+                ["Replace existing data", "Append to existing data"]
+            )
+            
+            st.markdown("---")
+            st.info("Upload a CSV file to analyze with BigQuery.")
+        
+        # Tabs for different actions
+        upload_tab, query_tab, visualization_tab = st.tabs(["Upload Data", "Query Data", "Visualize Data"])
+        
+        with upload_tab:
+            st.markdown("### Upload CSV File to BigQuery")
+            uploaded_file = st.file_uploader("Choose a CSV file", type=["csv"])
+            
+            if uploaded_file is not None:
+                # Preview the data
+                try:
+                    df_preview = pd.read_csv(uploaded_file)
+                    st.write("### Data Preview")
+                    st.dataframe(df_preview.head())
+                    
+                    # Display file details
+                    st.write(f"**Rows:** {len(df_preview)}")
+                    st.write(f"**Columns:** {len(df_preview.columns)}")
+                    st.write("**Column Types:**")
+                    st.write(df_preview.dtypes)
+                    
+                    # Reset file pointer
+                    uploaded_file.seek(0)
+                    
+                    # Upload button
+                    if st.button("Upload to BigQuery"):
+                        with st.spinner("Uploading to BigQuery..."):
+                            # Upload the file
+                            append_mode = replace_data == "Append to existing data"
+                            result = upload_csv_to_bigquery(uploaded_file, dataset_id, table_id, append=append_mode)
+                            
+                            # Show results
+                            st.success(f"Data uploaded successfully to {dataset_id}.{table_id}")
+                            st.write(f"**Rows loaded:** {result['num_rows']}")
+                            st.write(f"**Size:** {result['size_bytes']/1024/1024:.2f} MB")
+                            st.write(f"**Schema:** {', '.join(result['schema'])}")
+                            
+                            # Store table info in session state for querying
+                            st.session_state["table_info"] = {
+                                "dataset_id": dataset_id,
+                                "table_id": table_id,
+                                "schema": result["schema"]
+                            }
+                            
+                except Exception as e:
+                    st.error(f"Error processing CSV: {str(e)}")
+        
+        with query_tab:
+            st.markdown("### Query Your Data with BigQuery")
+            
+            # Check if table info exists in session state
+            if "table_info" in st.session_state:
+                table_info = st.session_state["table_info"]
+                st.info(f"Currently working with table: {table_info['dataset_id']}.{table_info['table_id']}")
+                
+                # Create a default query
+                default_query = f"SELECT * FROM `{credentials.project_id}.{table_info['dataset_id']}.{table_info['table_id']}` LIMIT 100"
+                
+                # Query editor
+                query = st.text_area("SQL Query", default_query, height=150)
+                
+                # Example queries
+                with st.expander("Example Queries"):
+                    st.markdown("""
+                    #### Example Queries:
+                    
+                    1. **Get all data:**
+                       ```sql
+                       SELECT * FROM `{project}.{dataset}.{table}` LIMIT 1000
+                       ```
+                       
+                    2. **Count rows:**
+                       ```sql
+                       SELECT COUNT(*) as count FROM `{project}.{dataset}.{table}`
+                       ```
+                       
+                    3. **Get summary statistics:**
+                       ```sql
+                       SELECT 
+                         MIN({numeric_column}) as min_value,
+                         MAX({numeric_column}) as max_value,
+                         AVG({numeric_column}) as avg_value,
+                         STDDEV({numeric_column}) as stddev_value
+                       FROM `{project}.{dataset}.{table}`
+                       ```
+                       
+                    4. **Group by and count:**
+                       ```sql
+                       SELECT 
+                         {category_column}, 
+                         COUNT(*) as count
+                       FROM `{project}.{dataset}.{table}`
+                       GROUP BY {category_column}
+                       ORDER BY count DESC
+                       LIMIT 10
+                       ```
+                    """.replace("{project}", credentials.project_id)
+                       .replace("{dataset}", table_info['dataset_id'])
+                       .replace("{table}", table_info['table_id'])
+                       .replace("{numeric_column}", table_info['schema'][0])
+                       .replace("{category_column}", table_info['schema'][0]))
+                
+                # Execute query button
+                if st.button("Run Query"):
+                    with st.spinner("Running query..."):
+                        try:
+                            # Run the query
+                            df_result = run_bigquery(query)
+                            
+                            # Show results
+                            if not df_result.empty:
+                                st.write("### Query Results")
+                                st.dataframe(df_result)
+                                
+                                # Store results for visualization
+                                st.session_state["query_results"] = df_result
+                                
+                                # Download button
+                                csv = df_result.to_csv(index=False)
+                                st.download_button(
+                                    label="Download Results as CSV",
+                                    data=csv,
+                                    file_name="query_results.csv",
+                                    mime="text/csv"
+                                )
+                            else:
+                                st.info("Query returned no results.")
+                        except Exception as e:
+                            st.error(f"Error running query: {str(e)}")
+            else:
+                st.warning("Please upload a CSV file in the 'Upload Data' tab first.")
+        
+        with visualization_tab:
+            st.markdown("### Visualize Your Query Results")
+            
+            if "query_results" in st.session_state and not st.session_state["query_results"].empty:
+                df = st.session_state["query_results"]
+                
+                # Chart type selector
+                chart_type = st.selectbox(
+                    "Select Chart Type",
+                    ["Bar Chart", "Line Chart", "Scatter Plot", "Histogram", "Pie Chart"]
+                )
+                
+                # Column selectors based on chart type
+                if chart_type in ["Bar Chart", "Line Chart", "Scatter Plot"]:
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        x_col = st.selectbox("X-axis", df.columns.tolist())
+                    with col2:
+                        y_col = st.selectbox("Y-axis", [c for c in df.columns.tolist() if c != x_col])
+                
+                elif chart_type == "Histogram":
+                    numeric_cols = df.select_dtypes(include=['int64', 'float64']).columns.tolist()
+                    if numeric_cols:
+                        hist_col = st.selectbox("Column", numeric_cols)
+                    else:
+                        st.warning("No numeric columns available for histogram.")
+                        hist_col = None
+                
+                elif chart_type == "Pie Chart":
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        label_col = st.selectbox("Labels", df.columns.tolist())
+                    with col2:
+                        value_cols = df.select_dtypes(include=['int64', 'float64']).columns.tolist()
+                        if value_cols:
+                            value_col = st.selectbox("Values", value_cols)
+                        else:
+                            st.warning("No numeric columns available for values.")
+                            value_col = None
+                
+                # Generate the selected chart
+                st.write("### Data Visualization")
+                
+                if chart_type == "Bar Chart" and x_col and y_col:
+                    st.bar_chart(df.set_index(x_col)[y_col])
+                
+                elif chart_type == "Line Chart" and x_col and y_col:
+                    st.line_chart(df.set_index(x_col)[y_col])
+                
+                elif chart_type == "Scatter Plot" and x_col and y_col:
+                    st.write(f"Scatter Plot: {x_col} vs {y_col}")
+                    fig, ax = plt.subplots()
+                    ax.scatter(df[x_col], df[y_col])
+                    ax.set_xlabel(x_col)
+                    ax.set_ylabel(y_col)
+                    st.pyplot(fig)
+                
+                elif chart_type == "Histogram" and hist_col:
+                    st.write(f"Histogram of {hist_col}")
+                    fig, ax = plt.subplots()
+                    ax.hist(df[hist_col].dropna(), bins=20)
+                    ax.set_xlabel(hist_col)
+                    ax.set_ylabel("Frequency")
+                    st.pyplot(fig)
+                
+                elif chart_type == "Pie Chart" and label_col and value_col:
+                    st.write(f"Pie Chart: {value_col} by {label_col}")
+                    # Limit to top 10 categories for pie chart clarity
+                    top_data = df.groupby(label_col)[value_col].sum().nlargest(10).reset_index()
+                    fig, ax = plt.subplots()
+                    ax.pie(top_data[value_col], labels=top_data[label_col], autopct='%1.1f%%')
+                    ax.axis('equal')
+                    st.pyplot(fig)
+            else:
+                st.warning("Please run a query in the 'Query Data' tab first.")
+    
     elif selected == "About":
         st.markdown("## About This App")
         st.write("""
-        This application uses Google Cloud Vision AI to analyze images. It can:
+        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
+        2. Upload an image or use your camera
         3. Select the types of analysis you want to perform
-        4. Click "Analyze Image"
+        4. Click "Analyze Image" or start the video stream
         
         The app is built with Streamlit and Google Cloud Vision API.
         """)