Update app.py

app.py

@@ -2,6 +2,8 @@
 import os
 import io
 import json
+from io import BytesIO
+
 import base64
 import logging
 import uuid
@@ -216,29 +218,70 @@ def upload_b64_to_firebase(base64_str: str, path: str, content_type="image/jpeg"
         raise
 
 # ---------- Image helpers (with EXIF transpose) ----------
+
+# Replace existing read_image_bytes and crop_and_b64 with this block
+
 def read_image_bytes(file_storage) -> Tuple[np.ndarray, int, int, bytes]:
+    """
+    Read bytes, apply EXIF orientation, return BGR numpy, width, height and re-encoded JPEG bytes.
+    This ensures the bytes we pass to Gemini / upload to storage are physically upright
+    (EXIF orientation is applied and not left in metadata).
+    """
     data = file_storage.read()
-    img = Image.open(io.BytesIO(data))
+    try:
+        img = Image.open(io.BytesIO(data))
+    except Exception as e:
+        # fallback: try to decode raw bytes via OpenCV
+        try:
+            arr_np = np.frombuffer(data, np.uint8)
+            cv_img = cv2.imdecode(arr_np, cv2.IMREAD_COLOR)
+            if cv_img is None:
+                raise
+            h, w = cv_img.shape[:2]
+            # re-encode to jpeg bytes to have consistent format
+            _, jpeg = cv2.imencode(".jpg", cv_img, [int(cv2.IMWRITE_JPEG_QUALITY), 92])
+            return cv_img, w, h, jpeg.tobytes()
+        except Exception as ee:
+            raise
+
+    # physically apply EXIF rotation if present
     try:
         img = ImageOps.exif_transpose(img)
     except Exception:
+        # ignore failures here; proceed with original image
         pass
+
+    # ensure RGB and get size
     img = img.convert("RGB")
     w, h = img.size
-    arr = np.array(img)[:, :, ::-1]
-    return arr, w, h, data
+
+    # re-encode to JPEG bytes to strip EXIF orientation tag (important!)
+    buf = BytesIO()
+    # We intentionally omit any EXIF bytes when saving so orientation is cleared.
+    img.save(buf, format="JPEG", quality=92, optimize=True)
+    jpeg_bytes = buf.getvalue()
+
+    # convert to BGR numpy for OpenCV operations
+    arr = np.array(img)[:, :, ::-1]  # RGB -> BGR
+    return arr, w, h, jpeg_bytes
+
 
 def crop_and_b64(bgr_img: np.ndarray, x: int, y: int, w: int, h: int, max_side=512) -> str:
+    """
+    Crop from BGR image (already upright), optionally resize, encode as JPEG and return base64 string.
+    """
     h_img, w_img = bgr_img.shape[:2]
     x = max(0, int(x)); y = max(0, int(y))
     x2 = min(w_img, int(x + w)); y2 = min(h_img, int(y + h))
     crop = bgr_img[y:y2, x:x2]
     if crop.size == 0:
         return ""
+    # resize if too large
     max_dim = max(crop.shape[0], crop.shape[1])
     if max_dim > max_side:
         scale = max_side / max_dim
         crop = cv2.resize(crop, (int(crop.shape[1] * scale), int(crop.shape[0] * scale)), interpolation=cv2.INTER_AREA)
+    # encode to JPEG (this will be upright because bgr_img was exif_transposed)
     _, jpeg = cv2.imencode(".jpg", crop, [int(cv2.IMWRITE_JPEG_QUALITY), 82])
     return base64.b64encode(jpeg.tobytes()).decode("ascii")