split endpoint views

app.py

@@ -167,4 +167,127 @@ async def explain(file: UploadFile = File(...)):
 
     # 6. Stream Result
     _, buffer = cv2.imencode('.jpg', overlay)
-    return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/jpeg")
+    return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/jpeg")
+
+
+@app.post("/explain/tiled")
+async def explain_tiled(file: UploadFile = File(...)):
+    # 1. Prepare Base Image
+    contents = await file.read()
+    image_pil = Image.open(io.BytesIO(contents)).convert("RGB")
+    image_np = np.array(image_pil).astype(np.float32)
+    input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)
+    
+    # 2. Get Initial Detections to know what to "Explain"
+    detections = detect_fn(input_tensor)
+    scores = detections['detection_scores'][0].numpy()
+    classes = detections['detection_classes'][0].numpy().astype(int)
+    boxes = detections['detection_boxes'][0].numpy()
+
+    # Create the Top-Left "Base" image with all boxes
+    base_image = cv2.cvtColor(image_np.astype(np.uint8), cv2.COLOR_RGB2BGR)
+    h_img, w_img, _ = base_image.shape
+    
+    for i in range(min(len(scores), 3)):
+        if scores[i] > 0.4:
+            ymin, xmin, ymax, xmax = boxes[i]
+            cv2.rectangle(base_image, (int(xmin*w_img), int(ymin*h_img)), 
+                          (int(xmax*w_img), int(ymax*h_img)), (255, 255, 0), 2)
+
+    # 3. Generate Saliency Maps for the Top 3 detections
+    panels = [base_image]
+    
+    for i in range(3):
+        if i < len(scores) and scores[i] > 0.4:
+            target_class = classes[i]
+            
+            with tf.GradientTape() as tape:
+                tape.watch(input_tensor)
+                image, shapes = detection_model.preprocess(input_tensor)
+                prediction_dict = detection_model.predict(image, shapes)
+                raw_scores = prediction_dict['class_predictions_with_background'][0]
+                # Target the specific class at its most active anchor
+                loss = tf.reduce_max(raw_scores[:, target_class])
+
+            grads = tape.gradient(loss, input_tensor)
+            saliency = np.max(np.abs(grads.numpy()), axis=-1)[0]
+            
+            # Normalize and Colorize
+            v_min, v_max = np.percentile(saliency, (5, 95))
+            saliency = np.clip((saliency - v_min) / (v_max - v_min + 1e-8), 0, 1)
+            heatmap = cv2.applyColorMap(np.uint8(255 * saliency), cv2.COLORMAP_JET)
+            
+            # Overlay
+            overlay = cv2.addWeighted(cv2.cvtColor(image_np.astype(np.uint8), cv2.COLOR_RGB2BGR), 0.6, heatmap, 0.4, 0)
+            
+            # Label the panel
+            class_name = category_index.get(target_class + 1, {}).get('name', 'unknown')
+            cv2.putText(overlay, f"Top {i+1}: {class_name}", (10, 30), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+            panels.append(overlay)
+        else:
+            # Placeholder for empty slots if fewer than 3 detections exist
+            panels.append(np.zeros_like(base_image))
+
+    # 4. Assemble the 2x2 Grid
+    # Panels are: [0:Base, 1:Top1, 2:Top2, 3:Top3]
+    top_row = np.hstack((panels[0], panels[1]))
+    bottom_row = np.hstack((panels[2], panels[3]))
+    tiled_output = np.vstack((top_row, bottom_row))
+
+    # 5. Stream Result
+    _, buffer = cv2.imencode('.jpg', tiled_output)
+    return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/jpeg")
+
+
+@app.post("/explain/global")
+async def explain_global(file: UploadFile = File(...)):
+    # 1. Read and Prepare Image
+    contents = await file.read()
+    image_pil = Image.open(io.BytesIO(contents)).convert("RGB")
+    image_np = np.array(image_pil).astype(np.float32)
+    # Keeping a uint8 copy for the final BGR overlay
+    image_bgr = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
+    
+    input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)
+
+    # 2. Gradient Tape for Global Activation
+    with tf.GradientTape() as tape:
+        tape.watch(input_tensor)
+        
+        # Forward pass
+        image, shapes = detection_model.preprocess(input_tensor)
+        prediction_dict = detection_model.predict(image, shapes)
+        
+        # 'class_predictions_with_background' shape: [1, num_anchors, num_classes]
+        raw_scores = prediction_dict['class_predictions_with_background'][0]
+        
+        # We ignore index 0 (Background/Clear) and look at all damage classes
+        # We take the max score at each anchor point, then sum them for the global loss
+        foreground_scores = raw_scores[:, 1:] 
+        loss = tf.reduce_sum(tf.reduce_max(foreground_scores, axis=-1))
+
+    # 3. Compute and Process Gradients
+    grads = tape.gradient(loss, input_tensor)
+    saliency = np.max(np.abs(grads.numpy()), axis=-1)[0]
+
+    # 4. Refine Saliency Visualization
+    # Using the 95th percentile helps ignore "pixel noise" and highlights the actual damage
+    v_min, v_max = np.percentile(saliency, (5, 95))
+    saliency = np.clip((saliency - v_min) / (v_max - v_min + 1e-8), 0, 1)
+    
+    # Create the heatmap overlay
+    heatmap = cv2.applyColorMap(np.uint8(255 * saliency), cv2.COLORMAP_JET)
+    
+    # Blend: 60% original image, 40% heatmap
+    # This maintains the "Pinterest-chic" aesthetic without washing out the car details
+    overlay = cv2.addWeighted(image_bgr, 0.6, heatmap, 0.4, 0)
+
+    # 5. Add Branding/Label
+    # Teal text to match your office setup/portfolio theme
+    cv2.putText(overlay, "Global Model Attention", (20, 40), 
+                cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 0), 2)
+
+    # 6. Stream Result
+    _, buffer = cv2.imencode('.jpg', overlay)
+    return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/jpeg")