Updated Burns

SkinBurns_Classification.py

@@ -1,65 +1,152 @@
-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)
+import os as _os
+import cv2 as _cv2
+import numpy as _np
+import glob as _glob
+import joblib as _jb
+import matplotlib.pyplot as _plt
+
+from skimage.feature import local_binary_pattern as _lbp, graycomatrix as _gcm, graycoprops as _gcp
+from sklearn.model_selection import train_test_split as _tts
+from sklearn.metrics import classification_report as _cr, accuracy_score as _acc
+from sklearn.svm import SVC as _S
+from sklearn.ensemble import RandomForestClassifier as _RF
+from sklearn.linear_model import LogisticRegression as _LR
+
+# distances and angles for GLCM
+def  generateAngles():
+    angs = [_np.pi * i / 5 for i in range(5)]          # five angles at 0, π/5, 2π/5, 3π/5, 4π/5
+    s = "1.2,2.2,3.1"                                     # string of distances
+    dists = [float(x) for x in s.split(",")]             # parse distances to floats
+    return angs, dists
+
+(_bestangles, _bestglcmdist) =  generateAngles()
+
+# best parameters for LBP
+_bestpoints = 9
+_bestradius = 1
+
+# SVM hyperparameters
+def  generateSVM_Args():
+    kern = 'linear'
+    Cval = 2.1
+    gamma = 'scale'
+    rs = 42
+    return {'kernel': kern, 'C': Cval, 'gamma': gamma, 'random_state': rs}
+
+# Random Forest hyperparameters
+def  generateRF_Args():
+    ne = 110
+    rs = 40
+    nj = -1
+    return {'n_estimators': ne, 'random_state': rs, 'n_jobs': nj}
+
+# Logistic Regression hyperparameters
+def  generateLR_Args():
+    mc = 'multinomial'
+    solv = 'lbfgs'
+    mi = 900
+    rs = 37
+    return {'multi_class': mc, 'solver': solv, 'max_iter': mi, 'random_state': rs}
+
+# Color feature extraction: compute 3D histogram component A
+def fun_colorA(img):
+    return _cv2.calcHist([img], [0,1,2], None, (5,5,5), [0,256,0,256,0,256])
+
+# Color feature extraction: normalize and flatten histogram
+def fun_colorB(hist_raw):
+    _cv2.normalize(hist_raw, hist_raw)
+    return hist_raw.flatten()
+
+# Full color histogram feature
+def fun_color(img):
+    return fun_colorB(fun_colorA(img))
+
+# Convert image to grayscale for LBP
+def lbpGray(img):
+    return _cv2.cvtColor(img, _cv2.COLOR_BGR2GRAY)
+
+# Compute LBP map with specified points and radius
+def lbpMap(gray_img):
+    return _lbp(gray_img, _bestpoints, _bestradius, method='uniform')
 
-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
+# Compute normalized histogram of LBP map
+def lbpHist(lbp_map):
+    bins = _np.arange(0, _bestpoints + 3)                 # bin edges from 0 to points+2
+    h, _ = _np.histogram(lbp_map.ravel(), bins=bins, range=(0, _bestpoints + 2))
+    h = h.astype('float')
+    return h / (h.sum() + 1e-6)                            # avoid division by zero
 
+# Full LBP feature pipeline: grayscale → map → histogram
+def lbpFeature(img):
+    g = lbpGray(img)
+    lm = lbpMap(g)
+    return lbpHist(lm)
 
+# Convert image to grayscale for GLCM
+def glcmGray(img):
+    return _cv2.cvtColor(img, _cv2.COLOR_BGR2GRAY)
 
-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}")
+# Compute GLCM matrix given distances and angles
+def glcmMatrix(gray_img):
+    return _gcm(gray_img, distances=_bestglcmdist, angles=_bestangles, symmetric=True, normed=True)
+
+# Extract a single GLCM property vector
+def glcmProperties(glcm_mat, prop_name):
+    return _gcp(glcm_mat, prop_name).flatten()
+
+# Full GLCM feature pipeline: grayscale → GLCM matrix → properties
+def glcmFeature(img):
+    gray = glcmGray(img)
+    glcm = glcmMatrix(gray)
+    features = []
+    properties = ["contrast", "dissimilarity", "homogeneity", "energy"]
+    for prop in properties:
+        features.extend(glcmProperties(glcm, prop))        # append each property’s flattened values
+    return _np.array(features)
+
+# Convert image to grayscale for Hu moments
+def huGray(img):
+    return _cv2.cvtColor(img, _cv2.COLOR_BGR2GRAY)
+
+# Compute Hu Moments from grayscale image
+def huMoments(img):
+    g = huGray(img)
+    m = _cv2.moments(g)
+    return _cv2.HuMoments(m).flatten()
+
+# Combine all feature types for a given image path
+def FullFeautures(pathF):
+    img = _cv2.imread(pathF)
+    if img is None:
+        print(f"[Warning] cannot read {pathF}")
         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])
 
+    # compute each feature block
+    ch   = fun_color(img)    # color histogram length = 125
+    lbph = lbpFeature(img)      # LBP histogram length = 11
+    glc  = glcmFeature(img)     # GLCM feature length = 60
+    hu   = huMoments(img)   # Hu moments length = 7
+
+    fv = []
+
+    # split color histogram into two halves and extend
+    _cl = len(ch)
+    fv.extend(ch[:_cl//2])
+    fv.extend(ch[_cl//2:])
+
+    # split LBP histogram into two halves and extend
+    _ll = len(lbph)
+    fv.extend(lbph[:_ll//2])
+    fv.extend(lbph[_ll//2:])
+
+    # split GLCM features into two halves and extend
+    _gl = len(glc)
+    fv.extend(glc[:_gl//2])
+    fv.extend(glc[_gl//2:])
+
+    # split Hu moments into two halves and extend
+    _hl = len(hu)
+    fv.extend(hu[:_hl//2])
+    fv.extend(hu[_hl//2:])
+
+    return _np.array(fv) 

SkinBurns_Segmentation.py

@@ -1,4 +1,3 @@
-# ── Imports & Helper Functions ──
 import os
 import numpy as np
 import matplotlib.pyplot as plt
@@ -10,96 +9,88 @@ from tensorly.decomposition import tucker
 import cv2
 from skimage.color import rgb2gray
 
-def compute_local_variance(img, window_size=9):
+def LocalVar(img, window_size=9):
     img_sq = img ** 2
     mean = uniform_filter(img, size=window_size)
     mean_sq = uniform_filter(img_sq, size=window_size)
     return mean_sq - mean ** 2
 
-def largest_rectangle_in_mask(mask):
+def largestRect(mask):
     h, w = mask.shape
     heights = [0] * w
-    max_area = 0
-    best_coords = None  # (y_start, y_end, x_start, x_end)
+    Arealargest = 0
+    chosenCors = None  
 
-    for y in range(h):
-        for x in range(w):
-            heights[x] = heights[x] + 1 if mask[y, x] == 1 else 0
+    for row_idx, row in enumerate(mask):
+        heights = [
+            heights[col] + 1 if row[col] == 1 else 0
+            for col in range(w)
+        ]
 
         stack = []
-        x = 0
-        while x <= w:
-            curr_h = heights[x] if x < w else 0
-            if not stack or curr_h >= heights[stack[-1]]:
-                stack.append(x)
-                x += 1
+        col = 0
+        while col <= w:
+            currentH = heights[col] if col < w else 0
+
+            if not stack or currentH >= heights[stack[-1]]:
+                stack.append(col)
+                col += 1
             else:
                 top = stack.pop()
-                width_rect = x if not stack else x - stack[-1] - 1
-                area = heights[top] * width_rect
-                if area > max_area:
-                    max_area = area
-                    y_end = y
-                    y_start = y - heights[top] + 1
-                    x_end = x
-                    x_start = x - width_rect
-                    best_coords = (y_start, y_end, x_start, x_end)
-    return best_coords
-# ── Main Segmentation Function ──
+                rectangleW = col if not stack else col - stack[-1] - 1
+                area = heights[top] * rectangleW
+                if area > Arealargest:
+                    Arealargest = area
+                    bottomY = row_idx
+                    topY = row_idx - heights[top] + 1
+                    leftX = col - rectangleW
+                    rightX = col - 1
+                    chosenCors = (topY, bottomY, leftX, rightX)
+    return chosenCors
+
 def segment_burn(patient_image_path,
                  reference_image_path,
                  threshold_texture=0.35,
                  threshold_color=10):
-    """
-    Takes:
-      - patient_image_path: path to the RGB image
-      - reference_image_path: path to the healthy-reference RGB image
-      - threshold_texture, threshold_color: tuning parameters
-
-    Returns:
-      - burn_crop_clean: the cropped burn region (as an ndarray)
-      - burn_crop_debug: original image with the crop rectangle overlaid
-    """
-    # --- Load patient image ---
+    
     image = io.imread(patient_image_path)
     if image.shape[-1] == 4:
         image = image[..., :3]
     image = img_as_float(image)
     height, width, _ = image.shape
 
-    # --- Preprocessing & feature extraction ---
-    # 1. Convert to Lab + CLAHE on L
+   
     image_lab = color.rgb2lab(image)
     clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
     image_lab[:, :, 0] = clahe.apply((image_lab[:, :, 0] * 255).astype(np.uint8)) / 255.0
 
-    # 2. Gaussian smoothing
+    
     image_lab_filtered = np.zeros_like(image_lab)
     for i in range(3):
         image_lab_filtered[:, :, i] = gaussian_filter(image_lab[:, :, i], sigma=1.5)
 
-    # 3. Tucker decomposition + reconstruction
+
     tensor_image = tl.tensor(image_lab_filtered)
     core, factors = tucker(tensor_image, rank=[30, 30, 3])
     reconstructed = tl.tucker_to_tensor((core, factors))
+    reconstructed_rgb = np.clip(color.lab2rgb(reconstructed), 0, 1)
 
-    # 4. Texture map (local variance)
+ 
     gray = rgb2gray(image)
-    local_var = compute_local_variance(gray, window_size=9)
+    local_var = LocalVar(gray, window_size=9)
     vmin, vmax = np.percentile(local_var, [5, 95])
     local_var = np.clip((local_var - vmin) / (vmax - vmin), 0, 1)
 
-    # 5. Build feature vectors
+  
     lab_feat = reconstructed.reshape(-1, 3)
     texture_feat = local_var.flatten()[:, None]
     features = np.hstack((lab_feat, texture_feat))
 
-    # --- KMeans clustering & burn scoring ---
+    
     n_clusters = 5
     kmeans = KMeans(n_clusters=n_clusters, n_init=10, random_state=42)
     labels = kmeans.fit_predict(features).reshape(height, width)
 
-    # Score clusters for burn likelihood
     cluster_means = [features[labels.flatten()==i].mean(axis=0) for i in range(n_clusters)]
     burn_scores = []
     for L, A, B, T in cluster_means:
@@ -109,18 +100,18 @@ def segment_burn(patient_image_path,
         burn_scores.append(0.4*red + 0.2*dark + 0.4*T)
 
     burn_clusters = np.argsort(burn_scores)[-2:]
-    # skin cluster = cluster closest to healthy skin color
+   
     skin_cluster = np.argmin([np.linalg.norm(np.array([L,A,B]) - np.array([0.7,0,0]))
                               for L,A,B,T in cluster_means])
 
-    # Initial burn mask + morphology
+    
     burn_mask = np.isin(labels, burn_clusters).astype(np.uint8)
     closed = binary_closing(burn_mask, structure=np.ones((10,10)))
     labeled, _ = label(closed)
     sizes = np.bincount(labeled.ravel()); sizes[0]=0
     largest = (labeled == sizes.argmax()).astype(np.uint8)
 
-    # --- Reference-based refinement ---
+   
     if os.path.exists(reference_image_path):
         ref = io.imread(reference_image_path)
         if ref.shape[-1]==4:
@@ -134,7 +125,7 @@ def segment_burn(patient_image_path,
             ref_lab_f[:, :, i] = gaussian_filter(ref_lab[:, :, i], sigma=1.5)
 
         ref_gray = rgb2gray(ref)
-        ref_var = compute_local_variance(ref_gray, window_size=9)
+        ref_var = LocalVar(ref_gray, window_size=9)
         rvmin, rvmax = np.percentile(ref_var, [5,95])
         ref_var = np.clip((ref_var - rvmin)/(rvmax - rvmin),0,1)
 
@@ -152,21 +143,21 @@ def segment_burn(patient_image_path,
     else:
         final_burn = largest
 
-    # (Optional) segmentation map if you need it later
+
     segmentation_map = np.zeros((height, width, 3))
     segmentation_map[labels==skin_cluster] = [0,1,0]
     segmentation_map[final_burn==1]   = [1,0,0]
 
-    # --- Crop the largest solid rectangle within the burn mask ---
-    coords = largest_rectangle_in_mask(final_burn)
+   
+    coords = largestRect(final_burn)
     if coords is None:
         raise ValueError("No solid rectangular burn area found.")
     y1,y2,x1,x2 = coords
     burn_crop_clean = image[y1:y2+1, x1:x2+1]
 
-    # --- Build debug overlay image ---
+    
     debug_img = (image * 255).astype(np.uint8).copy()
     cv2.rectangle(debug_img, (x1,y1), (x2,y2), (0,255,255), thickness=3)
     burn_crop_debug = debug_img
 
-    return burn_crop_clean, burn_crop_debug
+    return burn_crop_clean, burn_crop_debug  

app.py

@@ -9,7 +9,7 @@ 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_Classification import FullFeautures
 from SkinBurns_Segmentation import segment_burn
 import requests
 import joblib
@@ -86,7 +86,7 @@ async def predict_burn(file: UploadFile = File(...)):
             loaded_svm = pickle.load(model_file)
 
         # Extract features from the uploaded image
-        features = extract_features(temp_file_path)
+        features = FullFeautures(temp_file_path)
 
         # Remove the temporary file
         os.remove(temp_file_path)