Remove skull stripping and slice filtering from preprocessing pipeline

backend/app/services/preprocessor.py

@@ -33,70 +33,20 @@ def _sort_dicom_files(dcm_paths: list) -> list:
 # Hoạt động trên Windows, không cần subprocess
 # ──────────────────────────────────────────────
 
-def _skull_strip_slice(img: np.ndarray) -> np.ndarray:
-    """
-    Gọt sọ 1 slice 2D bằng cv2 morphological operations.
-    Tương tự kết quả SynthStrip nhưng ổn định trên mọi nền tảng.
-
-    1. Normalize 0-255
-    2. Otsu threshold → mask nhị phân
-    3. Lấy connected component lớn nhất (não)
-    4. Morphological closing để lấp lỗ hổng
-    5. Mask vào ảnh gốc
-    """
-    img_f = img.astype(np.float32)
-    if img_f.max() - img_f.min() < 1e-6:
-        return img_f
-
-    # Normalize sang 8-bit
-    img_8 = cv2.normalize(img_f, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
-
-    # Otsu threshold
-    blur = cv2.GaussianBlur(img_8, (5, 5), 0)
-    _, mask = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-
-    # Lấy connected component lớn nhất
-    num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(mask, connectivity=8)
-    if num_labels <= 1:
-        return img_f
-
-    # Component 0 là background — lấy component có area lớn nhất (trừ background)
-    areas = stats[1:, cv2.CC_STAT_AREA]
-    largest = int(np.argmax(areas)) + 1
-    brain_mask = (labels == largest).astype(np.uint8) * 255
-
-    # Morphological closing để lấp lỗ trong não
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
-    brain_mask = cv2.morphologyEx(brain_mask, cv2.MORPH_CLOSE, kernel)
-
-    # Fill holes bằng flood fill
-    flood = brain_mask.copy()
-    h, w = flood.shape
-    fill_mask = np.zeros((h + 2, w + 2), np.uint8)
-    cv2.floodFill(flood, fill_mask, (0, 0), 255)
-    filled = cv2.bitwise_not(flood)
-    brain_mask = cv2.bitwise_or(brain_mask, filled)
-
-    # Áp mask vào ảnh gốc (float, giữ giá trị gốc)
-    stripped = img_f * (brain_mask.astype(np.float32) / 255.0)
-    return stripped
-
-
 # ──────────────────────────────────────────────
-# Xử lý từng lát cắt — khớp training Kaggle
+# Chuẩn hóa lát cắt tối giản (Không gọt sọ, không lọc)
 # ──────────────────────────────────────────────
 
-def _process_slice(slice_2d: np.ndarray) -> np.ndarray | None:
+def _normalize_slice(slice_2d: np.ndarray) -> np.ndarray | None:
     """
-    Chuẩn hóa 1 slice 2D sau khi đã gọt sọ.
-    Pipeline khớp training:
-      - Loại blank (range < 1e-6)
+    Chuẩn hóa 1 slice 2D mà không gọt sọ hay lọc lát cắt:
+      - Loại slice hoàn toàn trống (range < 1e-6)
       - Percentile clip p1–p99
-      - Normalize 0–255
-      - Loại uniform (std < 3)
+      - Normalize 0–255 uint8
     """
     img = slice_2d.astype(np.float32)
-    if img.max() - img.min() < 1e-6:
+    img_range = img.max() - img.min()
+    if img_range < 1e-6:
         return None
 
     p_low  = np.percentile(img, 1)
@@ -104,18 +54,10 @@ def _process_slice(slice_2d: np.ndarray) -> np.ndarray | None:
     img = np.clip(img, p_low, p_high)
 
     img_range = img.max() - img.min()
-    img_8bit = ((img - img.min()) / (img_range + 1e-6) * 255).astype(np.uint8)
-
-    # Loại slice đồng nhất
-    if img_8bit.std() < 3:
-        return None
-
-    # Loại slice ít mô não: < 8% pixel không phải background (sau skull strip)
-    # Ngưỡng 8% khớp hành vi SynthStrip — loại các lát đầu/cuối volume ít não
-    tissue_ratio = np.count_nonzero(img_8bit) / img_8bit.size
-    if tissue_ratio < 0.08:
+    if img_range < 1e-6:
         return None
 
+    img_8bit = ((img - img.min()) / img_range * 255).astype(np.uint8)
     return img_8bit
 
 
@@ -125,12 +67,8 @@ def _process_slice(slice_2d: np.ndarray) -> np.ndarray | None:
 
 def preprocess_dicom_sequence(dicom_dir: str):
     """
-    Pipeline khớp training Kaggle:
-      DICOM → pixel arrays → skull strip (cv2) → axial slices (rot90 k=1) → normalize
-
-    Trả về:
-        valid_slices : list[np.ndarray uint8]
-        useful_idx   : np.ndarray[int]
+    Tiền xử lý chuỗi ảnh DICOM (Không gọt sọ, không lọc):
+    DICOM → pixel arrays → axial slices (rot90 k=1) → normalize 0-255
     """
     # 1. Đọc và sắp xếp DICOM
     files = []
@@ -162,7 +100,7 @@ def preprocess_dicom_sequence(dicom_dir: str):
     volume = np.nan_to_num(volume, nan=0.0, posinf=0.0, neginf=0.0)
 
     n_slices = volume.shape[2]
-    print(f"[Preprocessor] Volume shape: {volume.shape} | Starting skull strip...")
+    print(f"[Preprocessor] Volume shape: {volume.shape} | Processing slices (No skull strip, No filtering)...")
 
     # 2. Xử lý từng lát cắt axial
     valid_slices = []
@@ -172,10 +110,7 @@ def preprocess_dicom_sequence(dicom_dir: str):
         sl = volume[:, :, i]
         sl = np.rot90(sl, k=1)          # Khớp training: rot90 k=1
 
-        # Skull strip bằng cv2
-        sl_stripped = _skull_strip_slice(sl)
-
-        processed = _process_slice(sl_stripped)
+        processed = _normalize_slice(sl)
         if processed is not None:
             valid_slices.append(processed)
             useful_idx.append(i)
@@ -183,14 +118,14 @@ def preprocess_dicom_sequence(dicom_dir: str):
     if not valid_slices:
         raise ValueError("Không tìm thấy lát cắt MRI hợp lệ nào sau khi xử lý.")
 
-    print(f"[Preprocessor] {len(valid_slices)}/{n_slices} valid slices (cv2 skull-stripped)")
+    print(f"[Preprocessor] {len(valid_slices)}/{n_slices} valid slices (Normalized)")
     return valid_slices, np.array(useful_idx)
 
 
 def preprocess_nifti_file(nifti_path: str):
     """
-    Tiền xử lý 1 file NIfTI đã gọt sọ sẵn (giống logic training trên Kaggle):
-    NIfTI -> đọc volume -> contrast clip p1-p99 -> scale 0-255 uint8 -> lọc slice (std < 3)
+    Tiền xử lý file NIfTI (Không lọc lát cắt):
+    NIfTI -> đọc volume -> contrast clip p1-p99 -> scale 0-255 uint8
     """
     img_nii = nib.load(nifti_path)
     data = img_nii.get_fdata().astype(np.float32)
@@ -202,28 +137,14 @@ def preprocess_nifti_file(nifti_path: str):
     for i in range(n_slices):
         sl = data[:, :, i]
         
-        if np.max(sl) - np.min(sl) < 1e-6:
-            continue
-            
-        p_low = np.percentile(sl, 1)
-        p_high = np.percentile(sl, 99)
-        sl = np.clip(sl, p_low, p_high)
-        
-        sl_range = sl.max() - sl.min()
-        if sl_range < 1e-6:
-            continue
-            
-        sl_8bit = ((sl - sl.min()) / sl_range * 255).astype(np.uint8)
-        
-        if sl_8bit.std() < 3:
-            continue
-            
-        valid_slices.append(sl_8bit)
-        useful_idx.append(i)
+        processed = _normalize_slice(sl)
+        if processed is not None:
+            valid_slices.append(processed)
+            useful_idx.append(i)
         
     if not valid_slices:
         raise ValueError("Không tìm thấy lát cắt MRI hợp lệ nào trong file NIfTI.")
         
-    print(f"[Preprocessor] NIfTI processed: {len(valid_slices)}/{n_slices} valid slices")
+    print(f"[Preprocessor] NIfTI processed (No filtering): {len(valid_slices)}/{n_slices} valid slices")
     return valid_slices, np.array(useful_idx)