Upload 15 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+prediction_result.png filter=lfs diff=lfs merge=lfs -text

Readme.md

@@ -0,0 +1,3 @@
+# Bone Fracture Detection Gradio App
+
+Upload an X-ray image to detect bone fractures using GLCM features and an SVM classifier.

app.py

@@ -0,0 +1,90 @@
+import gradio as gr
+import numpy as np
+import cv2
+import tempfile
+import os
+import sys
+
+# Add project root to Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import predictor class
+from src.predict_fracture import FracturePredictor
+
+# Get current script location
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(current_dir)  # Go up from app/ to project root
+
+# CORRECTED MODEL PATHS
+MODEL_PATH = 'models/fracture_detection_model.joblib'
+ENCODER_PATH = 'models/label_encoder.joblib'
+# Debugging output
+print(f"Project root: {project_root}")
+print(f"Model path: {MODEL_PATH}")
+print(f"Model exists: {os.path.exists(MODEL_PATH)}")
+print(f"Encoder exists: {os.path.exists(ENCODER_PATH)}")
+
+# Initialize predictor only if files exist
+if os.path.exists(MODEL_PATH) and os.path.exists(ENCODER_PATH):
+    predictor = FracturePredictor(model_path=MODEL_PATH, encoder_path=ENCODER_PATH)
+else:
+    print("ERROR: Model files not found. Please run training first.")
+    exit(1)
+
+def predict_fracture(img):
+    """Process uploaded image and return prediction results"""
+    try:
+        # Handle different input types
+        if isinstance(img, np.ndarray):
+            # Convert to BGR format for OpenCV
+            if img.shape[2] == 4:  # RGBA image
+                img_bgr = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)
+            else:  # RGB image
+                img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+            
+            # Save to temp file
+            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
+                tmp_path = tmp.name
+                cv2.imwrite(tmp_path, img_bgr)
+        else:
+            # Already a file path
+            tmp_path = img
+        
+        # Get prediction
+        label, confidence, vis_path = predictor.predict(tmp_path)
+        
+        # Read visualization image
+        vis_img = cv2.imread(vis_path)
+        if vis_img is not None:
+            vis_img = cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB)
+        
+        # Clean up temporary file
+        if isinstance(img, np.ndarray) and os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        
+        return label, f"{confidence:.4f}", vis_img
+    
+    except Exception as e:
+        print(f"Prediction error: {str(e)}")
+        return "Error", "N/A", None
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_fracture,
+    inputs=gr.Image(label="Upload X-Ray Image"),
+    outputs=[
+        gr.Label(label="Prediction Result"),
+        gr.Textbox(label="Confidence Score"),
+        gr.Image(label="Prediction Visualization")
+    ],
+    title="🦴 Bone Fracture Detection System",
+    description="Upload an X-ray image to detect bone fractures using GLCM features and SVM classifier",
+    examples=[
+        [os.path.join("samples", "fractured_1.jpg")],
+        [os.path.join("samples", "normal_1.jpg")]
+    ],
+    flagging_mode="never"
+)
+
+if __name__ == "__main__":
+    iface.launch(server_name="0.0.0.0", server_port=7860)

models/fracture_detection_model.joblib

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

models/label_encoder.joblib

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

requirements.txt

@@ -0,0 +1,7 @@
+numpy==1.24.3
+opencv-python==4.8.0.76
+scikit-learn==1.3.0
+scikit-image==0.21.0
+matplotlib==3.7.2
+joblib==1.3.2
+argparse==1.4.0

src/glcm_feature_extractor.py

@@ -0,0 +1,110 @@
+import cv2
+import numpy as np
+from skimage.feature import graycomatrix, graycoprops
+import os
+from glob import glob
+from PIL import Image, UnidentifiedImageError
+
+class GLCMFeatureExtractor:
+    def __init__(self, distances=[1, 3, 5], angles=[0, np.pi/4, np.pi/2, 3*np.pi/4]):
+        self.distances = distances
+        self.angles = angles
+    
+    def preprocess_xray(self, img_path):
+        """Robust image loading with multiple fallbacks"""
+        try:
+            # First try with OpenCV
+            img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
+            if img is None:
+                # Fallback to PIL for problematic images
+                try:
+                    with Image.open(img_path) as pil_img:
+                        img = np.array(pil_img.convert('L'))
+                except (IOError, UnidentifiedImageError) as e:
+                    raise ValueError(f"PIL cannot read image: {img_path}") from e
+            
+            # Handle empty images
+            if img.size == 0:
+                raise ValueError(f"Empty image: {img_path}")
+                
+            # Resize and normalize
+            img = cv2.resize(img, (256, 256))
+            
+            # Improved normalization
+            img = img.astype(np.float32)
+            min_val = np.min(img)
+            max_val = np.max(img)
+            
+            # Handle zero-contrast images
+            if max_val - min_val < 1e-5:
+                img = np.zeros_like(img)  # Return black image
+            else:
+                img = (img - min_val) / (max_val - min_val) * 255
+                
+            return img.astype(np.uint8)
+        except Exception as e:
+            print(f"Error processing {img_path}: {str(e)}")
+            return None
+
+    def extract_features(self, img):
+        """Extract GLCM features with validation"""
+        if img is None:
+            return None
+            
+        try:
+            # Calculate GLCM with optimized parameters
+            glcm = graycomatrix(
+                img, 
+                distances=self.distances, 
+                angles=self.angles, 
+                levels=256,
+                symmetric=True, 
+                normed=True
+            )
+            
+            # Extract texture properties
+            features = []
+            props = ['contrast', 'dissimilarity', 'homogeneity', 
+                    'energy', 'correlation', 'ASM']
+            
+            for prop in props:
+                feat = graycoprops(glcm, prop)
+                features.extend(feat.flatten())
+                
+            return np.array(features)
+        except Exception as e:
+            print(f"Feature extraction error: {str(e)}")
+            return None
+
+    def extract_from_folder(self, folder_path, max_samples=None):
+        """Batch feature extraction with error handling"""
+        features = []
+        labels = []
+        class_name = os.path.basename(folder_path)
+        
+        # Find all image files
+        image_paths = []
+        for ext in ('*.png', '*.jpg', '*.jpeg', '*.dcm', '*.tif', '*.bmp'):
+            image_paths.extend(glob(os.path.join(folder_path, ext)))
+            
+        if not image_paths:
+            print(f"Warning: No images found in {folder_path}")
+            return np.array([]), np.array([])
+            
+        # Apply sampling if requested
+        if max_samples and len(image_paths) > max_samples:
+            image_paths = np.random.choice(image_paths, max_samples, replace=False)
+            
+        # Process each image
+        for img_path in image_paths:
+            img = self.preprocess_xray(img_path)
+            if img is None:
+                continue
+                
+            feat = self.extract_features(img)
+            if feat is not None:
+                features.append(feat)
+                labels.append(class_name)
+                
+        print(f"Successfully processed {len(features)}/{len(image_paths)} images in {folder_path}")
+        return np.array(features), np.array(labels)

src/predict_fracture.py

@@ -0,0 +1,77 @@
+import cv2
+import numpy as np
+import joblib
+from matplotlib import pyplot as plt
+import os
+import matplotlib
+matplotlib.use('Agg')  # For headless environments
+from .glcm_feature_extractor import GLCMFeatureExtractor
+
+class FracturePredictor:
+    def __init__(self, model_path='models/fracture_detection_model.joblib', 
+                 encoder_path='models/label_encoder.joblib'):
+        # Verify model paths
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model file not found: {model_path}")
+        if not os.path.exists(encoder_path):
+            raise FileNotFoundError(f"Encoder file not found: {encoder_path}")
+            
+        self.model = joblib.load(model_path)
+        self.le = joblib.load(encoder_path)
+        self.extractor = GLCMFeatureExtractor()
+    
+    def predict(self, img_input, visualize=True, save_path='prediction_result.png'):
+        """
+        Predict fracture from image input (file path)
+        Returns: (label, confidence, visualization_path)
+        """
+        try:
+            # Preprocess image
+            img = self.extractor.preprocess_xray(img_input)
+            if img is None:
+                return "Error: Invalid image", 0.0, None
+            
+            # Extract features
+            feat = self.extractor.extract_features(img)
+            if feat is None:
+                return "Error: Feature extraction failed", 0.0, None
+            
+            # Make prediction
+            proba = self.model.predict_proba(feat.reshape(1, -1))[0]
+            pred = self.model.predict(feat.reshape(1, -1))[0]
+            label = self.le.inverse_transform([pred])[0]
+            confidence = max(proba)
+            
+            # Generate visualization
+            vis_path = None
+            if visualize:
+                vis_path = save_path
+                self.visualize_prediction(img, label, confidence, proba, save_path)
+            
+            return label, confidence, vis_path
+        except Exception as e:
+            print(f"Prediction error: {str(e)}")
+            return "Prediction error", 0.0, None
+    
+    def visualize_prediction(self, img, label, confidence, proba, save_path):
+        """Create and save prediction visualization"""
+        plt.figure(figsize=(12, 6))
+        
+        # Original image
+        plt.subplot(1, 2, 1)
+        plt.imshow(img, cmap='gray')
+        plt.title(f"Original Image\nPrediction: {label}\nConfidence: {confidence:.2f}")
+        plt.axis('off')
+        
+        # Probability distribution
+        plt.subplot(1, 2, 2)
+        colors = ['red' if cls != label else 'green' for cls in self.le.classes_]
+        plt.bar(self.le.classes_, proba, color=colors)
+        plt.title("Classification Probabilities")
+        plt.ylabel("Probability")
+        plt.ylim(0, 1)
+        
+        plt.tight_layout()
+        plt.savefig(save_path)
+        plt.close()
+        return save_path

train_pipeline.py

@@ -0,0 +1,289 @@
+import numpy as np
+from skimage.feature import graycomatrix, graycoprops
+import os
+from glob import glob
+from PIL import Image, UnidentifiedImageError
+import joblib
+from sklearn.svm import SVC
+from sklearn.metrics import classification_report, accuracy_score, recall_score
+from sklearn.preprocessing import LabelEncoder
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+import matplotlib.pyplot as plt
+import argparse
+
+class GLCMFeatureExtractor:
+    def __init__(self, distances=[1, 3, 5], angles=[0, np.pi/4, np.pi/2, 3*np.pi/4]):
+        self.distances = distances
+        self.angles = angles
+    
+    def preprocess_xray(self, img_path):
+        """Robust image loading with PIL only"""
+        try:
+            with Image.open(img_path) as pil_img:
+                # Convert to grayscale
+                if pil_img.mode != 'L':
+                    pil_img = pil_img.convert('L')
+                
+                # Resize and convert to numpy array
+                pil_img = pil_img.resize((256, 256))
+                img = np.array(pil_img)
+            
+            # Handle empty images
+            if img.size == 0:
+                raise ValueError(f"Empty image: {img_path}")
+                
+            # Improved normalization
+            img = img.astype(np.float32)
+            min_val = np.min(img)
+            max_val = np.max(img)
+            
+            # Handle zero-contrast images
+            if max_val - min_val < 1e-5:
+                img = np.zeros_like(img)  # Return black image
+            else:
+                img = (img - min_val) / (max_val - min_val) * 255
+                
+            return img.astype(np.uint8)
+        except Exception as e:
+            print(f"Error processing {img_path}: {str(e)}")
+            return None
+
+    def extract_features(self, img):
+        """Extract GLCM features with validation"""
+        if img is None:
+            return None
+            
+        try:
+            # Calculate GLCM with optimized parameters
+            glcm = graycomatrix(
+                img, 
+                distances=self.distances, 
+                angles=self.angles, 
+                levels=256,
+                symmetric=True, 
+                normed=True
+            )
+            
+            # Extract texture properties
+            features = []
+            props = ['contrast', 'dissimilarity', 'homogeneity', 
+                    'energy', 'correlation', 'ASM']
+            
+            for prop in props:
+                feat = graycoprops(glcm, prop)
+                features.extend(feat.flatten())
+                
+            return np.array(features)
+        except Exception as e:
+            print(f"Feature extraction error: {str(e)}")
+            return None
+
+    def extract_from_folder(self, folder_path, max_samples=None):
+        """Batch feature extraction with error handling"""
+        features = []
+        labels = []
+        class_name = os.path.basename(folder_path)
+        
+        # Find all image files
+        image_paths = []
+        for ext in ('*.png', '*.jpg', '*.jpeg', '*.dcm', '*.tif', '*.bmp'):
+            image_paths.extend(glob(os.path.join(folder_path, ext)))
+            
+        if not image_paths:
+            print(f"Warning: No images found in {folder_path}")
+            return np.array([]), np.array([])
+            
+        # Apply sampling if requested
+        if max_samples and len(image_paths) > max_samples:
+            image_paths = np.random.choice(image_paths, max_samples, replace=False)
+            
+        # Process each image
+        for img_path in image_paths:
+            img = self.preprocess_xray(img_path)
+            if img is None:
+                continue
+                
+            feat = self.extract_features(img)
+            if feat is not None:
+                features.append(feat)
+                labels.append(class_name)
+                
+        print(f"Successfully processed {len(features)}/{len(image_paths)} images in {folder_path}")
+        return np.array(features), np.array(labels)
+
+
+def load_dataset(dataset_path):
+    splits = ['train', 'val', 'test']
+    features = {split: [] for split in splits}
+    labels = {split: [] for split in splits}
+    extractor = GLCMFeatureExtractor()
+    
+    for split in splits:
+        for label in ['fractured', 'not_fractured']:
+            folder = os.path.join(dataset_path, split, label)
+            if not os.path.exists(folder):
+                print(f"Warning: Missing folder {folder}")
+                continue
+                
+            feats, lbls = extractor.extract_from_folder(folder)
+            if len(feats) > 0:
+                features[split].extend(feats)
+                labels[split].extend(lbls)
+                print(f"Extracted {len(feats)} samples from {split}/{label}")
+            else:
+                print(f"No valid samples found in {split}/{label}")
+                    
+    return features, labels
+
+
+def train_and_evaluate(features, labels, model_save_path='models'):
+    os.makedirs(model_save_path, exist_ok=True)
+    
+    le = LabelEncoder()
+    all_labels = []
+    for split in labels:
+        all_labels.extend(labels[split])
+    le.fit(all_labels)
+    
+    # Prepare data splits
+    X_train = np.array(features['train'])
+    y_train = le.transform(labels['train'])
+    
+    X_val = np.array(features['val'])
+    y_val = le.transform(labels['val'])
+    
+    X_test = np.array(features['test'])
+    y_test = le.transform(labels['test'])
+    
+    # Check data availability
+    if len(X_train) == 0:
+        raise ValueError("No training data available!")
+    
+    # Train SVM classifier
+    clf = SVC(kernel='rbf', C=10, gamma='scale', probability=True, class_weight='balanced')
+    clf.fit(X_train, y_train)
+    
+    # Evaluate on validation set
+    print("\nValidation Set Performance:")
+    if len(X_val) > 0:
+        y_val_pred = clf.predict(X_val)
+        print(classification_report(y_val, y_val_pred, target_names=le.classes_))
+        print(f"Validation Accuracy: {accuracy_score(y_val, y_val_pred):.4f}")
+        print(f"Validation Recall: {recall_score(y_val, y_val_pred):.4f}")
+    else:
+        print("No validation data available")
+    
+    # Evaluate on test set
+    print("\nTest Set Performance:")
+    if len(X_test) > 0:
+        y_test_pred = clf.predict(X_test)
+        print(classification_report(y_test, y_test_pred, target_names=le.classes_))
+        print(f"Test Accuracy: {accuracy_score(y_test, y_test_pred):.4f}")
+        print(f"Test Recall: {recall_score(y_test, y_test_pred):.4f}")
+    else:
+        print("No test data available")
+    
+    # Save model
+    model_path = os.path.join(model_save_path, 'fracture_detection_model.joblib')
+    encoder_path = os.path.join(model_save_path, 'label_encoder.joblib')
+    joblib.dump(clf, model_path)
+    joblib.dump(le, encoder_path)
+    print(f"\nModel saved to {model_path}")
+    print(f"Label encoder saved to {encoder_path}")
+    
+    return clf, le
+
+class FracturePredictor:
+    def __init__(self, model_path='models/fracture_detection_model.joblib', 
+                 encoder_path='models/label_encoder.joblib'):
+        # Verify model paths
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model file not found: {model_path}")
+        if not os.path.exists(encoder_path):
+            raise FileNotFoundError(f"Encoder file not found: {encoder_path}")
+            
+        self.model = joblib.load(model_path)
+        self.le = joblib.load(encoder_path)
+        self.extractor = GLCMFeatureExtractor()
+    
+    def predict(self, img_input, visualize=True, save_path='prediction_result.png'):
+        """
+        Predict fracture from image input (file path)
+        Returns: (label, confidence, visualization_path)
+        """
+        try:
+            # Preprocess image
+            img = self.extractor.preprocess_xray(img_input)
+            if img is None:
+                return "Error: Invalid image", 0.0, None
+            
+            # Extract features
+            feat = self.extractor.extract_features(img)
+            if feat is None:
+                return "Error: Feature extraction failed", 0.0, None
+            
+            # Make prediction
+            proba = self.model.predict_proba(feat.reshape(1, -1))[0]
+            pred = self.model.predict(feat.reshape(1, -1))[0]
+            label = self.le.inverse_transform([pred])[0]
+            confidence = max(proba)
+            
+            # Generate visualization
+            vis_path = None
+            if visualize:
+                vis_path = save_path
+                self.visualize_prediction(img, label, confidence, proba, save_path)
+            
+            return label, confidence, vis_path
+        except Exception as e:
+            print(f"Prediction error: {str(e)}")
+            return "Prediction error", 0.0, None
+    
+    def visualize_prediction(self, img, label, confidence, proba, save_path):
+        """Create and save prediction visualization"""
+        plt.figure(figsize=(12, 6))
+        
+        # Original image
+        plt.subplot(1, 2, 1)
+        plt.imshow(img, cmap='gray')
+        plt.title(f"Original Image\nPrediction: {label}\nConfidence: {confidence:.2f}")
+        plt.axis('off')
+        
+        # Probability distribution
+        plt.subplot(1, 2, 2)
+        colors = ['red' if cls != label else 'green' for cls in self.le.classes_]
+        plt.bar(self.le.classes_, proba, color=colors)
+        plt.title("Classification Probabilities")
+        plt.ylabel("Probability")
+        plt.ylim(0, 1)
+        
+        plt.tight_layout()
+        plt.savefig(save_path)
+        plt.close()
+        return save_path
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Bone Fracture Detection System')
+    parser.add_argument('--dataset_path', default='dataset', help='Path to dataset directory')
+    parser.add_argument('--model_save_path', default='models', help='Path to save trained models')
+    parser.add_argument('--predict_image', default=None, help='Path to image for prediction')
+    args = parser.parse_args()
+    
+    if args.predict_image:
+        # Predict mode
+        predictor = FracturePredictor(
+            model_path=os.path.join(args.model_save_path, 'fracture_detection_model.joblib'),
+            encoder_path=os.path.join(args.model_save_path, 'label_encoder.joblib')
+        )
+        label, confidence, vis_path = predictor.predict(args.predict_image)
+        print(f"Prediction: {label}")
+        print(f"Confidence: {confidence:.4f}")
+        if vis_path:
+            print(f"Visualization saved to {vis_path}")
+    else:
+        # Train mode
+        print("Loading dataset and extracting features...")
+        features, labels = load_dataset(args.dataset_path)
+        print("\nTraining and evaluating model...")
+        train_and_evaluate(features, labels, args.model_save_path)