app.py

import streamlit as st
from PIL import Image
import io
import cv2
import numpy as np
import matplotlib.pyplot as plt
import io as BytesIO
from rembg import remove
import mediapipe as mp
from scipy.spatial import distance as dist

ring_size_dict = {
    14.0: 3,
    14.4: 3.5,
    14.8: 4,
    15.2: 4.5,
    15.6: 5,
    16.0: 5.5,
    16.45: 6,
    16.9: 6.5,
    17.3: 7,
    17.7: 7.5,
    18.2: 8,
    18.6: 8.5,
    19.0: 9,
    19.4: 9.5,
    19.8: 10,
    20.2: 10.5,
    20.6: 11,
    21.0: 11.5,
    21.4: 12,
    21.8: 12.5,
    22.2: 13,
    22.6: 13.5
}

def calculate_pixel_per_metric(image, known_diameter_of_coin=25):
    grayed = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    pixel_per_metric = None
    mm_per_pixel = None

    height, width = grayed.shape
    x_start, y_start = 0, 0
    x_end, y_end = width // 2, height // 2

    roi = grayed[y_start:y_end, x_start:x_end]
    roi_color = image[y_start:y_end, x_start:x_end]

    blurred = cv2.GaussianBlur(grayed, (9, 9), 2)

    circles = cv2.HoughCircles(
        blurred,
        cv2.HOUGH_GRADIENT,
        dp=1,
        minDist=50,
        param1=100,
        param2=30,
        minRadius=10,
        maxRadius=100
    )

    if circles is not None:
        circles = np.round(circles[0, :]).astype("int")
        largest_circle = max(circles, key=lambda c: c[2])
        (x, y, r) = largest_circle

        cv2.circle(image, (x, y), r, (0, 255, 0), 4)
        cv2.rectangle(image, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255), -1)

        diameter = 2 * r
        if pixel_per_metric is None:
            pixel_per_metric = diameter / known_diameter_of_coin
            mm_per_pixel = known_diameter_of_coin / diameter
            diameter_in_mm = diameter / pixel_per_metric
            cv2.putText(
                image,
                f"Diameter: {diameter} px, Diameter in mm: {diameter_in_mm:.2f} mm",
                (x - 50, y - r - 10),
                cv2.FONT_HERSHEY_SIMPLEX,
                1.5,
                (255, 255, 255),
                3
            )
            
    return pixel_per_metric, mm_per_pixel, image

def process_image(image):
    return remove(image)

def calculate_pip_width(image, original_img, pixel_per_metric):
    def calSize(xA, yA, xB, yB, color_circle, color_line, img):
        d = dist.euclidean((xA, yA), (xB, yB))
        cv2.circle(img, (int(xA), int(yA)), 5, color_circle, -1)
        cv2.circle(img, (int(xB), int(yB)), 5, color_circle, -1)
        cv2.line(img, (int(xA), int(yA)), (int(xB), int(yB)), color_line, 2)
        d_mm = d / pixel_per_metric
        d_mm = d_mm
        cv2.putText(img, "{:.1f}".format(d_mm), (int(xA - 15), int(yA - 10)), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (255, 255, 255), 2)
        # print(d_mm)
        return d_mm, img
    
    og_img = original_img.copy()
    imgH, imgW, _ = image.shape
    imgcpy = image.copy()
    image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    _, binary_image = cv2.threshold(image_gray, 1, 255, cv2.THRESH_BINARY)
    contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    contour_image = np.zeros_like(image_gray)
    cv2.drawContours(contour_image, contours, -1, (255), thickness=cv2.FILLED)
    cv2.drawContours(imgcpy, contours, -1, (0, 255, 0), 2)
    # print("length : ",len(contours))
    
    d_mm = 0  
    marked_img = image.copy()

    if len(contours) > 0:
        # print("hi")
        cnt = max(contours, key=cv2.contourArea)
        frame2 = cv2.cvtColor(og_img, cv2.COLOR_BGR2RGB)
        handsLM = mp.solutions.hands.Hands(max_num_hands=1, min_detection_confidence=0.8, min_tracking_confidence=0.8)
        pr = handsLM.process(frame2)
        # print(pr.multi_hand_landmarks)
        if pr.multi_hand_landmarks:
            # print("inside")
            for hand_landmarks in pr.multi_hand_landmarks:
                lmlist = []
                for id, landMark in enumerate(hand_landmarks.landmark):
                    xPos, yPos = int(landMark.x * imgW), int(landMark.y * imgH)
                    lmlist.append([id, xPos, yPos])

                if len(lmlist) != 0:
                    pip_joint = [lmlist[14][1], lmlist[14][2]]
                    mcp_joint = [lmlist[13][1], lmlist[13][2]]

                    m2 = (pip_joint[1] - mcp_joint[1]) / (pip_joint[0] - mcp_joint[0])
                    m1 = -1 / m2
                    b = pip_joint[1] - m1 * pip_joint[0]

                    x1, x2 = pip_joint[0], pip_joint[0]
                    y1 = m1 * x1 + b
                    y2 = m1 * x2 + b

                    result = 1.0
                    while result > 0:
                        result = cv2.pointPolygonTest(cnt, (x1, y1), False)
                        x1 += 1
                        y1 = m1 * x1 + b
                    x1 -= 1

                    result = 1.0
                    while result > 0:
                        result = cv2.pointPolygonTest(cnt, (x2, y2), False)
                        x2 -= 1
                        y2 = m1 * x2 + b
                    x2 += 1

                    d_mm, marked_img = calSize(x1, y1, x2, y2, (255, 0, 0), (255, 0, 255), original_img)

    return original_img, d_mm, imgcpy, marked_img

def show_resized_image(images, titles, scale=0.5):
    num_images = len(images)
    fig, axes = plt.subplots(1, num_images, figsize=(15, 5))

    if num_images == 1:
        axes = [axes]

    for ax, img, title in zip(axes, images, titles):
        resized_image = cv2.resize(img, None, fx=scale, fy=scale, interpolation=cv2.INTER_LINEAR)
        ax.imshow(cv2.cvtColor(resized_image, cv2.COLOR_BGR2RGB))
        ax.set_title(title)
        ax.axis('off')

    plt.tight_layout()
    img_stream = BytesIO.BytesIO()
    plt.savefig(img_stream, format='png')
    img_stream.seek(0)
    plt.close(fig)
    return img_stream

def get_ring_size(mm_value):
    if mm_value in ring_size_dict:
        return ring_size_dict[mm_value]
    else:
        closest_mm = min(ring_size_dict.keys(), key=lambda x: abs(x - mm_value))
        return ring_size_dict[closest_mm]

st.set_page_config(layout="wide", page_title="Ring Size Measurement")

st.write("## Determine Your Ring Size")
st.write(
    "📏 Upload an image of your finger to measure the width and determine your ring size. The measurement will be displayed along with a visual breakdown of the image processing flow."
)
st.sidebar.write("## Upload :gear:")

MAX_FILE_SIZE = 5 * 1024 * 1024  # 5MB

def process_image_and_get_results(upload):
    image = Image.open(upload)
    # image =  cv2.imread(upload)
    image_np = np.array(image)
    image_np = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
    original_img = image_np.copy()
    og_img1 = image_np.copy()
    og_img2 = image_np.copy()

    pixel_per_metric, mm_per_pixel, image_with_coin_info = calculate_pixel_per_metric(image_np)
    processed_image = process_image(og_img1)
    image_with_pip_width, width_mm, contour_image, pip_mark_img = calculate_pip_width(processed_image, original_img, pixel_per_metric)

    ring_size = get_ring_size(width_mm)
    return {
        "processed_image": pip_mark_img,
        "original_image": og_img2,
        "image_with_coin_info": image_with_coin_info,
        "contour_image": contour_image,
        "width_mm": width_mm,
        "ring_size": ring_size
    }

def show_how_it_works(processed_image):
    st.write("## How It Works")
    st.write("Here's a step-by-step breakdown of how your image is processed to determine your ring size:")
    st.image(processed_image, caption="Image Processing Flow", use_column_width=True)

col1, col2 = st.columns(2)
my_upload = st.sidebar.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])

if my_upload is not None:
    if my_upload.size > MAX_FILE_SIZE:
        st.error("The uploaded file is too large. Please upload an image smaller than 5MB.")
    else:
        st.write("## Image Processing Flow")
        results = process_image_and_get_results(my_upload)

        col1.write("Uploaded Image :camera:")
        col1.image(cv2.cvtColor(results["original_image"], cv2.COLOR_BGR2RGB), caption="Uploaded Image")

        col2.write("Processed Image :wrench:")
        col2.image(cv2.cvtColor(results["processed_image"], cv2.COLOR_BGR2RGB), caption="Processed Image with PIP Width")

        st.write(f"📏 The width of your finger is {results['width_mm']:.2f} mm, and the estimated ring size is {results['ring_size']:.1f}.")

        if st.button("How it Works"):
            st.write("## How It Works")
            st.write("Here's a step-by-step breakdown of how your image is processed to determine your ring size:")
            img_stream = show_resized_image(
                [results["original_image"], results["image_with_coin_info"], results["contour_image"], results["processed_image"]],
                ['Original Image', 'Image with Coin Info', 'Contour Boundary Image', 'Ring Finger Width'],
                scale=0.5
            )
            st.image(img_stream, caption="Processing Flow", use_column_width=True)
else:
    st.info("Please upload an image to get started.")