add file

Dockerfile

@@ -0,0 +1,14 @@
+# read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,39 @@
+from fastapi import FastAPI, File, UploadFile
+from fastapi.responses import JSONResponse
+import uvicorn
+from ssim1 import compare_images  # Import the compare_image function
+
+import cv2
+import numpy as np
+
+app = FastAPI()
+
+@app.post("/compare")
+async def compare(image1: UploadFile = File(...), image2: UploadFile = File(...)):
+    try:
+
+        # Read images as binary
+        image1_content = await image1.read()
+        image2_content = await image2.read()
+        
+        nparr1 = np.frombuffer(image1_content, np.uint8)
+        img1 = cv2.imdecode(nparr1, cv2.IMREAD_COLOR)
+
+        nparr2 = np.frombuffer(image2_content, np.uint8)
+        img2 = cv2.imdecode(nparr2, cv2.IMREAD_COLOR)
+
+        # Call the compare_image function. You might need to adjust this part
+        # depending on how compare_image is implemented in ssim1.py.
+        # Assuming compare_image accepts bytes and returns a similarity score or result
+        result = compare_images(img1, img2)
+        # print(result)
+        # Return the result as JSON
+        return JSONResponse(content={"result": result})
+    except Exception as e:
+        print(e)
+        return JSONResponse(content={"error": True})
+
+
+# Run the application
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+opencv-python
+numpy

ssim1.py

@@ -0,0 +1,102 @@
+import cv2
+import numpy as np
+import time
+
+# Initialize Haar Cascade face detector
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+# Function to detect and crop the face from an image
+def detect_and_crop_face(image, cascade):
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    faces = cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+    if len(faces) == 0:
+        return None
+    (x, y, w, h) = faces[0]
+    return image[y:y+h, x:x+w]
+
+# Custom SSIM computation function
+def compute_ssim(img1, img2):
+    C1 = (0.01 * 255) ** 2
+    C2 = (0.03 * 255) ** 2
+    img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
+    img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
+    img1 = cv2.resize(img1, (100, 100))
+    img2 = cv2.resize(img2, (100, 100))
+
+    target_file_name1 = 'compare-faces/' +  ' - ' + str(time.time()) + '.jpg'
+    cv2.imwrite(
+        target_file_name1,
+        img1,
+    )
+    target_file_name2 = 'compare-faces/' +  ' - ' + str(time.time()) + '.jpg'
+    cv2.imwrite(
+        target_file_name2,
+        img2,
+    )
+
+    mean_img1 = np.mean(img1)
+    mean_img2 = np.mean(img2)
+    var_img1 = np.var(img1)
+    var_img2 = np.var(img2)
+    std_img1 = np.sqrt(var_img1)
+    std_img2 = np.sqrt(var_img2)
+    covariance = np.mean((img1 - mean_img1) * (img2 - mean_img2))
+    numerator = (2 * mean_img1 * mean_img2 + C1) * (2 * covariance + C2)
+    denominator = (mean_img1 ** 2 + mean_img2 ** 2 + C1) * (var_img1 + var_img2 + C2)
+    ssim = numerator / denominator
+    return ssim
+
+
+def compare_images(image1_path, image2_path):
+    # image1 = cv2.imread(image1_path)
+    # image2 = cv2.imread(image2_path)
+
+    image1 = image1_path
+    image2 = image2_path
+
+    face1 = detect_and_crop_face(image1, face_cascade)
+    face2 = detect_and_crop_face(image2, face_cascade)
+    # Results variable
+    result = {}
+
+    # Compare the faces if both were detected and cropped
+    if face1 is not None and face2 is not None:
+        ssim_index = compute_ssim(face1, face2)
+        similarity_percentage = ssim_index * 100
+        result["Similarity Percentage"] = similarity_percentage
+        result["Are Faces Similar"] = "Yes" if similarity_percentage > 50 else "No"
+    else:
+        result["Error"] = "Could not detect a face in one or both of the images. Please try with different images."
+        result['Photo 1'] = 'Exist' if face1 is not None else 'Not Exist'
+        result['Photo 2'] = 'Exist' if face2 is not None else 'Not Exist'
+    return result
+
+
+
+# =================================================================
+# INTERNAL TEST
+# =================================================================
+
+# # Load the images
+# # Tes 1
+# image1_path = './dataset/ditya/0106.png'
+# image2_path = './dataset/zidni/0109.png'
+
+# # Tes 2
+# # image1_path = './dataset/rara/User.1.1.jpg'
+# # image2_path = './dataset/rara/User.1.3.jpg'
+
+# # Tes 3
+# # image1_path = './dataset/ika/User.2.5.jpg'
+# # image2_path = './dataset/ika/User.2.37.jpg'
+
+# # Tes 4
+# # image1_path = './dataset/rara/User.1.5.jpg'
+# # image2_path = './dataset/ika/User.2.37.jpg'
+
+# # Tes 5
+# image1_path = './dataset/ditya/0104.png'
+# image2_path = './dataset/ditya/0105.png'
+
+# result = compare_images(image1_path, image2_path)
+# print(result)

ssim1_test.py

@@ -0,0 +1,78 @@
+import os
+import random
+
+# Assuming cosine5.py is correctly set up with a compare_images function
+from ssim1 import compare_images
+
+# Find Threshold
+from findthreshold import find_best_threshold
+
+# Path to the dataset directory
+dataset_path = './dataset'
+
+def run_test(dataset_path, iterations=10):
+    i = 0
+    r = []
+
+    for _ in range(iterations):
+        # Randomly decide if the images should come from the same folder or different ones
+        same_folder = random.choice([True, False])
+        
+        # Get the list of person directories in the dataset
+        persons = [person for person in os.listdir(dataset_path) if os.path.isdir(os.path.join(dataset_path, person))]
+
+        if same_folder:
+            # Randomly select a person's directory and use it for both images
+            selected_person = random.choice(persons)
+            person_paths = [os.path.join(dataset_path, selected_person), os.path.join(dataset_path, selected_person)]
+        else:
+            # Randomly select two person's directories for the two images
+            selected_persons = random.sample(persons, 2) if len(persons) >= 2 else [random.choice(persons), random.choice(persons)]
+            person_paths = [os.path.join(dataset_path, person) for person in selected_persons]
+
+        images = []
+        for person_path in person_paths:
+            # Get the list of image files in the person's directory
+            person_images = [img for img in os.listdir(person_path) if os.path.isfile(os.path.join(person_path, img))]
+            # Randomly select an image from the person's directory
+            images.append(random.choice(person_images))
+
+        # Construct the full image paths
+        image_paths = [os.path.join(person_paths[i], images[i]) for i in range(2)]
+
+        # Compare the images and print the result
+        similarity_result = compare_images(image_paths[0], image_paths[1])
+        # print(f"Test iteration: Comparing images {images[0]} and {images[1]} {'from the same folder' if same_folder else 'from different folders'}")
+        # label = ''
+        # if same_folder: label += 'Yes - '
+        # else: label += 'No - '
+
+        # label += image_paths[0]
+        # label += ' / '
+        # label += image_paths[1]
+        # print(label)
+        
+        # print(similarity_result)
+        # print("\n")
+        predict_result = 'YES' if same_folder else 'NO'
+        actual_result = similarity_result.get("Are Faces Similar")
+        error = similarity_result.get('Error')
+        photo_1 = similarity_result.get('Photo 1')
+        photo_2 = similarity_result.get('Photo 2')
+
+        score = similarity_result.get('Similarity Percentage')
+
+        label = image_paths[0] + ',' + image_paths[1] + ',' + str(photo_1) + ',' + str(photo_2) + ',' + str(score) + ',' + str(predict_result) + ',' + str(actual_result) + ',' + str(error)
+        print(label)
+        # r[i]['score_similarity'] = score
+        # r[i]['predict_result'] = predict_result
+        r.append({'score_similarity': 0 if score == None else score, 'predict_result': predict_result})
+        i = i+1
+
+    print(r)
+    best_threshold, best_accuracy = find_best_threshold(r)
+    print(f"Best Threshold: {best_threshold}, Best Accuracy: {best_accuracy}")
+
+# Specify how many iterations of the test you want to run
+number_of_tests = 5  # For example, 5 iterations
+run_test(dataset_path, iterations=number_of_tests)