Spaces:
Sleeping
Sleeping
| 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.") | |