Still tuning accuracy of detection prompts to reduce false positives

main2.py

@@ -592,7 +592,8 @@ def setup_directories():
     output_dirs = {
         "standard": os.path.join("output", "standard"),
         "shifted": os.path.join("output", "shifted"),
-        "crops": os.path.join("output", "crops")
+        "crops": os.path.join("output", "crops"),
+        "verification": os.path.join("output", "verification")
     }
     
     # Create the images directory if it doesn't exist
@@ -729,6 +730,387 @@ def process_images(images_dir, output_dir, image_files):
             opacity=opacity
         )
 
+def convert_to_supported_format(input_path, output_format="jpg"):
+    """
+    Convert an image to a format supported by OpenAI's Vision API.
+    
+    Args:
+        input_path (str): Path to the input image
+        output_format (str): Output format ('jpg', 'png', 'webp', or 'gif')
+        
+    Returns:
+        str: Path to the converted image
+    """
+    try:
+        # Read the image
+        img = cv2.imread(input_path)
+        if img is None:
+            try:
+                pil_img = Image.open(input_path)
+                img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+            except Exception as e:
+                print(f"Error: Could not read image with PIL either: {e}")
+                return None
+        
+        # Create output path
+        file_dir = os.path.dirname(input_path)
+        file_name, _ = os.path.splitext(os.path.basename(input_path))
+        output_path = os.path.join(file_dir, f"{file_name}.{output_format}")
+        
+        # Save in the new format
+        cv2.imwrite(output_path, img)
+        print(f"Converted image saved to {output_path}")
+        
+        return output_path
+    except Exception as e:
+        print(f"Error converting image: {e}")
+        return None
+    
+
+def resize_image_if_needed(image_path, max_size=4096):
+    """Resize an image if either dimension exceeds max_size"""
+    img = cv2.imread(image_path)
+    if img is None:
+        return image_path
+        
+    height, width = img.shape[:2]
+    if max(height, width) > max_size:
+        # Calculate new dimensions
+        if width > height:
+            new_width = max_size
+            new_height = int(height * (max_size / width))
+        else:
+            new_height = max_size
+            new_width = int(width * (max_size / height))
+            
+        # Resize the image
+        img_resized = cv2.resize(img, (new_width, new_height))
+        
+        # Save the resized image
+        file_dir = os.path.dirname(image_path)
+        file_name, file_ext = os.path.splitext(os.path.basename(image_path))
+        output_path = os.path.join(file_dir, f"{file_name}_resized{file_ext}")
+        cv2.imwrite(output_path, img_resized)
+        print(f"Resized image saved to {output_path}")
+        return output_path
+    
+    return image_path
+
+
+def call_openai_api(standard_grid_path, shifted_grid_path, prompt_text, api_key):
+    """
+    Call the OpenAI API with both grid images in a single request.
+    
+    Args:
+        standard_grid_path: Path to the standard grid image
+        shifted_grid_path: Path to the shifted grid image
+        prompt_text: The prompt text to send to the API
+        api_key: Your OpenAI API key
+    
+    Returns:
+        The API response text
+    """
+    import openai
+    import base64
+    from openai import OpenAI
+
+    # After converting format
+    standard_grid_path = resize_image_if_needed(standard_grid_path)
+    shifted_grid_path = resize_image_if_needed(shifted_grid_path)
+    
+    # Initialize the client with your API key
+    client = OpenAI(api_key=api_key)
+    
+    # Convert images to supported formats if needed
+    if standard_grid_path.lower().endswith(('.tiff', '.tif')):
+        standard_grid_path = convert_to_supported_format(standard_grid_path, "jpg")
+    
+    if shifted_grid_path.lower().endswith(('.tiff', '.tif')):
+        shifted_grid_path = convert_to_supported_format(shifted_grid_path, "jpg")
+    
+    # Read and encode the images
+    def encode_image(image_path):
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+    
+    standard_grid_base64 = encode_image(standard_grid_path)
+    shifted_grid_base64 = encode_image(shifted_grid_path)
+    
+    # Prepare the messages payload
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a search and rescue assistant analyzing aerial imagery."
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": prompt_text
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{standard_grid_base64}",
+                        "detail": "high"
+                    }
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{shifted_grid_base64}",
+                        "detail": "high"
+                    }
+                }
+            ]
+        }
+    ]
+    
+    # Call the API
+    response = client.chat.completions.create(
+        model="gpt-4o",  # Latest model that supports vision
+        messages=messages,
+        max_tokens=2000
+    )
+    
+    return response.choices[0].message.content
+
+def draw_boundary_around_person(image_path, output_path, dot_number, x_offset=0, y_offset=0, 
+                         width_percent=0.3, height_percent=0.3, grid_rows=5, grid_cols=5):
+    """Draw a more precise boundary within a grid cell"""
+    # Read the image
+    img = cv2.imread(image_path)
+    height, width = img.shape[:2]
+    
+    # Calculate cell dimensions
+    cell_height = height // grid_rows
+    cell_width = width // grid_cols
+    
+    # Calculate cell position
+    row = (dot_number - 1) // grid_cols
+    col = (dot_number - 1) % grid_cols
+    
+    # Calculate cell center
+    center_x = (col * cell_width) + (cell_width // 2)
+    center_y = (row * cell_height) + (cell_height // 2)
+    
+    # Calculate smaller boundary within the cell
+    box_width = int(cell_width * width_percent)
+    box_height = int(cell_height * height_percent)
+    
+    # Apply offset from center if provided
+    x1 = center_x - (box_width // 2) + x_offset
+    y1 = center_y - (box_height // 2) + y_offset
+    x2 = x1 + box_width
+    y2 = y1 + box_height
+    
+    # Draw the boundary
+    img_with_boundary = img.copy()
+    cv2.rectangle(img_with_boundary, (x1, y1), (x2, y2), (0, 255, 0), 2)
+    
+    # Save the image
+    cv2.imwrite(output_path, img_with_boundary)
+    
+    return img_with_boundary
+
+
+def draw_focused_boundary(image_path, output_path, dot_number, grid_rows=5, grid_cols=5, 
+                         boundary_color=(0, 255, 0), focus_factor=0.5):
+    """Draw a boundary focused on the center portion of a grid cell"""
+    img = cv2.imread(image_path)
+    if img is None:
+        return None
+        
+    height, width = img.shape[:2]
+    cell_height = height // grid_rows
+    cell_width = width // grid_cols
+    
+    # Calculate grid position
+    row = (dot_number - 1) // grid_cols
+    col = (dot_number - 1) % grid_cols
+    
+    # Calculate original cell boundaries
+    cell_x1 = col * cell_width
+    cell_y1 = row * cell_height
+    cell_x2 = cell_x1 + cell_width
+    cell_y2 = cell_y1 + cell_height
+    
+    # Calculate focused area within cell
+    center_x = cell_x1 + (cell_width // 2)
+    center_y = cell_y1 + (cell_height // 2)
+    
+    focus_width = int(cell_width * focus_factor)
+    focus_height = int(cell_height * focus_factor)
+    
+    x1 = center_x - (focus_width // 2)
+    y1 = center_y - (focus_height // 2)
+    x2 = x1 + focus_width
+    y2 = y1 + focus_height
+    
+    # Draw the boundary
+    img_copy = img.copy()
+    
+    # Draw full cell with thin line
+    cv2.rectangle(img_copy, (cell_x1, cell_y1), (cell_x2, cell_y2), (0, 150, 0), 1)
+    
+    # Draw focused area with thicker line
+    cv2.rectangle(img_copy, (x1, y1), (x2, y2), boundary_color, 2)
+    
+    # Add label
+    label = f"Person detected (Cell {dot_number})"
+    cv2.putText(img_copy, label, (cell_x1, cell_y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, boundary_color, 2)
+    
+    cv2.imwrite(output_path, img_copy)
+    return img_copy
+
+def parse_api_response(api_response):
+    """
+    Parse the YAML response from the OpenAI API to extract the recommended zoom area.
+    
+    Args:
+        api_response (str): The raw text response from the API
+        
+    Returns:
+        int: The recommended grid number to zoom in on, or None if not found
+    """
+    import yaml
+    import re
+    
+    # Try to extract directly using regex
+    best_detection_match = re.search(r'best_detection:.*?(\d+)', api_response, re.DOTALL)
+    recommended_area_match = re.search(r'recommended_zoom_area:\s*(\d+)', api_response, re.DOTALL)
+    
+    if recommended_area_match:
+        return int(recommended_area_match.group(1))
+    elif best_detection_match:
+        return int(best_detection_match.group(1))
+    
+    # If regex failed, try YAML parsing with error handling
+    try:
+        # Try to extract YAML content
+        yaml_match = re.search(r'```yaml\n(.*?)\n```', api_response, re.DOTALL)
+        if yaml_match:
+            yaml_content = yaml_match.group(1)
+            
+            # Clean up potentially problematic YAML
+            # Replace "best_detection: standard_grid: 18" with "best_detection: 'standard_grid: 18'"
+            yaml_content = re.sub(r'best_detection:\s+(.*?):\s+(\d+)', r'best_detection: "\1: \2"', yaml_content)
+            
+            # Parse the YAML
+            try:
+                result = yaml.safe_load(yaml_content)
+                
+                # Get the recommended zoom area
+                zoom_area = result.get('final_determination', {}).get('recommended_zoom_area')
+                if zoom_area:
+                    return int(zoom_area)
+                
+                # Try alternate location
+                best_detection = result.get('final_determination', {}).get('best_detection')
+                if best_detection and isinstance(best_detection, str):
+                    # Extract number from string like "standard_grid: 18"
+                    number_match = re.search(r'(\d+)', best_detection)
+                    if number_match:
+                        return int(number_match.group(1))
+            except yaml.YAMLError as e:
+                print(f"YAML parsing error: {e}")
+                
+                # Try to extract the number directly
+                number_match = re.search(r'recommended_zoom_area:\s*(\d+)', yaml_content)
+                if number_match:
+                    return int(number_match.group(1))
+    except Exception as e:
+        print(f"Error during response parsing: {e}")
+    
+    # If all else fails, look for any number after "detection" or "area"
+    any_number = re.search(r'(detection|area).*?(\d+)', api_response, re.DOTALL | re.IGNORECASE)
+    if any_number:
+        return int(any_number.group(2))
+    
+    return None
+
+
+def verify_detection(image_path, prompt_text, api_key):
+    """Second pass verification of a potential person detection"""
+    import base64
+    from openai import OpenAI
+    
+    # Convert to supported formats and resize if needed
+    if image_path.lower().endswith(('.tiff', '.tif')):
+        image_path = convert_to_supported_format(image_path, "jpg")
+    
+    image_path = resize_image_if_needed(image_path)
+    
+    # Initialize API client
+    client = OpenAI(api_key=api_key)
+    
+    # Encode the image
+    with open(image_path, "rb") as image_file:
+        base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+    
+    # Call the API
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a search and rescue imagery analyst specializing in detecting humans in aerial photography."
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": prompt_text
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{base64_image}",
+                        "detail": "high"
+                    }
+                }
+            ]
+        }
+    ]
+    
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        messages=messages,
+        max_tokens=1000
+    )
+    
+    return response.choices[0].message.content
+
+def check_verification_result(response_text):
+    """Analyze verification response to determine if it's really a person"""
+    import re
+    
+    # Check for confident affirmative language
+    positive_indicators = ['definitely a person', 'clearly a human', 'confident this is a person',
+                          'human figure is visible', 'can confirm this is a person']
+    
+    # Check for negative language
+    negative_indicators = ['not a person', 'false positive', 'no human', 'just a', 'likely just',
+                          'probably just', 'appears to be a rock', 'vegetation', 'shadow', 'no evidence']
+    
+    response_lower = response_text.lower()
+    
+    # Count indicators
+    positive_count = sum(1 for term in positive_indicators if term in response_lower)
+    negative_count = sum(1 for term in negative_indicators if term in response_lower)
+    
+    # Extract any confidence statements
+    confidence_match = re.search(r'confidence:?\s*(high|medium|low)', response_lower)
+    confidence = confidence_match.group(1) if confidence_match else None
+    
+    # Decision logic
+    if positive_count > negative_count and (confidence != 'low'):
+        return True
+    elif 'yes' in response_lower[:100] and negative_count == 0:
+        return True
+    else:
+        return False
+
 def main():
     """
     Main function to run the grid numbering script.
@@ -736,21 +1118,186 @@ def main():
     # Setup directories
     images_dir, output_dirs = setup_directories()
     
+    # Add a new directory for final results
+    results_dir = os.path.join("output", "results")
+    if not os.path.exists(results_dir):
+        os.makedirs(results_dir)
+        print(f"Created results directory: {results_dir}")
+    output_dirs["results"] = results_dir
+    
     # Get image files
     image_files = get_image_files(images_dir)
     
+    # Get API key from environment
+    api_key = os.getenv("OPENAI_API_KEY")
+
+    # Fallback to a hardcoded key if environment variable is not set
+    if not api_key:
+        api_key = "HARD CODED API"  # This is a fallback
+        print("Warning: Using hardcoded API key. Better to set OPENAI_API_KEY environment variable.")
+    
+    # Read the prompt from the markdown file
+    try:
+        with open("prompt_yaml.md", "r") as f:
+            prompt_text = f.read()
+        print("Successfully loaded prompt from prompt_yaml.md")
+    except Exception as e:
+        print(f"Error reading prompt file: {e}")
+        return
+    
+    # Read the verification prompt if it exists
+    try:
+        with open("verification_prompt.md", "r") as f:
+            verification_prompt = f.read()
+        print("Successfully loaded verification prompt")
+    except:
+        # Use a default verification prompt if file doesn't exist
+        verification_prompt = """
+        I'm showing you a zoomed-in section of an aerial image where a person might be present.
+        
+        Please carefully analyze this image and determine if there is actually a human present.
+        
+        Important considerations:
+        1. Look for definitive human shapes, limbs, or clothing
+        2. Be skeptical - many natural features can look like people from above
+        3. Consider whether this might be a false positive (rock, tree stump, shadow, etc.)
+        
+        Provide your assessment with high, medium, or low confidence and explain your reasoning.
+        """
+        print("Using default verification prompt")
+    
     if image_files:
         # Choose which operation to perform
-        operation = "grid"  # Options: "grid", "shift", "crop", "crop_cells", "all"
+        operation = "all"  # Options: "grid", "shift", "crop", "crop_cells", "all", "api"
         
-        if operation == "grid" or operation == "all":
+        # Process images with standard grid if required
+        if operation == "grid" or operation == "all" or operation == "api":
             print("\nProcessing images with standard grid pattern...")
             process_images(images_dir, output_dirs["standard"], image_files)
         
-        if operation == "shift" or operation == "all":
+        # Process images with shifted grid if required
+        if operation == "shift" or operation == "all" or operation == "api":
             print("\nProcessing images with shifted grid pattern...")
             process_images_with_shift(images_dir, output_dirs["shifted"], image_files)
         
+        # Perform API analysis if requested
+        if operation == "api" or operation == "all":
+            print("\nPerforming API analysis with both grid patterns...")
+            for image_file in image_files:
+                file_name, file_ext = os.path.splitext(image_file)
+                
+                # Get paths to the generated grid images
+                standard_grid_path = os.path.join(output_dirs["standard"], f"{file_name}_grid{file_ext}")
+                
+                # Use the correct path for the shifted grid image (without "_shifted" in the filename)
+                shifted_grid_path = os.path.join(output_dirs["shifted"], f"{file_name}_grid{file_ext}")
+                
+                # Check if both images exist
+                if not (os.path.exists(standard_grid_path) and os.path.exists(shifted_grid_path)):
+                    print(f"Error: Grid images not found for {image_file}. Run grid and shift operations first.")
+                    print(f"Looked for: {standard_grid_path} and {shifted_grid_path}")
+                    continue
+                
+                print(f"\nAnalyzing grid patterns for {image_file}...")
+                try:
+                    # Step 1: Initial detection
+                    api_response = call_openai_api(
+                        standard_grid_path, 
+                        shifted_grid_path, 
+                        prompt_text, 
+                        api_key
+                    )
+                    
+                    # Save the API response to a file
+                    response_path = os.path.join(output_dirs["standard"], f"{file_name}_analysis.txt")
+                    with open(response_path, "w") as f:
+                        f.write(api_response)
+                    
+                    print(f"API response saved to {response_path}")
+                    
+                    # Parse the response to extract recommended zoom area
+                    recommended_area = parse_api_response(api_response)
+                    if recommended_area:
+                        print(f"Potential person detected near number {recommended_area}")
+                        
+                        # Step 2: Create a zoomed image for verification
+                        verification_path = os.path.join(output_dirs["verification"], f"{file_name}_verify_{recommended_area}.jpg")
+                        crop_image_around_dot(
+                            os.path.join(images_dir, image_file), 
+                            verification_path, 
+                            recommended_area, 
+                            grid_rows=5, 
+                            grid_cols=5,
+                            crop_factor=1.5  # Tighter crop for verification
+                        )
+                        
+                        # Convert to jpg if needed for API
+                        if verification_path.lower().endswith(('.tiff', '.tif')):
+                            verification_path = convert_to_supported_format(verification_path, "jpg")
+                        
+                        # Step 3: Verify the detection with a second API call
+                        print("Verifying potential detection...")
+                        verification_response = verify_detection(verification_path, verification_prompt, api_key)
+                        
+                        # Save verification response
+                        verify_resp_path = os.path.join(output_dirs["verification"], f"{file_name}_verify_{recommended_area}_response.txt")
+                        with open(verify_resp_path, "w") as f:
+                            f.write(verification_response)
+                        
+                        # Step 4: Check verification result
+                        is_person = check_verification_result(verification_response)
+                        
+                        if is_person:
+                            print(f"CONFIRMED: Person detected in cell {recommended_area}")
+                            
+                            # Draw boundary around the detected person with focused area
+                            boundary_path = os.path.join(output_dirs["results"], f"{file_name}_person_detected{file_ext}")
+                            draw_focused_boundary(
+                                os.path.join(images_dir, image_file), 
+                                boundary_path, 
+                                recommended_area, 
+                                grid_rows=5, 
+                                grid_cols=5,
+                                focus_factor=0.6  # Draw boundary around 60% of the cell
+                            )
+                            print(f"Image with person boundary saved to {boundary_path}")
+                            
+                            # Create the zoomed crop
+                            crop_path = os.path.join(output_dirs["crops"], f"{file_name}_zoom_{recommended_area}{file_ext}")
+                            crop_image_around_dot(
+                                os.path.join(images_dir, image_file), 
+                                crop_path, 
+                                recommended_area, 
+                                grid_rows=5, 
+                                grid_cols=5,
+                                crop_factor=2.0  # Adjust as needed
+                            )
+                            print(f"Zoomed image saved to {crop_path}")
+                        else:
+                            print(f"FALSE POSITIVE: Initial detection in cell {recommended_area} appears to be incorrect.")
+                            # Save a rejected detection image for reference
+                            rejected_path = os.path.join(output_dirs["results"], f"{file_name}_rejected_{recommended_area}{file_ext}")
+                            # To this:
+                            draw_boundary_around_person(
+                                os.path.join(images_dir, image_file), 
+                                rejected_path, 
+                                recommended_area,
+                                x_offset=0,
+                                y_offset=0,
+                                width_percent=0.3,
+                                height_percent=0.3,
+                                grid_rows=5, 
+                                grid_cols=5
+                            )
+                            print(f"Rejected detection saved to {rejected_path}")
+                    else:
+                        print("Could not identify a potential person in the image.")
+                    
+                except Exception as e:
+                    print(f"Error in API processing: {e}")
+                    print(f"Exception details: {str(e)}")
+        
+        # Perform manual cropping if requested
         if operation == "crop" or operation == "all":
             print("\nCropping images around specific dots...")
             # Example: crop around these dot numbers
@@ -772,5 +1319,6 @@ def main():
     else:
         print("No images to process.")
 
+
 if __name__ == "__main__":
     main()

promt_yaml.md → prompt_yaml.md

@@ -5,15 +5,32 @@ You are a search-and-rescue assistant deployed in a wilderness environment. Your
 
 The missing person may be wearing outdoor or winter gear and could be **lying down, standing, or partially obscured** by vegetation or terrain. Visibility may be reduced due to tree cover, rocks, shadows, or snow.
 
+## Important Aerial Imagery Considerations:
+- People viewed from above appear very different than from ground level
+- Look for these specific indicators of human presence:
+  - **Body shape**: Oval or elongated shapes that contrast with surroundings
+  - **Limbs**: Linear extensions from a central mass (arms/legs)
+  - **Clothing**: Artificial colors like bright blues, reds, yellows that contrast with nature
+  - **Shadow patterns**: Human-shaped shadows distinct from vegetation
+- Common false positives to avoid:
+  - Fallen logs or tree branches (often mistaken for bodies)
+  - Animal trails or small clearings
+  - Rock formations or terrain features
+  - Shadows from trees and other vegetation
+
 ####  Objective:
-- **Carefully the image**
+- **Carefully examine the image**
 - Identify the **nearest number most likely has a human figure or human-like features**.
 - You may see only **parts of a human body** (like a head, torso, arm, or leg), or clothing that stands out from the natural environment.
 - The individual may appear **small or camouflaged**, so analyze closely.
+- Compare both images to account for potential obstruction by the numbered circles
+- If a human figure is visible in one image but not the other, indicate which image and number
 
-####  Input:
-- A single image that has been **given numbers** with proper intervals.
-- The numbers are given such that the area can be identified using nearest number.
+#### Input:
+- Two versions of the same aerial image, both with numbered grids:
+  - Image 1 (standard_grid): Standard grid pattern with numbered circles
+  - Image 2 (shifted_grid): Same grid pattern but shifted slightly to ensure no person is hidden behind circles
+- Please analyze both images and determine if a human is present in either or both images
 
 ####  What to look for:
 - **Skin tones**, **shoes**, **backpacks**, or **bright clothing**.
@@ -26,17 +43,38 @@ The missing person may be wearing outdoor or winter gear and could be **lying do
 1. Nearest **integer number(s)** a human or human-like feature is most likely detected.
 2. **Short justification** for your choice (e.g., “visible figure in red jacket lying near a rock” or “unusual shape with color contrast suggesting a backpack”).
 3. If unsure, list **top 2-3 most suspicious numbers** near the human in descending order of confidence.
+4. If no human is detected in either image, please state so clearly while maintaining the YAML format with "None" values where appropriate.
 
 #### 📝 Format:
 ```yaml
-likely_human_near_number: 40
-confidence: High
-reason: "There is a human-shaped figure wearing dark clothing near a cleared area with fallen logs near the number 19"
-
-alternative_candidates:
-  - near_number: 57
-    confidence: Medium
-    reason: "Bright object that may be clothing or gear, partially hidden by trees."
-  - near_number: 43
-    confidence: Low
-    reason: "Dark form resembling a crouching figure, but could be a shadow or rock."
+# Analysis of both grid patterns
+standard_grid:
+  likely_human_near_number: [number]
+  confidence: [High/Medium/Low]
+  reason: "[Detailed description of what you see and why it appears human]"
+  alternative_candidates:
+    - near_number: [number]
+      confidence: [Medium/Low]
+      reason: "[Description of what makes this suspicious]"
+    - near_number: [number]
+      confidence: [Medium/Low]
+      reason: "[Description of what makes this suspicious]"
+
+shifted_grid:
+  likely_human_near_number: [number]
+  confidence: [High/Medium/Low]
+  reason: "[Detailed description of what you see and why it appears human]"
+  alternative_candidates:
+    - near_number: [number]
+      confidence: [Medium/Low]
+      reason: "[Description of what makes this suspicious]"
+    - near_number: [number]
+      confidence: [Medium/Low]
+      reason: "[Description of what makes this suspicious]"
+
+# Combined assessment
+final_determination:
+  best_detection: [standard_grid: number] OR [shifted_grid: number]
+  confidence: [High/Medium/Low]
+  reason: "[Explanation of why this is the most reliable detection]"
+  recommended_zoom_area: [number]