Add Streamlit app

app.py

@@ -0,0 +1,130 @@
+import streamlit as st
+import cv2 as cv
+import numpy as np
+
+# Paths to your files
+model_path = "graph_opt.pb"
+
+# Load the TensorFlow model
+net = cv.dnn.readNetFromTensorflow(model_path)
+if net.empty():
+    raise FileNotFoundError(f"Model file not found or cannot be loaded: {model_path}")
+
+BODY_PARTS = {"Nose": 0, "Neck": 1, "RShoulder": 2, "RElbow": 3, "RWrist": 4,
+              "LShoulder": 5, "LElbow": 6, "LWrist": 7, "RHip": 8, "RKnee": 9,
+              "RAnkle": 10, "LHip": 11, "LKnee": 12, "LAnkle": 13, "REye": 14,
+              "LEye": 15, "REar": 16, "LEar": 17, "Background": 18}
+
+# Adjust POSE_PAIRS to include only wrist to elbow parts
+POSE_PAIRS = [["RElbow", "RWrist"], ["LElbow", "LWrist"]]
+
+width = 368
+height = 368
+inWidth = width
+inHeight = height
+thr = 0.2
+
+def overlay_image_alpha(img, img_overlay, pos, alpha_mask):
+    x, y = pos
+
+    y1, y2 = max(0, y), min(img.shape[0], y + img_overlay.shape[0])
+    x1, x2 = max(0, x), min(img.shape[1], x + img_overlay.shape[1])
+
+    y1o, y2o = max(0, -y), min(img_overlay.shape[0], img.shape[0] - y)
+    x1o, x2o = max(0, -x), min(img_overlay.shape[1], img.shape[1] - x)
+
+    if y1 >= y2 or x1 >= x2 or y1o >= y2o or x1o >= x2o:
+        return
+
+    img_crop = img[y1:y2, x1:x2]
+    img_overlay_crop = img_overlay[y1o:y2o, x1o:x2o]
+    alpha = alpha_mask[y1o:y2o, x1o:x2o, np.newaxis]
+    alpha_inv = 1.0 - alpha
+
+    img_crop[:] = alpha * img_overlay_crop + alpha_inv * img_crop
+
+def poseDetector(frame, overlay_img):
+    frameWidth = frame.shape[1]
+    frameHeight = frame.shape[0]
+
+    net.setInput(cv.dnn.blobFromImage(frame, 1.0, (inWidth, inHeight), (127.5, 127.5, 127.5), swapRB=True, crop=False))
+    out = net.forward()
+    out = out[:, :19, :, :]
+
+    assert (len(BODY_PARTS) == out.shape[1])
+
+    points = []
+    for i in range(len(BODY_PARTS)):
+        heatMap = out[0, i, :, :]
+
+        _, conf, _, point = cv.minMaxLoc(heatMap)
+        x = (frameWidth * point[0]) / out.shape[3]
+        y = (frameHeight * point[1]) / out.shape[2]
+
+        points.append((int(x), int(y)) if conf > thr else None)
+
+    for pair in POSE_PAIRS:
+        partFrom = pair[0]
+        partTo = pair[1]
+
+        assert (partFrom in BODY_PARTS)
+        assert (partTo in BODY_PARTS)
+
+        idFrom = BODY_PARTS[partFrom]
+        idTo = BODY_PARTS[partTo]
+
+        if points[idFrom] and points[idTo]:
+            angle = np.degrees(np.arctan2(points[idTo][1] - points[idFrom][1], points[idTo][0] - points[idFrom][0]))
+            adjusted_angle = angle + 270
+
+            length = int(np.sqrt((points[idTo][0] - points[idFrom][0])**2 + (points[idTo][1] - points[idFrom][1])**2))
+            reduced_length = int(length * 0.5)
+            overlay_resized = cv.resize(overlay_img, (reduced_length, int(overlay_img.shape[0] * 0.5)))
+
+            M = cv.getRotationMatrix2D((overlay_resized.shape[1] / 2, overlay_resized.shape[0] / 2), adjusted_angle, 1)
+            overlay_rotated = cv.warpAffine(overlay_resized, M, (overlay_resized.shape[1], overlay_resized.shape[0]), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_CONSTANT, borderValue=(0, 0, 0, 0))
+
+            wrist_position = points[idTo]
+            position = (int(wrist_position[0] - overlay_rotated.shape[1] / 2), int(wrist_position[1] - overlay_rotated.shape[0] / 2))
+
+            alpha_mask = overlay_rotated[:, :, 3] / 255.0
+            overlay_image_alpha(frame, overlay_rotated[:, :, :3], position, alpha_mask)
+
+    t, _ = net.getPerfProfile()
+    return frame
+
+def main():
+    st.title("Webcam Stream with Pose Detection and Tattoo Overlay")
+
+    st.sidebar.header("Upload Tattoo Image")
+    uploaded_tattoo_img = st.sidebar.file_uploader("Upload Tattoo Image", type=["png"])
+
+    if uploaded_tattoo_img:
+        tattoo_img = cv.imdecode(np.frombuffer(uploaded_tattoo_img.read(), np.uint8), cv.IMREAD_UNCHANGED)
+
+        run = st.checkbox('Run')
+
+        # Access the webcam (0 is the default camera)
+        cap = cv.VideoCapture(0)
+
+        if not cap.isOpened():
+            st.error("Unable to access the camera")
+            return
+
+        stframe = st.empty()
+
+        while run:
+            ret, frame = cap.read()
+            if not ret:
+                st.error("Failed to capture image")
+                break
+
+            frame = poseDetector(frame, tattoo_img)
+            frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
+            stframe.image(frame, channels="RGB")
+
+        # Release the camera when done
+        cap.release()
+
+if __name__ == "__main__":
+    main()

graph_opt.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51f84ea82b3d0143dd4cf362e018c125e832c64771908ee8766fbd8b0328008d
+size 7804434

requirements.txt

@@ -0,0 +1 @@
+streamlit