Create app.py

app.py

@@ -0,0 +1,269 @@
+import streamlit as st
+from google.cloud import vision
+import os
+from PIL import Image, ImageDraw
+import io
+import numpy as np
+from streamlit_option_menu import option_menu
+
+# Set page config
+st.set_page_config(
+    page_title="Vision AI Analyzer",
+    page_icon="👁️",
+    layout="wide"
+)
+
+# Set your Google Cloud credentials
+os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = 'path/to/your/credentials.json'
+
+# Initialize the Vision AI client
+client = vision.ImageAnnotatorClient()
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #4285F4;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .subheader {
+        font-size: 1.5rem;
+        color: #34A853;
+        margin-top: 1.5rem;
+    }
+    .result-container {
+        background-color: #f8f9fa;
+        border-radius: 10px;
+        padding: 15px;
+        margin-top: 10px;
+    }
+    .label-item {
+        padding: 5px;
+        margin: 2px 0;
+        border-radius: 4px;
+        background-color: #e9f5e9;
+    }
+    .object-item {
+        padding: 5px;
+        margin: 2px 0;
+        border-radius: 4px;
+        background-color: #e9ecf5;
+    }
+    .text-item {
+        padding: 5px;
+        margin: 2px 0;
+        border-radius: 4px;
+        background-color: #f5eee9;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def analyze_image(image, analysis_types):
+    """Analyze image with selected analysis types"""
+    # Convert uploaded image to bytes
+    if image is None:
+        return None, {}, {}, ""
+    
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='PNG')
+    content = img_byte_arr.getvalue()
+
+    # Create vision image object
+    vision_image = vision.Image(content=content)
+
+    # Perform detection based on selected types
+    labels_data = {}
+    objects_data = {}
+    text_content = ""
+    
+    img_with_boxes = image.copy()
+    draw = ImageDraw.Draw(img_with_boxes)
+    
+    if "Labels" in analysis_types:
+        labels = client.label_detection(image=vision_image)
+        labels_data = {label.description: round(label.score * 100) 
+                      for label in labels.label_annotations}
+    
+    if "Objects" in analysis_types:
+        objects = client.object_localization(image=vision_image)
+        objects_data = {obj.name: round(obj.score * 100) 
+                       for obj in objects.localized_object_annotations}
+        
+        # Draw object boundaries
+        for obj in objects.localized_object_annotations:
+            box = [(vertex.x * image.width, vertex.y * image.height)
+                  for vertex in obj.bounding_poly.normalized_vertices]
+            draw.polygon(box, outline='red', width=2)
+            draw.text((box[0][0], box[0][1] - 10),
+                     f"{obj.name}: {int(obj.score * 100)}%",
+                     fill='red')
+    
+    if "Text" in analysis_types:
+        text = client.text_detection(image=vision_image)
+        if text.text_annotations:
+            text_content = text.text_annotations[0].description
+            
+            # 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]
+                draw.polygon(box, outline='blue', width=1)
+
+    if "Face Detection" in analysis_types:
+        faces = client.face_detection(image=vision_image)
+        for face in faces.face_annotations:
+            vertices = face.bounding_poly.vertices
+            box = [(vertex.x, vertex.y) for vertex in vertices]
+            draw.polygon(box, outline='green', width=2)
+            
+            # Draw facial landmarks
+            for landmark in face.landmarks:
+                px = landmark.position.x
+                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
+
+def display_results(annotated_img, labels, objects, text):
+    """Display analysis results in a clean format"""
+    col1, col2 = st.columns([3, 2])
+    
+    with col1:
+        st.markdown('<div class="subheader">Analyzed Image</div>', unsafe_allow_html=True)
+        st.image(annotated_img, use_column_width=True)
+    
+    with col2:
+        st.markdown('<div class="subheader">Analysis Results</div>', unsafe_allow_html=True)
+        
+        # Labels tab
+        if labels:
+            st.markdown("##### 🏷️ Labels Detected")
+            st.markdown('<div class="result-container">', unsafe_allow_html=True)
+            for label, confidence in labels.items():
+                st.markdown(f'<div class="label-item">{label}: {confidence}%</div>', unsafe_allow_html=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Objects tab
+        if objects:
+            st.markdown("##### 📦 Objects Detected")
+            st.markdown('<div class="result-container">', unsafe_allow_html=True)
+            for obj, confidence in objects.items():
+                st.markdown(f'<div class="object-item">{obj}: {confidence}%</div>', unsafe_allow_html=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Text tab
+        if text:
+            st.markdown("##### 📝 Text Detected")
+            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)
+
+def main():
+    # Header
+    st.markdown('<div class="main-header">Google Cloud Vision AI Analyzer</div>', unsafe_allow_html=True)
+    
+    # Navigation
+    selected = option_menu(
+        menu_title=None,
+        options=["Image Analysis", "About"],
+        icons=["image", "info-circle"],
+        menu_icon="cast",
+        default_index=0,
+        orientation="horizontal",
+    )
+    
+    if selected == "Image Analysis":
+        # Sidebar controls
+        with st.sidebar:
+            st.markdown("### Analysis Settings")
+            
+            # Analysis types selection
+            st.write("Choose analysis types:")
+            analysis_types = []
+            
+            if st.checkbox("Label Detection", value=True):
+                analysis_types.append("Labels")
+            
+            if st.checkbox("Object Detection", value=True):
+                analysis_types.append("Objects")
+            
+            if st.checkbox("Text Recognition", value=True):
+                analysis_types.append("Text")
+            
+            if st.checkbox("Face Detection"):
+                analysis_types.append("Face Detection")
+            
+            st.markdown("---")
+            
+            # Image quality settings
+            st.write("Image settings:")
+            quality = st.slider("Image Quality", min_value=0, max_value=100, value=100)
+            
+            st.markdown("---")
+            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)
+            
+            # 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"
+                        )
+    
+    elif selected == "About":
+        st.markdown("## About This App")
+        st.write("""
+        This application uses Google Cloud Vision AI to analyze images. It can:
+        
+        - **Detect labels** in images
+        - **Identify objects** and their locations
+        - **Extract text** from images
+        - **Detect faces** and facial landmarks
+        
+        To use this app, you need to:
+        1. Set up Google Cloud Vision API credentials
+        2. Upload an image
+        3. Select the types of analysis you want to perform
+        4. Click "Analyze Image"
+        
+        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.")
+
+if __name__ == "__main__":
+    main()