uploaded 9 min

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