commit

app.py

@@ -1,9 +1,11 @@
 import gradio as gr
 import os
-from PIL import Image
+from PIL import Image, ImageDraw, ImageFont
 import io
 import base64
 from openai import OpenAI
+import re
+import json
 
 def encode_image(image):
     """Convert PIL Image to base64 string for API"""
@@ -11,6 +13,69 @@ def encode_image(image):
     image.save(buffered, format="JPEG", quality=95)
     return base64.b64encode(buffered.getvalue()).decode('utf-8')
 
+def draw_annotations(image, annotations):
+    """
+    Draw numbered annotations on the image
+
+    Args:
+        image: PIL Image object
+        annotations: List of dicts with 'x', 'y', 'label' keys (coordinates are 0-1 normalized)
+
+    Returns:
+        PIL Image with annotations drawn
+    """
+    # Create a copy to avoid modifying original
+    img_copy = image.copy()
+    draw = ImageDraw.Draw(img_copy)
+
+    # Get image dimensions
+    width, height = img_copy.size
+
+    # Try to load a better font, fall back to default if not available
+    try:
+        font_size = max(20, min(width, height) // 40)
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
+    except:
+        font = ImageFont.load_default()
+
+    # Draw each annotation
+    for i, ann in enumerate(annotations, 1):
+        # Convert normalized coordinates to pixel coordinates
+        x = int(ann['x'] * width)
+        y = int(ann['y'] * height)
+
+        # Circle radius based on image size
+        radius = max(15, min(width, height) // 80)
+
+        # Draw outer circle (white border)
+        draw.ellipse(
+            [(x - radius - 2, y - radius - 2), (x + radius + 2, y + radius + 2)],
+            fill='white',
+            outline='white'
+        )
+
+        # Draw inner circle (red)
+        draw.ellipse(
+            [(x - radius, y - radius), (x + radius, y + radius)],
+            fill='red',
+            outline='white',
+            width=2
+        )
+
+        # Draw number
+        number_text = str(i)
+        # Get text bounding box for centering
+        bbox = draw.textbbox((0, 0), number_text, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+
+        # Draw text centered in circle
+        text_x = x - text_width // 2
+        text_y = y - text_height // 2
+        draw.text((text_x, text_y), number_text, fill='white', font=font)
+
+    return img_copy
+
 def analyze_satellite_image(image, geolocation, brief, analysis_mode, api_key):
     """
     Analyze satellite imagery using Meta Llama Vision via OpenRouter
@@ -74,14 +139,32 @@ Provide your analysis in a structured format covering:
         else:  # annotated mode
             instruction = f"""Analyze this satellite image and provide a professional intelligence assessment with annotations.{location_context}{brief_context}
 
-First, identify key features that should be annotated. Then provide:
-1. A detailed description of what annotations you would place (describe location, label, and significance of each)
+You MUST format your response in TWO sections:
+
+SECTION 1 - ANNOTATIONS (JSON):
+Provide a JSON array of annotation points. Each point should have:
+- "x": horizontal position (0.0 to 1.0, where 0.0 is left edge, 1.0 is right edge)
+- "y": vertical position (0.0 to 1.0, where 0.0 is top edge, 1.0 is bottom edge)
+- "label": brief description of the feature
+
+Start this section with exactly: ANNOTATIONS:
+Then provide valid JSON on the next line.
+
+Example format:
+ANNOTATIONS:
+[
+  {{"x": 0.25, "y": 0.35, "label": "Military installation"}},
+  {{"x": 0.75, "y": 0.60, "label": "Vehicle staging area"}}
+]
+
+SECTION 2 - ANALYSIS:
+Provide your detailed analysis referencing the numbered annotations (1, 2, 3, etc.) that will be drawn on the image:
+1. Key features identified (reference annotation numbers)
 2. Overview and general observations
-3. Key features and infrastructure identified
-4. Notable patterns or anomalies
-5. Assessment and implications (if relevant to the brief)
+3. Notable patterns or anomalies
+4. Assessment and implications (if relevant to the brief)
 
-Note: Describe the annotations you would make in text form, as you cannot directly draw on images. Be specific about locations (e.g., "top-left quadrant", "center-right", using approximate coordinates or descriptive positions)."""
+Remember: The annotations will be numbered automatically in the order you list them."""
 
         # Encode image
         image_data = encode_image(image)
@@ -116,10 +199,47 @@ Note: Describe the annotations you would make in text form, as you cannot direct
 
         analysis_text = response.choices[0].message.content
 
-        # For annotated mode, return both text and original image
-        # (Future enhancement: could add actual annotation drawing)
+        # For annotated mode, parse annotations and draw on image
         if analysis_mode == "annotated":
-            return analysis_text, image
+            try:
+                # Extract annotations JSON from response
+                annotations = []
+                annotated_image = image
+
+                # Look for ANNOTATIONS: section
+                if "ANNOTATIONS:" in analysis_text:
+                    # Extract the JSON part
+                    parts = analysis_text.split("ANNOTATIONS:")
+                    if len(parts) > 1:
+                        json_part = parts[1].split("SECTION 2")[0].strip()
+                        # Also try splitting by "ANALYSIS:" if SECTION 2 not found
+                        if "ANALYSIS:" in json_part:
+                            json_part = json_part.split("ANALYSIS:")[0].strip()
+
+                        # Try to extract JSON array
+                        json_match = re.search(r'\[.*?\]', json_part, re.DOTALL)
+                        if json_match:
+                            json_str = json_match.group(0)
+                            annotations = json.loads(json_str)
+
+                            # Draw annotations on image
+                            if annotations:
+                                annotated_image = draw_annotations(image, annotations)
+
+                                # Clean up the analysis text to remove JSON section
+                                # Keep only the analysis part
+                                if "ANALYSIS:" in analysis_text:
+                                    analysis_text = "ANALYSIS:\n" + analysis_text.split("ANALYSIS:")[1].strip()
+                                elif "SECTION 2" in analysis_text:
+                                    analysis_text = analysis_text.split("SECTION 2")[1].strip()
+                                    if analysis_text.startswith("- ANALYSIS:"):
+                                        analysis_text = analysis_text[12:].strip()
+
+                return analysis_text, annotated_image
+
+            except Exception as e:
+                # If annotation parsing fails, return original image with a note
+                return f"[Note: Annotation parsing failed: {str(e)}]\n\n{analysis_text}", image
         else:
             return analysis_text, None
 
@@ -179,15 +299,19 @@ with gr.Blocks(title="SATINT Analyst - Satellite Imagery Analysis", theme=gr.the
             analyze_btn = gr.Button("Analyze Imagery", variant="primary", size="lg")
 
         with gr.Column(scale=1):
-            analysis_output = gr.Textbox(
-                label="Intelligence Analysis",
-                lines=20,
-                max_lines=30,
-                show_copy_button=True
+            gr.Markdown("### Intelligence Analysis")
+            with gr.Row():
+                copy_btn = gr.Button("📋 Copy to Clipboard", size="sm", scale=0)
+            analysis_output = gr.Markdown(
+                value="*Analysis will appear here...*",
+                height=600,
+                elem_classes="analysis-box"
             )
+            # Hidden textbox to hold raw text for copying
+            analysis_text_raw = gr.Textbox(visible=False)
 
             annotated_output = gr.Image(
-                label="Reference Image (for annotated mode)",
+                label="Annotated Image",
                 visible=True
             )
 
@@ -196,8 +320,9 @@ with gr.Blocks(title="SATINT Analyst - Satellite Imagery Analysis", theme=gr.the
     ### Usage Tips
     - **Geolocation**: Use decimal notation (e.g., 38.8977, -77.0365) for latitude and longitude
     - **Brief**: Provide specific questions or focus areas for more targeted analysis
-    - **Text Only Mode**: Receive a detailed written analysis
-    - **Annotated Mode**: Receive analysis with descriptions of key features and their locations
+    - **Text Only Mode**: Receive a detailed written analysis with markdown formatting
+    - **Annotated Mode**: Receive analysis with numbered annotations drawn on the image referencing key features
+    - **Copy Button**: Click the clipboard button to copy the analysis text
 
     ### Privacy & Model
     - **Model**: Meta Llama 3.2 Vision 90B (via OpenRouter)
@@ -207,10 +332,23 @@ with gr.Blocks(title="SATINT Analyst - Satellite Imagery Analysis", theme=gr.the
     """)
 
     # Set up the analyze button
+    def process_analysis(image, geolocation, brief, analysis_mode, api_key):
+        """Wrapper to return results for both markdown and raw text"""
+        text, img = analyze_satellite_image(image, geolocation, brief, analysis_mode, api_key)
+        return text, text, img  # markdown display, raw text for copying, image
+
     analyze_btn.click(
-        fn=analyze_satellite_image,
+        fn=process_analysis,
         inputs=[image_input, geolocation_input, brief_input, analysis_mode, api_key_input],
-        outputs=[analysis_output, annotated_output]
+        outputs=[analysis_output, analysis_text_raw, annotated_output]
+    )
+
+    # Set up copy button to copy from hidden textbox
+    copy_btn.click(
+        fn=lambda x: x,
+        inputs=[analysis_text_raw],
+        outputs=[],
+        js="(text) => {navigator.clipboard.writeText(text); return text;}"
     )
 
 if __name__ == "__main__":

test-local.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# Local testing script for SATINT-Analyst Hugging Face Space
+# This uses uv for fast dependency management locally
+# Hugging Face will still use requirements.txt when deployed
+
+set -e  # Exit on error
+
+echo "🚀 Setting up local testing environment with uv..."
+
+# Check if uv is installed
+if ! command -v uv &> /dev/null; then
+    echo "❌ uv is not installed. Install it with: pip install uv"
+    exit 1
+fi
+
+# Create virtual environment if it doesn't exist
+if [ ! -d ".venv" ]; then
+    echo "📦 Creating virtual environment..."
+    uv venv
+fi
+
+# Activate virtual environment
+echo "🔌 Activating virtual environment..."
+source .venv/bin/activate
+
+# Install dependencies from requirements.txt using uv (much faster than pip)
+echo "📥 Installing dependencies with uv..."
+uv pip install -r requirements.txt
+
+# Run the Gradio app
+echo "🎯 Starting Gradio app..."
+echo "📍 App will be available at http://127.0.0.1:7860"
+echo "Press Ctrl+C to stop"
+echo ""
+
+python app.py