Update app.py

app.py

@@ -162,11 +162,11 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
-def analyze_image(image, analysis_types):
-    """Analyze image with selected analysis types"""
+def analyze_image(image, analysis_types, confidence_threshold=0.5):
+    """Analyze image with selected analysis types and confidence filtering"""
     # Convert uploaded image to bytes
     if image is None:
-        return None, {}, {}, ""
+        return None, {}, {}, "", {}
     
     img_byte_arr = io.BytesIO()
     image.save(img_byte_arr, format='PNG')
@@ -179,22 +179,42 @@ def analyze_image(image, analysis_types):
     labels_data = {}
     objects_data = {}
     text_content = ""
+    colors_data = {}  # New: store dominant colors
+    text_language = "" # New: store detected language
     
     img_with_boxes = image.copy()
     draw = ImageDraw.Draw(img_with_boxes)
     
+    # Extract color information regardless of analysis types
+    if "Visual Attributes" in analysis_types:
+        image_properties = client.image_properties(image=vision_image).image_properties_annotation
+        # Get top 5 dominant colors with scores
+        colors_data = {
+            f"Color #{i+1}": {
+                "rgb": (int(color.color.red), int(color.color.green), int(color.color.blue)),
+                "score": round(color.score * 100, 2),
+                "pixel_fraction": round(color.pixel_fraction * 100, 2)
+            } for i, color in enumerate(image_properties.dominant_colors.colors[:5])
+        }
+    
     if "Labels" in analysis_types:
         labels = client.label_detection(image=vision_image)
+        # Apply confidence threshold
         labels_data = {label.description: round(label.score * 100) 
-                      for label in labels.label_annotations}
+                      for label in labels.label_annotations 
+                      if label.score >= confidence_threshold}
     
     if "Objects" in analysis_types:
         objects = client.object_localization(image=vision_image)
+        # Apply confidence threshold
+        filtered_objects = [obj for obj in objects.localized_object_annotations 
+                           if obj.score >= confidence_threshold]
+        
         objects_data = {obj.name: round(obj.score * 100) 
-                       for obj in objects.localized_object_annotations}
+                       for obj in filtered_objects}
         
         # Draw object boundaries
-        for obj in objects.localized_object_annotations:
+        for obj in filtered_objects:
             box = [(vertex.x * image.width, vertex.y * image.height)
                   for vertex in obj.bounding_poly.normalized_vertices]
             draw.polygon(box, outline='red', width=2)
@@ -207,6 +227,23 @@ def analyze_image(image, analysis_types):
         if text.text_annotations:
             text_content = text.text_annotations[0].description
             
+            # New: Detect language if text is found
+            if text_content:
+                try:
+                    # Get language of text
+                    document = vision.types.Document(
+                        content=content,
+                        type_=vision.types.Document.Type.GENERAL_DOCUMENT
+                    )
+                    response = client.document_text_detection(image=vision_image)
+                    if response.text_annotations:
+                        # Get the language code from the first page
+                        if response.pages and response.pages[0].property.detected_languages:
+                            lang = response.pages[0].property.detected_languages[0]
+                            text_language = f"{lang.language_code} ({round(lang.confidence * 100)}%)"
+                except Exception as e:
+                    text_language = "Detection failed"
+            
             # Draw text boundaries
             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]
@@ -214,7 +251,11 @@ def analyze_image(image, analysis_types):
 
     if "Face Detection" in analysis_types:
         faces = client.face_detection(image=vision_image)
-        for face in faces.face_annotations:
+        # Apply confidence threshold - filter by detection confidence
+        filtered_faces = [face for face in faces.face_annotations 
+                         if face.detection_confidence >= confidence_threshold]
+        
+        for face in filtered_faces:
             vertices = face.bounding_poly.vertices
             box = [(vertex.x, vertex.y) for vertex in vertices]
             draw.polygon(box, outline='green', width=2)
@@ -225,15 +266,18 @@ def analyze_image(image, analysis_types):
                 py = landmark.position.y
                 draw.ellipse((px-2, py-2, px+2, py+2), fill='yellow')
 
-    return img_with_boxes, labels_data, objects_data, text_content
+    # Return extended results
+    return img_with_boxes, labels_data, objects_data, text_content, colors_data, text_language
 
-def display_results(annotated_img, labels, objects, text):
-    """Display analysis results in a clean format"""
+def display_results(annotated_img, labels, objects, text, colors=None, text_language=None):
+    """Display analysis results in a clean format with enhanced features"""
     # Store results in session state for chatbot context
     st.session_state.analysis_results = {
         "labels": labels,
         "objects": objects,
         "text": text,
+        "colors": colors if colors else {},
+        "text_language": text_language if text_language else "",
         "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
     }
     
@@ -268,12 +312,37 @@ def display_results(annotated_img, labels, objects, text):
         # Text tab
         if text:
             st.markdown("##### 📝 Text Detected")
+            if text_language:
+                st.markdown(f"**Detected Language:** {text_language}")
             st.markdown('<div class="result-container">', unsafe_allow_html=True)
             st.markdown(f'<div class="text-item">{text}</div>', unsafe_allow_html=True)
             st.markdown('</div>', unsafe_allow_html=True)
+            
+        # Color analysis tab (new)
+        if colors:
+            st.markdown("##### 🎨 Dominant Colors")
+            st.markdown('<div class="result-container">', unsafe_allow_html=True)
+            
+            # Create color swatches
+            for color_name, color_data in colors.items():
+                rgb = color_data["rgb"]
+                hex_color = f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
+                
+                # Display color swatch with info
+                st.markdown(f"""
+                <div style="display:flex; align-items:center; margin-bottom:10px;">
+                    <div style="background-color:{hex_color}; width:50px; height:30px; margin-right:15px; border:1px solid #ddd;"></div>
+                    <div>
+                        <strong>{color_name}</strong>: {color_data["score"]}% coverage<br>
+                        RGB: {rgb}
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            st.markdown('</div>', unsafe_allow_html=True)
     
     # Add Download Summary Image button
-    summary_img = create_summary_image(annotated_img, labels, objects, text)
+    summary_img = create_summary_image(annotated_img, labels, objects, text, colors)
     buf = io.BytesIO()
     summary_img.save(buf, format="JPEG", quality=90)
     byte_im = buf.getvalue()
@@ -286,7 +355,7 @@ def display_results(annotated_img, labels, objects, text):
         help="Download a complete image showing the analyzed image and all detected features"
     )
 
-def create_summary_image(annotated_img, labels, objects, text):
+def create_summary_image(annotated_img, labels, objects, text, colors=None):
     """Create a downloadable summary image with analysis results"""
     # Create a new image with space for results
     img_width, img_height = annotated_img.size
@@ -690,7 +759,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 and slow down output for better visibility"""
+    """Process an uploaded video file with enhanced Vision AI detection and analytics"""
     # 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())
@@ -743,14 +812,22 @@ def process_video_file(video_file, analysis_types):
     progress_bar = st.progress(0)
     status_text = st.empty()
     
-    # Statistics tracking for summary
+    # Enhanced statistics tracking
     detection_stats = {
         "objects": {},
         "faces": 0,
         "text_blocks": 0,
-        "labels": {}
+        "labels": {},
+        # New advanced tracking
+        "object_tracking": {},  # Track object appearances by frame
+        "activity_metrics": [],  # Track frame-to-frame differences
+        "scene_changes": []     # Track major scene transitions
     }
     
+    # For scene change detection
+    previous_frame_gray = None
+    scene_change_threshold = 40.0  # Threshold for scene change detection
+    
     try:
         frame_count = 0
         while frame_count < max_frames:  # Limit to 10 seconds
@@ -769,7 +846,26 @@ def process_video_file(video_file, analysis_types):
             cv2.putText(frame, f"Time: {frame_count/fps:.2f}s", 
                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
             
-            # Process frames with Vision API (more frequently for detail)
+            # Activity detection and scene change detection
+            current_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            current_frame_gray = cv2.GaussianBlur(current_frame_gray, (21, 21), 0)
+                
+            if previous_frame_gray is not None:
+                # Calculate frame difference for activity detection
+                frame_diff = cv2.absdiff(current_frame_gray, previous_frame_gray)
+                activity_level = np.mean(frame_diff)
+                detection_stats["activity_metrics"].append((frame_count/fps, activity_level))
+                
+                # Scene change detection
+                if activity_level > scene_change_threshold:
+                    detection_stats["scene_changes"].append(frame_count/fps)
+                    # Mark scene change on frame
+                    cv2.putText(frame, "SCENE CHANGE", 
+                              (width // 2 - 100, 50), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 255), 2)
+            
+            previous_frame_gray = current_frame_gray
+            
+            # Process frames with Vision API
             if frame_count % process_every_n_frames == 0:
                 try:
                     # Convert OpenCV frame to PIL Image for Vision API
@@ -786,12 +882,28 @@ def process_video_file(video_file, analysis_types):
                         objects = client.object_localization(image=vision_image)
                         # Draw boxes around detected objects with enhanced info
                         for obj in objects.localized_object_annotations:
-                            # Track statistics
-                            if obj.name in detection_stats["objects"]:
-                                detection_stats["objects"][obj.name] += 1
+                            obj_name = obj.name
+                            # Update basic stats
+                            if obj_name in detection_stats["objects"]:
+                                detection_stats["objects"][obj_name] += 1
                             else:
-                                detection_stats["objects"][obj.name] = 1
+                                detection_stats["objects"][obj_name] = 1
                                 
+                            # Enhanced object tracking
+                            timestamp = frame_count/fps
+                            if obj_name not in detection_stats["object_tracking"]:
+                                detection_stats["object_tracking"][obj_name] = {
+                                    "first_seen": timestamp,
+                                    "last_seen": timestamp,
+                                    "frames_present": 1,
+                                    "timestamps": [timestamp]
+                                }
+                            else:
+                                tracking = detection_stats["object_tracking"][obj_name]
+                                tracking["frames_present"] += 1
+                                tracking["last_seen"] = timestamp
+                                tracking["timestamps"].append(timestamp)
+                            
                             # Calculate box coordinates
                             box = [(vertex.x * frame.shape[1], vertex.y * frame.shape[0])
                                   for vertex in obj.bounding_poly.normalized_vertices]
@@ -932,7 +1044,15 @@ def process_video_file(video_file, analysis_types):
         os.unlink(temp_video_path)
         os.unlink(output_path)
         
-        # Return both the video and the detection statistics
+        # Calculate additional statistics
+        for obj_name, tracking in detection_stats["object_tracking"].items():
+            # Calculate total screen time
+            tracking["screen_time"] = round(tracking["frames_present"] * (1/fps) * process_every_n_frames, 2)
+            # Calculate average confidence if available
+            if "confidences" in tracking and tracking["confidences"]:
+                tracking["avg_confidence"] = sum(tracking["confidences"]) / len(tracking["confidences"])
+        
+        # Return enhanced results
         results = {"detection_stats": detection_stats}
         
         # Store results in session state for chatbot context
@@ -1457,12 +1577,28 @@ def main():
             if st.checkbox("Face Detection"):
                 analysis_types.append("Face Detection")
             
+            # New enhanced analysis options
+            if st.checkbox("Visual Attributes (Colors)", value=False):
+                analysis_types.append("Visual Attributes")
+            
             st.markdown("---")
             
+            # Confidence threshold control
+            confidence_threshold = st.slider("Detection Confidence Threshold", 
+                                          min_value=0.0, max_value=1.0, value=0.5,
+                                          help="Filter results based on confidence level")
+            
             # Image quality settings
             st.write("Image settings:")
             quality = st.slider("Image Quality", min_value=0, max_value=100, value=100)
             
+            # Add a slider in the sidebar
+            confidence_threshold = st.sidebar.slider("Detection Confidence Threshold", 0.0, 1.0, 0.5)
+            
+            # Then filter results based on this threshold
+            filtered_objects = [obj for obj in response.localized_object_annotations 
+                               if obj.score >= confidence_threshold]
+            
             st.markdown("---")
             st.info("This application analyzes images using Google Cloud Vision AI. Upload an image to get started.")
         
@@ -1492,10 +1628,10 @@ def main():
                     else:
                         with st.spinner("Analyzing image..."):
                             # Call analyze function
-                            annotated_img, labels, objects, text = analyze_image(image, analysis_types)
+                            annotated_img, labels, objects, text, colors, text_language = analyze_image(image, analysis_types)
                             
                             # Display results
-                            display_results(annotated_img, labels, objects, text)
+                            display_results(annotated_img, labels, objects, text, colors, text_language)
                             
                             # Add download button for the annotated image
                             buf = io.BytesIO()
@@ -1515,118 +1651,78 @@ def main():
             
             uploaded_files = st.file_uploader("Choose images...", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
             
-            if uploaded_files:
-                # Limit to 5 images
+            if uploaded_files and len(uploaded_files) > 0:
                 if len(uploaded_files) > 5:
-                    st.warning("Maximum 5 images allowed. Only the first 5 will be processed.")
+                    st.warning("You've uploaded more than 5 images. 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_container_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 = {}
+                if st.button("Process Batch"):
+                    st.write(f"Processing {len(uploaded_files)} images...")
+                    
+                    # Process each image with a unique key for each download button
+                    for i, uploaded_file in enumerate(uploaded_files):
+                        st.markdown(f"### Image {i+1}: {uploaded_file.name}")
                         
-                        # 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)
+                        # Open and process the image
+                        try:
+                            image = Image.open(uploaded_file)
+                            annotated_img, labels, objects, text, colors, text_language = analyze_image(
+                                image, analysis_types, confidence_threshold
+                            )
+                            
+                            # Create a unique identifier for this image
+                            image_id = f"{i}_{uploaded_file.name.replace(' ', '_')}"
+                            
+                            # Display results with unique download button keys
+                            col1, col2 = st.columns([3, 2])
+                            
+                            with col1:
+                                st.image(annotated_img, use_container_width=True)
+                            
+                            with col2:
+                                # Display analysis results
+                                if labels:
+                                    st.markdown("##### Labels Detected")
+                                    for label, confidence in labels.items():
+                                        st.write(f"{label}: {confidence}%")
                                 
-                                # 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
+                                if objects:
+                                    st.markdown("##### Objects Detected")
+                                    for obj, confidence in objects.items():
+                                        st.write(f"{obj}: {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
+                                if text:
+                                    st.markdown("##### Text Detected")
+                                    if text_language:
+                                        st.markdown(f"**Language:** {text_language}")
+                                    st.text(text)
                                 
-                                # 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)
-                        
-                        col1, col2 = st.columns(2)
-                        
-                        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)
+                                if colors:
+                                    st.markdown("##### Dominant Colors")
+                                    for color_name, color_data in colors.items():
+                                        rgb = color_data["rgb"]
+                                        hex_color = f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
+                                        st.markdown(f"<div style='background-color:{hex_color};width:50px;height:20px;display:inline-block;'></div> {color_name}: {color_data['score']}%", 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 summary image for download
+                            summary_img = create_summary_image(annotated_img, labels, objects, text, colors)
+                            buf = io.BytesIO()
+                            summary_img.save(buf, format="JPEG", quality=90)
+                            byte_im = buf.getvalue()
                             
-                            # 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)
+                            # Use unique key for each download button
+                            st.download_button(
+                                label=f"📥 Download Results for {uploaded_file.name}",
+                                data=byte_im,
+                                file_name=f"analysis_{image_id}.jpg",
+                                mime="image/jpeg",
+                                key=f"download_batch_{image_id}"  # Unique key for each image
+                            )
                             
-                            # 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)
+                            st.markdown("---")  # Add separator between images
+                            
+                        except Exception as e:
+                            st.error(f"Error processing {uploaded_file.name}: {str(e)}")
     
     elif selected == "Video Analysis":
         st.markdown('<div class="subheader">Video Analysis</div>', unsafe_allow_html=True)