Update app.py

app.py

@@ -321,190 +321,313 @@
 
 
 
-import gradio as gr
-import json
-import base64
-import requests
-from io import BytesIO
+# import gradio as gr
+# import json
+# import base64
+# import requests
+# from io import BytesIO
+# import torch
+# import numpy as np
+# import cv2
+# import os
+# from PIL import Image
+# from detectron2.engine import DefaultPredictor
+# from detectron2.config import get_cfg
+# from detectron2 import model_zoo
+
+# # === Set up Detectron2 model ===
+# cfg = get_cfg()
+# cfg.merge_from_file(model_zoo.get_config_file("COCO-Keypoints/keypoint_rcnn_R_50_FPN_3x.yaml"))
+# cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Keypoints/keypoint_rcnn_R_50_FPN_3x.yaml")
+# cfg.MODEL.DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+# predictor = DefaultPredictor(cfg)
+
+# # === Utility ===
+# def get_distance(p1, p2):
+#     return np.linalg.norm(np.array(p1) - np.array(p2))
+
+# # === Keypoint and Measurement Logic ===
+# def process_image(image, user_height_cm):
+#     image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+#     outputs = predictor(image_cv)
+#     instances = outputs["instances"]
+#     keypoints = instances.pred_keypoints.cpu().numpy().tolist() if instances.has("pred_keypoints") else None
+
+#     if not keypoints:
+#         return "No keypoints detected.", None, None
+
+#     keypoints = np.array(keypoints[0])[:, :2]
+
+#     # Draw keypoints and skeleton
+#     skeleton = [(5, 6), (5, 11), (6, 12), (11, 12)]
+#     for x, y in keypoints:
+#         cv2.circle(image_cv, (int(x), int(y)), 5, (0, 255, 0), -1)
+#     for pt1, pt2 in skeleton:
+#         x1, y1 = map(int, keypoints[pt1])
+#         x2, y2 = map(int, keypoints[pt2])
+#         cv2.line(image_cv, (x1, y1), (x2, y2), (255, 0, 0), 2)
+
+#     # Body part indices
+#     NOSE, L_SHOULDER, R_SHOULDER = 0, 5, 6
+#     L_WRIST, L_HIP, R_HIP, L_ANKLE, R_ANKLE = 9, 11, 12, 15, 16
+
+#     ankle_mid = ((keypoints[L_ANKLE] + keypoints[R_ANKLE]) / 2).tolist()
+#     pixel_height = get_distance(keypoints[NOSE], ankle_mid)
+#     estimated_full_pixel_height = pixel_height / 0.87
+#     pixels_per_cm = estimated_full_pixel_height / user_height_cm
+
+#     shoulder_width_cm = get_distance(keypoints[L_SHOULDER], keypoints[R_SHOULDER]) / pixels_per_cm
+#     waist_width_cm = get_distance(keypoints[L_HIP], keypoints[R_HIP]) / pixels_per_cm
+#     pelvis = ((keypoints[L_HIP] + keypoints[R_HIP]) / 2).tolist()
+#     neck = ((keypoints[L_SHOULDER] + keypoints[R_SHOULDER]) / 2).tolist()
+#     torso_length_cm = get_distance(neck, pelvis) / pixels_per_cm
+#     arm_length_cm = get_distance(keypoints[L_SHOULDER], keypoints[L_WRIST]) / pixels_per_cm
+
+#     waist_circumference = np.pi * waist_width_cm
+#     hip_circumference = waist_circumference / 0.75
+
+#     measurements = {
+#         "Waist Circumference (cm)": round(waist_circumference, 2),
+#         "Hip Circumference (cm)": round(hip_circumference, 2),
+#         "Shoulder Width (cm)": round(shoulder_width_cm, 2),
+#         "Torso Length (Neck to Pelvis, cm)": round(torso_length_cm, 2),
+#         "Full Arm Length (Shoulder to Wrist, cm)": round(arm_length_cm, 2),
+#     }
+
+#     return measurements, cv2.cvtColor(image_cv, cv2.COLOR_BGR2RGB), keypoints.tolist()
+
+# # === Save to DB ===
+# # def save_to_database(measurements, image, user_height_cm, user_id):
+# #     if not user_id:
+# #         return "❌ user_id missing from URL."
+
+# #     if measurements is None or image is None:
+# #         return "⚠️ No data to save."
+
+# #     buffered = BytesIO()
+# #     pil_image = Image.fromarray(image)
+# #     pil_image.save(buffered, format="JPEG")
+# #     img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+# #     payload = {
+# #         "imageBase64": img_str,
+# #         "heightCm": user_height_cm,
+# #         "measurements": measurements
+# #     }
+
+#     # try:
+#     #     response = requests.post(
+#     #         f"https://9d68-210-212-162-140.ngrok-free.app/upload/{user_id}",
+#     #         json=payload
+#     #     )
+#     #     if response.status_code == 201:
+#     #         return "✅ Measurements and image saved to database!"
+#     #     else:
+#     #         return f"❌ Failed: {response.status_code} - {response.text}"
+#     # except Exception as e:
+#     #     return f"⚠️ Error during save: {str(e)}"
+
+
+
+# def save_to_database(measurements, image, user_height_cm, user_id):
+#     if not user_id:
+#         return "❌ user_id missing from URL."
+#     if measurements is None or image is None:
+#         return "⚠️ No data to save."
+
+#     buffered = BytesIO()
+#     pil_image = Image.fromarray(image)
+#     pil_image.save(buffered, format="JPEG")
+#     img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+#     payload = {
+#         "imageBase64": img_str,
+#         "heightCm": user_height_cm,
+#         "waistCircumferenceCm": measurements.get("Waist Circumference (cm)"),
+#         "hipcircumference": measurements.get("Hip Circumference (cm)"),
+#         "shoulderwidth": measurements.get("Shoulder Width (cm)"),
+#         "torsolength": measurements.get("Torso Length (Neck to Pelvis, cm)"),
+#         "fullarmlength": measurements.get("Full Arm Length (Shoulder to Wrist, cm)"),
+#     }
+
+#     try:
+#         response = requests.post(
+#             f"https://7da2-2409-4042-6e81-1806-de6-b8e5-836c-6b95.ngrok-free.app/upload/{user_id}",
+#             json=payload
+#         )
+#         if response.status_code == 201:
+#             return "✅ Measurements and image saved to database!"
+#         else:
+#             return f"❌ Failed: {response.status_code} - {response.text}"
+#     except Exception as e:
+#         return f"⚠️ Error during save: {str(e)}"
+
+
+# # === Gradio App ===
+# with gr.Blocks() as demo:
+#     gr.Markdown("# 📏 AI-Powered Body Measurement Tool")
+#     user_id_state = gr.State()
+
+#     @demo.load(inputs=None, outputs=[user_id_state])
+#     def load_user_id(request: gr.Request):
+#         return request.query_params.get("user_id", "")
+
+#     with gr.Row():
+#         with gr.Column():
+#             image_input = gr.Image(label="Upload Your Full Body Image", type="pil")
+#             height_input = gr.Number(label="Your Real Height (in cm)")
+#             process_button = gr.Button("📐 Extract Measurements")
+
+#         with gr.Column():
+#             output_image = gr.Image(label="Detected Keypoints")
+#             measurement_output = gr.JSON(label="Body Measurements")
+
+#     with gr.Row():
+#         save_button = gr.Button("💾 Save to Backend")
+#         save_status = gr.Textbox(label="Status", interactive=False)
+
+#     # Store results for save
+#     processed_img = gr.State()
+#     processed_data = gr.State()
+
+#     process_button.click(
+#         fn=process_image,
+#         inputs=[image_input, height_input],
+#         outputs=[measurement_output, output_image, processed_data]
+#     ).then(
+#         fn=lambda img: img,
+#         inputs=[output_image],
+#         outputs=processed_img
+#     )
+
+#     save_button.click(
+#         fn=save_to_database,
+#         inputs=[measurement_output, processed_img, height_input, user_id_state],
+#         outputs=save_status
+#     )
+
+# if __name__ == "__main__":
+#     demo.launch()
 import torch
 import numpy as np
 import cv2
+import json
 import os
-from PIL import Image
+import gradio as gr
 from detectron2.engine import DefaultPredictor
 from detectron2.config import get_cfg
 from detectron2 import model_zoo
 
-# === Set up Detectron2 model ===
+# Create output directory if it doesn't exist
+output_dir = "key/"
+os.makedirs(output_dir, exist_ok=True)
+output_file = os.path.join(output_dir, "keypoints.json")
+
+# Load pre-trained Keypoint R-CNN model
 cfg = get_cfg()
 cfg.merge_from_file(model_zoo.get_config_file("COCO-Keypoints/keypoint_rcnn_R_50_FPN_3x.yaml"))
 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Keypoints/keypoint_rcnn_R_50_FPN_3x.yaml")
 cfg.MODEL.DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-predictor = DefaultPredictor(cfg)
 
-# === Utility ===
-def get_distance(p1, p2):
-    return np.linalg.norm(np.array(p1) - np.array(p2))
+# Load the predictor
+predictor = DefaultPredictor(cfg)
 
-# === Keypoint and Measurement Logic ===
 def process_image(image, user_height_cm):
-    image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-    outputs = predictor(image_cv)
+    # Convert Gradio image input to OpenCV format
+    image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+
+    # Run keypoint detection
+    outputs = predictor(image)
+
+    # Extract keypoints
     instances = outputs["instances"]
     keypoints = instances.pred_keypoints.cpu().numpy().tolist() if instances.has("pred_keypoints") else None
 
     if not keypoints:
-        return "No keypoints detected.", None, None
+        return "No keypoints detected.", None
 
-    keypoints = np.array(keypoints[0])[:, :2]
+    # Save keypoints to JSON
+    with open(output_file, "w") as f:
+        json.dump({"keypoints": keypoints}, f, indent=4)
+
+    keypoints = np.array(keypoints[0])[:, :2]  # Extract (x, y) coordinates
+
+    # COCO format indices
+    NOSE, L_SHOULDER, R_SHOULDER = 0, 5, 6
+    L_ELBOW, R_ELBOW = 7, 8
+    L_WRIST, R_WRIST = 9, 10
+    L_HIP, R_HIP = 11, 12
+    L_ANKLE, R_ANKLE = 15, 16
 
-    # Draw keypoints and skeleton
+    # Define Keypoint Pairs for Drawing Lines (COCO Format)
     skeleton = [(5, 6), (5, 11), (6, 12), (11, 12)]
+
+    # Draw Keypoints
     for x, y in keypoints:
-        cv2.circle(image_cv, (int(x), int(y)), 5, (0, 255, 0), -1)
+        cv2.circle(image, (int(x), int(y)), 5, (0, 255, 0), -1)
+
+    # Draw Skeleton
     for pt1, pt2 in skeleton:
         x1, y1 = map(int, keypoints[pt1])
         x2, y2 = map(int, keypoints[pt2])
-        cv2.line(image_cv, (x1, y1), (x2, y2), (255, 0, 0), 2)
+        cv2.line(image, (x1, y1), (x2, y2), (255, 0, 0), 2)
 
-    # Body part indices
-    NOSE, L_SHOULDER, R_SHOULDER = 0, 5, 6
-    L_WRIST, L_HIP, R_HIP, L_ANKLE, R_ANKLE = 9, 11, 12, 15, 16
+    # Function to calculate Euclidean distance
+    def get_distance(p1, p2):
+        return np.linalg.norm(np.array(p1) - np.array(p2))
 
+    # Calculate full height (consider head length)
     ankle_mid = ((keypoints[L_ANKLE] + keypoints[R_ANKLE]) / 2).tolist()
     pixel_height = get_distance(keypoints[NOSE], ankle_mid)
-    estimated_full_pixel_height = pixel_height / 0.87
-    pixels_per_cm = estimated_full_pixel_height / user_height_cm
-
-    shoulder_width_cm = get_distance(keypoints[L_SHOULDER], keypoints[R_SHOULDER]) / pixels_per_cm
-    waist_width_cm = get_distance(keypoints[L_HIP], keypoints[R_HIP]) / pixels_per_cm
-    pelvis = ((keypoints[L_HIP] + keypoints[R_HIP]) / 2).tolist()
-    neck = ((keypoints[L_SHOULDER] + keypoints[R_SHOULDER]) / 2).tolist()
-    torso_length_cm = get_distance(neck, pelvis) / pixels_per_cm
-    arm_length_cm = get_distance(keypoints[L_SHOULDER], keypoints[L_WRIST]) / pixels_per_cm
 
-    waist_circumference = np.pi * waist_width_cm
-    hip_circumference = waist_circumference / 0.75
+    # Estimated full body height (add approx head length)
+    estimated_full_pixel_height = pixel_height / 0.87  # Since 87% = nose to ankle
+    pixels_per_cm = estimated_full_pixel_height / user_height_cm
 
-    measurements = {
-        "Waist Circumference (cm)": round(waist_circumference, 2),
-        "Hip Circumference (cm)": round(hip_circumference, 2),
-        "Shoulder Width (cm)": round(shoulder_width_cm, 2),
-        "Torso Length (Neck to Pelvis, cm)": round(torso_length_cm, 2),
-        "Full Arm Length (Shoulder to Wrist, cm)": round(arm_length_cm, 2),
-    }
+    # Waist and shoulder measurements
+    shoulder_width_px = get_distance(keypoints[L_SHOULDER], keypoints[R_SHOULDER])
+    waist_width_px = get_distance(keypoints[L_HIP], keypoints[R_HIP])
 
-    return measurements, cv2.cvtColor(image_cv, cv2.COLOR_BGR2RGB), keypoints.tolist()
+    # Convert to cm
+    shoulder_width_cm = shoulder_width_px / pixels_per_cm
+    waist_width_cm = waist_width_px / pixels_per_cm
 
-# === Save to DB ===
-# def save_to_database(measurements, image, user_height_cm, user_id):
-#     if not user_id:
-#         return "❌ user_id missing from URL."
-
-#     if measurements is None or image is None:
-#         return "⚠️ No data to save."
-
-#     buffered = BytesIO()
-#     pil_image = Image.fromarray(image)
-#     pil_image.save(buffered, format="JPEG")
-#     img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    # Torso Length (Neck to Pelvis)
+    pelvis = ((keypoints[L_HIP] + keypoints[R_HIP]) / 2).tolist()
+    neck = ((keypoints[L_SHOULDER] + keypoints[R_SHOULDER]) / 2).tolist()
+    torso_length_px = get_distance(neck, pelvis)
+    torso_length_cm = torso_length_px / pixels_per_cm
 
-#     payload = {
-#         "imageBase64": img_str,
-#         "heightCm": user_height_cm,
-#         "measurements": measurements
-#     }
+    # Arm Length (Shoulder to Wrist)
+    arm_length_px = get_distance(keypoints[L_SHOULDER], keypoints[L_WRIST])
+    arm_length_cm = arm_length_px / pixels_per_cm
 
-    # try:
-    #     response = requests.post(
-    #         f"https://9d68-210-212-162-140.ngrok-free.app/upload/{user_id}",
-    #         json=payload
-    #     )
-    #     if response.status_code == 201:
-    #         return "✅ Measurements and image saved to database!"
-    #     else:
-    #         return f"❌ Failed: {response.status_code} - {response.text}"
-    # except Exception as e:
-    #     return f"⚠️ Error during save: {str(e)}"
-
-
-
-def save_to_database(measurements, image, user_height_cm, user_id):
-    if not user_id:
-        return "❌ user_id missing from URL."
-    if measurements is None or image is None:
-        return "⚠️ No data to save."
-
-    buffered = BytesIO()
-    pil_image = Image.fromarray(image)
-    pil_image.save(buffered, format="JPEG")
-    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
-
-    payload = {
-        "imageBase64": img_str,
-        "heightCm": user_height_cm,
-        "waistCircumferenceCm": measurements.get("Waist Circumference (cm)"),
-        "hipcircumference": measurements.get("Hip Circumference (cm)"),
-        "shoulderwidth": measurements.get("Shoulder Width (cm)"),
-        "torsolength": measurements.get("Torso Length (Neck to Pelvis, cm)"),
-        "fullarmlength": measurements.get("Full Arm Length (Shoulder to Wrist, cm)"),
-    }
-
-    try:
-        response = requests.post(
-            f"https://7da2-2409-4042-6e81-1806-de6-b8e5-836c-6b95.ngrok-free.app/upload/{user_id}",
-            json=payload
-        )
-        if response.status_code == 201:
-            return "✅ Measurements and image saved to database!"
-        else:
-            return f"❌ Failed: {response.status_code} - {response.text}"
-    except Exception as e:
-        return f"⚠️ Error during save: {str(e)}"
-
-
-# === Gradio App ===
-with gr.Blocks() as demo:
-    gr.Markdown("# 📏 AI-Powered Body Measurement Tool")
-    user_id_state = gr.State()
-
-    @demo.load(inputs=None, outputs=[user_id_state])
-    def load_user_id(request: gr.Request):
-        return request.query_params.get("user_id", "")
-
-    with gr.Row():
-        with gr.Column():
-            image_input = gr.Image(label="Upload Your Full Body Image", type="pil")
-            height_input = gr.Number(label="Your Real Height (in cm)")
-            process_button = gr.Button("📐 Extract Measurements")
-
-        with gr.Column():
-            output_image = gr.Image(label="Detected Keypoints")
-            measurement_output = gr.JSON(label="Body Measurements")
-
-    with gr.Row():
-        save_button = gr.Button("💾 Save to Backend")
-        save_status = gr.Textbox(label="Status", interactive=False)
-
-    # Store results for save
-    processed_img = gr.State()
-    processed_data = gr.State()
-
-    process_button.click(
-        fn=process_image,
-        inputs=[image_input, height_input],
-        outputs=[measurement_output, output_image, processed_data]
-    ).then(
-        fn=lambda img: img,
-        inputs=[output_image],
-        outputs=processed_img
-    )
-
-    save_button.click(
-        fn=save_to_database,
-        inputs=[measurement_output, processed_img, height_input, user_id_state],
-        outputs=save_status
-    )
-
-if __name__ == "__main__":
-    demo.launch()
+    # Calculate waist and hip circumference (Ellipse approximation)
+    # Waist circumference ≈ π × (waist_width / 2) × 2
+    waist_circumference = np.pi * waist_width_cm
+    hip_circumference = waist_circumference / 0.75  # Assuming hip is slightly bigger than waist
+
+    # Improved body measurement calculation
+    def calculate_body_measurements(waist_circumference, hip_circumference, shoulder_width_cm, torso_length_cm, arm_length_cm):
+        return {
+            "Waist Circumference (cm)": round(waist_circumference, 2),
+            "Hip Circumference (cm)": round(hip_circumference, 2),
+            "Shoulder Width (cm)": round(shoulder_width_cm, 2),
+            "Torso Length (Neck to Pelvis, cm)": round(torso_length_cm, 2),
+            "Full Arm Length (Shoulder to Wrist, cm)": round(arm_length_cm, 2),
+        }
+
+    measurements = calculate_body_measurements(waist_circumference, hip_circumference, shoulder_width_cm, torso_length_cm, arm_length_cm)
+
+    return measurements, cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+# Gradio Interface
+demo = gr.Interface(
+    fn=process_image,
+    inputs=[gr.Image(type="pil"), gr.Number(label="User Height (cm)")],
+    outputs=[gr.JSON(label="Measurements"), gr.Image(type="pil", label="Keypoint Overlay")],
+    title="Keypoint Measurement Extractor",
+    description="Upload an image, enter your height, and get body measurements based on keypoints.",
+)
+
+demo.launch()