Classifier Added

SkinBurns_Classification.py

@@ -0,0 +1,65 @@
+import os
+import cv2
+import numpy as np
+from skimage.feature import local_binary_pattern, graycomatrix, graycoprops
+from sklearn.svm import SVC
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report, accuracy_score
+import glob
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import StandardScaler
+import pickle
+
+# Parameters for feature extraction
+LBP_RADIUS = 1
+LBP_POINTS = 8 * LBP_RADIUS
+GLCM_DISTANCES = [1, 2, 3]  # Increased distances
+GLCM_ANGLES = [0, np.pi/4, np.pi/2, 3*np.pi/4]  # Increased angles
+scaler = StandardScaler()
+
+def extract_color_histogram(image, bins=(4, 4, 4)):
+    """Extract color histogram features from an image."""
+    hist = cv2.calcHist([image], [0, 1, 2], None, bins, [0, 256, 0, 256, 0, 256])
+    cv2.normalize(hist, hist)
+    return hist.flatten()
+
+def extract_lbp_features(image, radius=LBP_RADIUS, points=LBP_POINTS):
+    """Extract Local Binary Pattern (LBP) features from an image."""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    lbp = local_binary_pattern(gray, points, radius, method='uniform')
+    (hist, _) = np.histogram(lbp.ravel(), bins=np.arange(0, points + 3), range=(0, points + 2))
+    hist = hist.astype('float')
+    hist /= (hist.sum() + 1e-6)
+    return hist
+
+def extract_glcm_features(image, distances=GLCM_DISTANCES, angles=GLCM_ANGLES):
+    """Extract Gray-Level Co-occurrence Matrix (GLCM) features from an image."""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    glcm = graycomatrix(gray, distances=distances, angles=angles, symmetric=True, normed=True)
+    features = []
+    for prop in ['contrast', 'dissimilarity', 'homogeneity', 'energy', 'correlation']:
+        feature = graycoprops(glcm, prop)
+        features.extend(feature.flatten())
+    return np.array(features)
+
+def extract_invariant_moments(image):
+    """Extract invariant moment features from an image."""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    moments = cv2.moments(gray)
+    hu_moments = cv2.HuMoments(moments).flatten()
+    return hu_moments
+
+
+
+def extract_features(image_path):
+    """Extract combined features from an image."""
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"Warning: Unable to read image at {image_path}")
+        return None
+    color_hist = extract_color_histogram(image)
+    lbp_features = extract_lbp_features(image)
+    glcm_features = extract_glcm_features(image)
+    invariant_moments = extract_invariant_moments(image)
+    return np.hstack([color_hist, lbp_features, glcm_features, invariant_moments])
+

app.py

@@ -1,10 +1,15 @@
+import os
+import pickle
 from fastapi import FastAPI, File, UploadFile
+from fastapi.responses import JSONResponse
 from pymongo.mongo_client import MongoClient
 from pymongo.server_api import ServerApi
 import cloudinary
 import cloudinary.uploader
 from cloudinary.utils import cloudinary_url
+from SkinBurns_Classification import extract_features
 from SkinBurns_Segmentation import segment_skin_burns 
+import requests
 
 app = FastAPI()
 
@@ -57,32 +62,84 @@ async def upload_sample(file: UploadFile = File(...)):
         return {"uploaded_url": uploaded_url}
     except Exception as e:
         return {"error": str(e)}
-
-@app.post("/skin_burns/segment")
-async def Segment_Burns(file: UploadFile = File(...), output_path='segmented_image.png'):
+    
+    
+@app.post("/skin_burns/predict")
+async def predict_burn(file: UploadFile = File(...)):
     try:
-        # Save the uploaded file temporarily
-        with open(file.filename, "wb") as temp_file:
-            temp_file.write(await file.read())
+        # Upload to Cloudinary
+        upload_result = cloudinary.uploader.upload(file.file, public_id=f"predict_{file.filename}")
+        cloudinary_url = upload_result["secure_url"]
 
-        # Call the segmentation function
-        segmented_image_path = segment_skin_burns(file.filename, output_path)
+        # Download the image from Cloudinary
+        response = requests.get(cloudinary_url)
+        temp_image_path = f"predict_{file.filename}"
+        with open(temp_image_path, 'wb') as out_file:
+            out_file.write(response.content)
 
-        # Upload the segmented image to Cloudinary
-        result = cloudinary.uploader.upload(segmented_image_path, public_id=f"segmented_{file.filename}")
-        uploaded_url = result["secure_url"]
+        # Load the trained SVM model
+        with open('svm_model.pkl', 'rb') as model_file:
+            loaded_svm = pickle.load(model_file)
 
-        # Save segmented image URL to MongoDB
-        collection = db["Images"]
-        doc = {"filename": f"segmented_{file.filename}", "url": uploaded_url}
+        # Extract features from the downloaded image
+        features = extract_features(temp_image_path)
+
+        # Delete temporary image file
+        os.remove(temp_image_path)
+
+        if features is None:
+            return JSONResponse(content={"error": "Failed to extract features from the image."}, status_code=400)
+
+        # Reshape and predict
+        features = features.reshape(1, -1)
+        prediction = loaded_svm.predict(features)
+        prediction_label = "Burn" if prediction[0] == 1 else "No Burn"
+
+        #Save result to MongoDB (if needed)
+        collection = db["Predictions"]
+        doc = {"filename": file.filename, "url": cloudinary_url, "prediction": prediction_label}
         collection.insert_one(doc)
 
-        return {"segmented_image_url": uploaded_url}
+        return {
+            "prediction": prediction_label,
+            "image_url": cloudinary_url
+        }
+
     except Exception as e:
-        return {"error": str(e)}
+        return JSONResponse(content={"error": str(e)}, status_code=500)
     
+@app.post("/predict_burn")
+async def predict_burn(file: UploadFile = File(...)):
+    try:
+        # Save the uploaded file temporarily
+        temp_file_path = f"temp_{file.filename}"
+        with open(temp_file_path, "wb") as temp_file:
+            temp_file.write(await file.read())
+
+        # Load the saved SVM model
+        with open('svm_model.pkl', 'rb') as model_file:
+            loaded_svm = pickle.load(model_file)
 
+        # Extract features from the uploaded image
+        features = extract_features(temp_file_path)
 
+        # Remove the temporary file
+        os.remove(temp_file_path)
+
+        if features is None:
+            return JSONResponse(content={"error": "Failed to extract features from the image."}, status_code=400)
+
+        # Reshape features to match the SVM model's expected input
+        features = features.reshape(1, -1)
+
+        # Predict the class
+        prediction = loaded_svm.predict(features)
+        prediction_label = "Burn" if prediction[0] == 1 else "No Burn"
+
+        return {"prediction": prediction_label}
+
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
 
 
 

requirements.txt

@@ -9,4 +9,5 @@ scipy
 tensorly
 scikit-learn
 opencv-python
-matplotlib
+matplotlib
+glob2

svm_model.pkl

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