OSCR

A Multiple Sclerosis MRI Dataset with Tri-Mask Annotations for Lesion Segmentation.

Code ↔ Paper

17 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 17 matches
  1. [1] § Technical Validation › Baseline methods and implementation ↔ old_scripts/model_architecturs.py, lines 852–909 · score 0.86 · nested skip pathways, semantic gap, medical image segmentation, convolutional, encoder, channel
  2. [2] § Background & Summary ↔ preprocessing/dicom_to_nifti.py, lines 235–310 · score 0.69 · T1 weighted, T2 weighted, FLAIR sequences, suppresses, detection, protocols
  3. [3] § Materials & Methods › Preprocessing › Step 5: Brain extraction ↔ preprocessing/coregistration_and_brain_extraction.py, lines 251–378 · score 0.67 · Brain Extraction, brain mask, FSL, BET, FLAIR
  4. [4] § Data Records ↔ preprocessing/dicom_to_nifti.py, lines 352–417 · score 0.63 · voxel spacing, headers preserve, NIfTI, matrices, preprocessed, Patient
  5. [5] § Materials & Methods › Data collection › Patient cohort ↔ preprocessing/dicom_to_nifti.py, lines 235–310 · score 0.63 · motion artifacts, image quality, technical, MS, patient
  6. [6] § Materials & Methods › Annotation methodology › Annotation statistics ↔ dataset_analysis/ms_demographics_table.py, lines 98–181 · score 0.62 · female patients, sex, cohort, age, MS
  7. [7] § Background & Summary ↔ preprocessing/coregistration_and_brain_extraction.py, lines 1–30 · score 0.61 · brain extraction, FLAIR space, FLAIR images, preprocessed, binary, mask
  8. [8] § Materials & Methods › Preprocessing › Step 3: Co-registration ↔ preprocessing/coregistration_and_brain_extraction.py, lines 1–30 · score 0.58 · FLAIR space, FSL, FLIRT, FLAIR images, masks
  9. [9] § Usage Notes ↔ old_scripts/models_runner.py, lines 1–86 · score 0.57 · TensorFlow, Deep learning, CUDA, libraries, brain
  10. [10] § Materials & Methods › Evaluation metrics ↔ utils/metrics.py, lines 57–98 · score 0.56 · percentile Hausdorff Distance, surfaces, metrics, HD95, boundary
  11. [11] § Materials & Methods › MRI Acquisition ↔ dataset_analysis/ms_imaging_table.py, lines 9–122 · score 0.56 · slice thickness, FA, TE, matrix, TI, DICOM
  12. [12] § Technical Validation › Experimental setup ↔ utils/data_loader.py, lines 185–237 · score 0.54 · cross validation split, fold cross validation, held, training, patient
  13. [13] § Data Records ↔ dataset_analysis/patient_encoder_v2.py, lines 253–314 · score 0.54 · nii.gz, NIfTI headers, anonymized, Patient
  14. [14] § Usage Notes ↔ preprocessing/coregistration_and_brain_extraction.py, lines 537–584 · score 0.53 · brain extraction, FSL, GB, installation, memory
  15. [15] § Materials & Methods › Preprocessing › Step 2: Format conversion ↔ preprocessing/dicom_to_nifti.py, lines 504–547 · score 0.52 · dcm2niix, compatibility, NIfTI, conversion, DICOM
  16. [16] § Materials & Methods › Evaluation metrics ↔ old_scripts/metrics_functions.py, lines 42–77 · score 0.51 · percentile Hausdorff Distance, metrics, HD95, boundary
  17. [17] § Materials & Methods › Annotation methodology › Annotation statistics ↔ dataset_analysis/ms_mask_analysis.py, lines 245–301 · score 0.51 · female patients, cohort, age, MS

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 583 lines · 26 KB · MIT · 4 matches

  1. #!/usr/bin/env python3
  2. """
  3. MRI NIFTI File Creator from DICOMs - Final Production Version
  4. ====================================================
  6. This script converts the dicom files of a patient into a nifti file.
  7. Since many dicom header would be lost through this conversion, this script provides header information as in json files.
  9. System Requirements:
  10. - Python 3.9+
  12. Features:
  13. -
  15. Author: Mahdi Bashiri Bawil
  16. Date: September 2025
  17. Version: 1.0 (Production Ready)
  18. """
  21. import os
  22. import json
  23. import logging
  24. from pathlib import Path
  25. import subprocess
  26. import sys
  27. from datetime import datetime
  29. # Required libraries
  30. try:
  31. import pydicom
  32. import nibabel as nib
  33. import numpy as np
  34. from dicom2nifti import dicom_series_to_nifti
  35. from dicom2nifti.settings import disable_validate_slice_increment
  36. except ImportError as e:
  37. print(f"Missing required library: {e}")
  38. print("Install with: pip install pydicom nibabel dicom2nifti")
  39. sys.exit(1)
  41. # Set up logging with UTF-8 encoding to handle special characters
  42. logging.basicConfig(
  43. level=logging.INFO,
  44. format='%(asctime)s - %(levelname)s - %(message)s',
  45. handlers=[
  46. logging.FileHandler('ms_dicom_to_nifti_conversion.log', encoding='utf-8'),
  47. logging.StreamHandler()
  48. ]
  49. )
  51. # Set console output to UTF-8 if possible
  52. if hasattr(sys.stdout, 'reconfigure'):
  53. sys.stdout.reconfigure(encoding='utf-8')
  54. if hasattr(sys.stderr, 'reconfigure'):
  55. sys.stderr.reconfigure(encoding='utf-8')
  58. class MSDatasetDicomToNiftiConverter:
  59. """
  60. Specialized DICOM to NIfTI converter for MS dataset structure
  61. Handles the specific directory structure: PatientID/Protocol/DICOM_files
  62. Enhanced for research use with comprehensive metadata preservation
  63. """
  65. def __init__(self, input_directory, output_directory, method='dicom2nifti'):
  66. """
  67. Initialize MS dataset converter
  69. Args:
  70. input_directory (str): Root directory containing patient folders (6-digit IDs)
  71. output_directory (str): Output directory for NIfTI files
  72. method (str): Conversion method ('dicom2nifti', 'dcm2niix', 'nibabel')
  73. """
  74. self.input_dir = Path(input_directory)
  75. self.output_dir = Path(output_directory)
  76. self.method = method
  77. self.converted_series = 0
  78. self.failed_series = 0
  79. self.processed_patients = 0
  81. # Create output directory
  82. self.output_dir.mkdir(parents=True, exist_ok=True)
  84. # Disable strict validation for research data
  85. disable_validate_slice_increment()
  87. # MS protocol mappings for standardization
  88. self.protocol_mapping = {
  89. 'FLAIR': 'FLAIR',
  90. 'FLAIR_SG': 'FLAIR_SG',
  91. 'T1WI': 'T1WI',
  92. 'T2WI': 'T2WI',
  93. 't1wi': 'T1WI', # Handle case variations
  94. 't2wi': 'T2WI',
  95. 'flair': 'FLAIR',
  96. 'flair_sg': 'FLAIR_SG'
  97. }
  99. def find_patient_folders(self):
  100. """Find all patient folders (6-digit numeric folders)"""
  101. patient_folders = []
  103. for item in self.input_dir.iterdir():
  104. if item.is_dir() and item.name.isdigit() and len(item.name) == 6:
  105. patient_folders.append(item)
  107. return sorted(patient_folders)
  109. def find_protocol_folders(self, patient_folder):
  110. """Find protocol folders within a patient folder"""
  111. protocol_folders = []
  113. for item in patient_folder.iterdir():
  114. if item.is_dir():
  115. protocol_folders.append(item)
  117. return protocol_folders
  119. def get_dicom_files(self, protocol_folder):
  120. """Get all DICOM files from a protocol folder, excluding PNG files"""
  121. dicom_files = []
  123. for file in protocol_folder.iterdir():
  124. if file.is_file() and not file.suffix.lower() == '.png':
  125. if self.is_dicom_file(file):
  126. dicom_files.append(file)
  128. return sorted(dicom_files)
  130. def is_dicom_file(self, file_path):
  131. """Check if file is a valid DICOM file"""
  132. try:
  133. pydicom.dcmread(file_path, stop_before_pixels=True)
  134. return True
  135. except:
  136. return False
  138. def standardize_protocol_name(self, protocol_name):
  139. """Standardize protocol names using mapping"""
  140. return self.protocol_mapping.get(protocol_name, protocol_name.upper())
  142. def extract_comprehensive_metadata(self, protocol_folder, dicom_files):
  143. """Extract comprehensive metadata from DICOM series for MS research"""
  144. if not dicom_files:
  145. return None
  147. # Read first and last DICOM files for comprehensive metadata
  148. first_ds = pydicom.dcmread(dicom_files[0])
  149. last_ds = pydicom.dcmread(dicom_files[-1]) if len(dicom_files) > 1 else first_ds
  151. # Helper function to safely get DICOM attribute
  152. def safe_get(ds, attr, default=None):
  153. try:
  154. value = getattr(ds, attr, default)
  155. if hasattr(value, 'value'): # Handle DataElement objects
  156. return value.value
  157. return value
  158. except:
  159. return default
  161. # Convert MultiValue objects to lists
  162. def convert_multivalue(value):
  163. if hasattr(value, '__iter__') and not isinstance(value, (str, bytes)):
  164. try:
  165. return list(value)
  166. except:
  167. return str(value)
  168. return value
  170. metadata = {
  171. # === PATIENT INFORMATION ===
  172. "PatientID": safe_get(first_ds, 'PatientID', 'Unknown'),
  173. "PatientName": str(safe_get(first_ds, 'PatientName', 'Anonymous')),
  174. "PatientAge": safe_get(first_ds, 'PatientAge', 'Unknown'),
  175. "PatientSex": safe_get(first_ds, 'PatientSex', 'Unknown'),
  176. "PatientBirthDate": safe_get(first_ds, 'PatientBirthDate', 'Unknown'),
  177. "PatientWeight": safe_get(first_ds, 'PatientWeight', None),
  178. "PatientSize": safe_get(first_ds, 'PatientSize', None),
  179. "PatientPosition": safe_get(first_ds, 'PatientPosition', 'Unknown'),
  181. # === STUDY INFORMATION ===
  182. "StudyDate": safe_get(first_ds, 'StudyDate', 'Unknown'),
  183. "StudyTime": safe_get(first_ds, 'StudyTime', 'Unknown'),
  184. "StudyDescription": safe_get(first_ds, 'StudyDescription', 'Unknown'),
  185. "StudyInstanceUID": safe_get(first_ds, 'StudyInstanceUID', 'Unknown'),
  186. "StudyID": safe_get(first_ds, 'StudyID', 'Unknown'),
  187. "AccessionNumber": safe_get(first_ds, 'AccessionNumber', 'Unknown'),
  188. "ReferringPhysicianName": str(safe_get(first_ds, 'ReferringPhysicianName', 'Unknown')),
  189. "InstitutionName": safe_get(first_ds, 'InstitutionName', 'Unknown'),
  190. "InstitutionAddress": safe_get(first_ds, 'InstitutionAddress', 'Unknown'),
  191. "InstitutionalDepartmentName": safe_get(first_ds, 'InstitutionalDepartmentName', 'Unknown'),
  193. # === SERIES INFORMATION ===
  194. "SeriesDescription": safe_get(first_ds, 'SeriesDescription', 'Unknown'),
  195. "SeriesNumber": safe_get(first_ds, 'SeriesNumber', 'Unknown'),
  196. "SeriesInstanceUID": safe_get(first_ds, 'SeriesInstanceUID', 'Unknown'),
  197. "SeriesDate": safe_get(first_ds, 'SeriesDate', 'Unknown'),
  198. "SeriesTime": safe_get(first_ds, 'SeriesTime', 'Unknown'),
  199. "ProtocolName": safe_get(first_ds, 'ProtocolName', protocol_folder.name),
  200. "Modality": safe_get(first_ds, 'Modality', 'MR'),
  202. # === MR ACQUISITION PARAMETERS (Critical for MS research) ===
  203. "MagneticFieldStrength": safe_get(first_ds, 'MagneticFieldStrength', None),
  204. "SliceThickness": safe_get(first_ds, 'SliceThickness', None),
  205. "SpacingBetweenSlices": safe_get(first_ds, 'SpacingBetweenSlices', None),
  206. "RepetitionTime": safe_get(first_ds, 'RepetitionTime', None),
  207. "EchoTime": safe_get(first_ds, 'EchoTime', None),
  208. "InversionTime": safe_get(first_ds, 'InversionTime', None),
  209. "FlipAngle": safe_get(first_ds, 'FlipAngle', None),
  210. "EchoNumbers": safe_get(first_ds, 'EchoNumbers', None),
  211. "NumberOfAverages": safe_get(first_ds, 'NumberOfAverages', None),
  212. "ImagingFrequency": safe_get(first_ds, 'ImagingFrequency', None),
  213. "ImagedNucleus": safe_get(first_ds, 'ImagedNucleus', None),
  214. "MagneticFieldStrength": safe_get(first_ds, 'MagneticFieldStrength', None),
  216. # === SPATIAL INFORMATION ===
  217. "PixelSpacing": convert_multivalue(safe_get(first_ds, 'PixelSpacing', None)),
  218. "Rows": safe_get(first_ds, 'Rows', None),
  219. "Columns": safe_get(first_ds, 'Columns', None),
  220. "AcquisitionMatrix": convert_multivalue(safe_get(first_ds, 'AcquisitionMatrix', None)),
  221. "FOVDimensions": convert_multivalue(safe_get(first_ds, 'FOVDimensions', None)),
  222. "SliceLocation": safe_get(first_ds, 'SliceLocation', None),
  223. "ImageOrientationPatient": convert_multivalue(safe_get(first_ds, 'ImageOrientationPatient', None)),
  224. "ImagePositionPatient": convert_multivalue(safe_get(first_ds, 'ImagePositionPatient', None)),
  226. # === SEQUENCE INFORMATION (Important for MS protocols) ===
  227. "ImageType": convert_multivalue(safe_get(first_ds, 'ImageType', 'Unknown')),
  228. "ScanningSequence": convert_multivalue(safe_get(first_ds, 'ScanningSequence', 'Unknown')),
  229. "SequenceVariant": convert_multivalue(safe_get(first_ds, 'SequenceVariant', 'Unknown')),
  230. "ScanOptions": convert_multivalue(safe_get(first_ds, 'ScanOptions', 'Unknown')),
  231. "MRAcquisitionType": safe_get(first_ds, 'MRAcquisitionType', 'Unknown'),
  232. "SequenceName": safe_get(first_ds, 'SequenceName', 'Unknown'),
  233. "PulseSequenceName": safe_get(first_ds, 'PulseSequenceName', 'Unknown'),
  235. # === EQUIPMENT INFORMATION ===
  236. "Manufacturer": safe_get(first_ds, 'Manufacturer', 'Unknown'),
  237. "ManufacturerModelName": safe_get(first_ds, 'ManufacturerModelName', 'Unknown'),
  238. "SoftwareVersions": convert_multivalue(safe_get(first_ds, 'SoftwareVersions', 'Unknown')),
  239. "DeviceSerialNumber": safe_get(first_ds, 'DeviceSerialNumber', 'Unknown'),
  240. "StationName": safe_get(first_ds, 'StationName', 'Unknown'),
  242. # === CONTRAST AND IMAGE PARAMETERS ===
  243. "ContrastBolusAgent": safe_get(first_ds, 'ContrastBolusAgent', None),
  244. "ContrastBolusRoute": safe_get(first_ds, 'ContrastBolusRoute', None),
  245. "ContrastBolusVolume": safe_get(first_ds, 'ContrastBolusVolume', None),
  246. "WindowCenter": convert_multivalue(safe_get(first_ds, 'WindowCenter', None)),
  247. "WindowWidth": convert_multivalue(safe_get(first_ds, 'WindowWidth', None)),
  248. "RescaleIntercept": safe_get(first_ds, 'RescaleIntercept', None),
  249. "RescaleSlope": safe_get(first_ds, 'RescaleSlope', None),
  251. # === TIMING AND PHYSIOLOGICAL ===
  252. "AcquisitionTime": safe_get(first_ds, 'AcquisitionTime', None),
  253. "ContentTime": safe_get(first_ds, 'ContentTime', None),
  254. "TriggerTime": safe_get(first_ds, 'TriggerTime', None),
  255. "HeartRate": safe_get(first_ds, 'HeartRate', None),
  256. "CardiacNumberOfImages": safe_get(first_ds, 'CardiacNumberOfImages', None),
  258. # === BODY PART AND POSITIONING ===
  259. "BodyPartExamined": safe_get(first_ds, 'BodyPartExamined', 'Unknown'),
  260. "PatientPosition": safe_get(first_ds, 'PatientPosition', 'Unknown'),
  261. "ViewPosition": safe_get(first_ds, 'ViewPosition', None),
  263. # === SLICE INFORMATION ===
  264. "SliceLocation_First": safe_get(first_ds, 'SliceLocation', None),
  265. "SliceLocation_Last": safe_get(last_ds, 'SliceLocation', None),
  266. "InstanceNumber_First": safe_get(first_ds, 'InstanceNumber', None),
  267. "InstanceNumber_Last": safe_get(last_ds, 'InstanceNumber', None),
  269. # === FILE AND PROCESSING INFORMATION ===
  270. "NumberOfSlices": len(dicom_files),
  271. "DicomFiles": [f.name for f in dicom_files],
  272. "ProtocolFolder": protocol_folder.name,
  273. "OriginalPath": str(protocol_folder),
  274. "ConversionDate": datetime.now().isoformat(),
  275. "ConversionMethod": self.method,
  277. # === MS-SPECIFIC RESEARCH METADATA ===
  278. "MSProtocolType": self.standardize_protocol_name(protocol_folder.name),
  279. "IsFlairSequence": "FLAIR" in protocol_folder.name.upper(),
  280. "IsT1Weighted": "T1" in protocol_folder.name.upper(),
  281. "IsT2Weighted": "T2" in protocol_folder.name.upper(),
  282. "IsSuppressedFlair": "SG" in protocol_folder.name.upper(),
  284. # === ADDITIONAL TECHNICAL PARAMETERS ===
  285. "BitsAllocated": safe_get(first_ds, 'BitsAllocated', None),
  286. "BitsStored": safe_get(first_ds, 'BitsStored', None),
  287. "HighBit": safe_get(first_ds, 'HighBit', None),
  288. "PixelRepresentation": safe_get(first_ds, 'PixelRepresentation', None),
  289. "PhotometricInterpretation": safe_get(first_ds, 'PhotometricInterpretation', None),
  290. "SamplesPerPixel": safe_get(first_ds, 'SamplesPerPixel', None),
  292. # === RESEARCH-SPECIFIC QUALITY METRICS ===
  293. "SNR_Estimated": None, # Can be calculated post-conversion
  294. "ImageQualityScore": None, # For future quality assessment
  295. "MotionArtifacts": None, # For future artifact detection
  296. }
  298. # Convert numpy arrays and special types to JSON-serializable formats
  299. for key, value in metadata.items():
  300. if isinstance(value, np.ndarray):
  301. metadata[key] = value.tolist()
  302. elif hasattr(value, '__iter__') and not isinstance(value, (str, bytes)) and value is not None:
  303. try:
  304. metadata[key] = list(value)
  305. except:
  306. metadata[key] = str(value)
  307. elif value is not None and not isinstance(value, (int, float, str, bool, list, dict)):
  308. metadata[key] = str(value)
  310. return metadata
  312. def convert_with_dicom2nifti(self, protocol_folder, output_path):
  313. """Convert using dicom2nifti library (fixed - removed invalid reorient parameter)"""
  314. try:
  315. # Fixed: removed the invalid 'reorient' parameter
  316. dicom_series_to_nifti(str(protocol_folder), str(output_path))
  317. return True
  318. except Exception as e:
  319. logging.error(f"dicom2nifti conversion failed for {protocol_folder}: {e}")
  320. return False
  322. def convert_with_dcm2niix(self, protocol_folder, output_path):
  323. """Convert using dcm2niix"""
  324. try:
  325. # Check if dcm2niix is available
  326. subprocess.run(['dcm2niix', '-h'], capture_output=True, check=True)
  328. # Run dcm2niix with research-optimized settings
  329. cmd = [
  330. 'dcm2niix',
  331. '-z', 'y', # Compress output
  332. '-f', output_path.stem, # Output filename
  333. '-o', str(output_path.parent), # Output directory
  334. '-b', 'y', # Create BIDS sidecar JSON
  335. '-ba', 'y', # Anonymize BIDS
  336. '-v', 'y', # Verbose output
  337. str(protocol_folder)
  338. ]
  340. result = subprocess.run(cmd, capture_output=True, text=True)
  342. if result.returncode == 0:
  343. return True
  344. else:
  345. logging.error(f"dcm2niix failed for {protocol_folder}: {result.stderr}")
  346. return False
  348. except (subprocess.CalledProcessError, FileNotFoundError):
  349. logging.error("dcm2niix not found. Install from: https://github.com/rordenlab/dcm2niix")
  350. return False
  352. def convert_with_nibabel(self, protocol_folder, output_path):
  353. """Convert using nibabel with enhanced header preservation"""
  354. try:
  355. dicom_files = self.get_dicom_files(protocol_folder)
  357. if not dicom_files:
  358. return False
  360. # Read DICOM files
  361. slices = []
  362. for dicom_file in dicom_files:
  363. ds = pydicom.dcmread(dicom_file)
  364. slices.append(ds)
  366. # Sort by slice location or instance number
  367. try:
  368. slices.sort(key=lambda x: float(getattr(x, 'SliceLocation', 0)))
  369. except:
  370. try:
  371. slices.sort(key=lambda x: int(getattr(x, 'InstanceNumber', 0)))
  372. except:
  373. logging.warning(f"Could not sort slices for {protocol_folder}")
  375. # Create 3D array
  376. pixel_arrays = [s.pixel_array.astype(np.float32) for s in slices]
  377. volume = np.stack(pixel_arrays, axis=-1)
  379. # Get voxel spacing and create proper affine matrix
  380. ds = slices[0]
  381. pixel_spacing = getattr(ds, 'PixelSpacing', [1.0, 1.0])
  382. slice_thickness = getattr(ds, 'SliceThickness', 1.0)
  384. # Create more accurate affine matrix
  385. affine = np.eye(4)
  386. affine[0, 0] = float(pixel_spacing[0])
  387. affine[1, 1] = float(pixel_spacing[1])
  388. affine[2, 2] = float(slice_thickness)
  390. # Try to get image position for better spatial alignment
  391. try:
  392. img_pos = getattr(ds, 'ImagePositionPatient', [0, 0, 0])
  393. affine[0, 3] = float(img_pos[0])
  394. affine[1, 3] = float(img_pos[1])
  395. affine[2, 3] = float(img_pos[2])
  396. except:
  397. pass
  399. # Create NIfTI image with enhanced header
  400. nifti_img = nib.Nifti1Image(volume, affine)
  402. # Set additional header information
  403. header = nifti_img.header
  404. header.set_xyzt_units('mm', 'sec')
  406. # Set data type appropriately
  407. if volume.dtype == np.float32:
  408. header.set_data_dtype(np.float32)
  409. else:
  410. header.set_data_dtype(volume.dtype)
  412. nib.save(nifti_img, output_path)
  413. return True
  415. except Exception as e:
  416. logging.error(f"nibabel conversion failed for {protocol_folder}: {e}")
  417. return False
  419. def process_patient(self, patient_folder):
  420. """Process all protocols for a single patient"""
  421. patient_id = patient_folder.name
  422. logging.info(f"Processing patient: {patient_id}")
  424. # Create patient output directory
  425. patient_output_dir = self.output_dir / patient_id
  426. patient_output_dir.mkdir(parents=True, exist_ok=True)
  428. # Find protocol folders
  429. protocol_folders = self.find_protocol_folders(patient_folder)
  431. if not protocol_folders:
  432. logging.warning(f"No protocol folders found for patient {patient_id}")
  433. return
  435. patient_conversions = 0
  436. patient_failures = 0
  438. for protocol_folder in protocol_folders:
  439. protocol_name = protocol_folder.name
  440. standardized_protocol = self.standardize_protocol_name(protocol_name)
  442. # Check if folder contains DICOM files
  443. dicom_files = self.get_dicom_files(protocol_folder)
  445. if not dicom_files:
  446. logging.warning(f"No DICOM files found in {protocol_folder}")
  447. patient_failures += 1
  448. continue
  450. # Generate output filename: {6-digit patientID}_{protocol}.nii.gz
  451. filename = f"{patient_id}_{standardized_protocol}.nii.gz"
  452. nifti_path = patient_output_dir / filename
  453. json_path = patient_output_dir / filename.replace('.nii.gz', '.json')
  455. logging.info(f" Converting {protocol_name} -> {filename}")
  457. # Convert based on selected method
  458. success = False
  459. if self.method == 'dicom2nifti':
  460. success = self.convert_with_dicom2nifti(protocol_folder, nifti_path)
  461. elif self.method == 'dcm2niix':
  462. success = self.convert_with_dcm2niix(protocol_folder, nifti_path)
  463. elif self.method == 'nibabel':
  464. success = self.convert_with_nibabel(protocol_folder, nifti_path)
  466. if success:
  467. patient_conversions += 1
  468. self.converted_series += 1
  469. # Using regular characters instead of special Unicode characters
  470. logging.info(f" [SUCCESS] Successfully converted: {nifti_path}")
  472. # Save comprehensive metadata as JSON
  473. metadata = self.extract_comprehensive_metadata(protocol_folder, dicom_files)
  474. if metadata:
  475. with open(json_path, 'w', encoding='utf-8') as f:
  476. json.dump(metadata, f, indent=2, default=str, ensure_ascii=False)
  477. logging.info(f" [SUCCESS] Metadata saved: {json_path}")
  478. else:
  479. patient_failures += 1
  480. self.failed_series += 1
  481. # Using regular characters instead of special Unicode characters
  482. logging.error(f" [FAILED] Failed to convert: {protocol_folder}")
  484. logging.info(f"Patient {patient_id} completed: {patient_conversions} successful, {patient_failures} failed")
  485. self.processed_patients += 1
  487. def convert_all(self):
  488. """Convert all patients and protocols"""
  489. patient_folders = self.find_patient_folders()
  491. if not patient_folders:
  492. logging.error("No patient folders (6-digit numeric) found in input directory")
  493. return
  495. logging.info(f"Found {len(patient_folders)} patient folders to process")
  496. logging.info(f"Expected protocols per patient: FLAIR, FLAIR_SG, T1WI, T2WI")
  498. for i, patient_folder in enumerate(patient_folders, 1):
  499. logging.info(f"\nProcessing patient {i}/{len(patient_folders)}: {patient_folder.name}")
  500. self.process_patient(patient_folder)
  502. self.print_summary()
  504. def print_summary(self):
  505. """Print conversion summary"""
  506. print("\n" + "=" * 80)
  507. print("MS DATASET DICOM TO NIFTI CONVERSION SUMMARY")
  508. print("=" * 80)
  509. print(f"Input directory: {self.input_dir}")
  510. print(f"Output directory: {self.output_dir}")
  511. print(f"Conversion method: {self.method}")
  512. print("-" * 80)
  513. print(f"Patients processed: {self.processed_patients}")
  514. print(f"Protocol series successfully converted: {self.converted_series}")
  515. print(f"Protocol series failed: {self.failed_series}")
  516. print(f"Total protocol series: {self.converted_series + self.failed_series}")
  517. if (self.converted_series + self.failed_series) > 0:
  518. success_rate = (self.converted_series / (self.converted_series + self.failed_series) * 100)
  519. print(f"Success rate: {success_rate:.1f}%")
  520. else:
  521. print("Success rate: N/A")
  522. print("-" * 80)
  523. print("OUTPUT STRUCTURE:")
  524. print("Output_Directory/")
  525. print(" |-- 001/")
  526. print(" | |-- 001_FLAIR.nii.gz")
  527. print(" | |-- 001_FLAIR.json")
  528. print(" | |-- 001_FLAIR_SG.nii.gz")
  529. print(" | |-- 001_FLAIR_SG.json")
  530. print(" | |-- 001_T1WI.nii.gz")
  531. print(" | |-- 001_T1WI.json")
  532. print(" | |-- 001_T2WI.nii.gz")
  533. print(" | |-- 001_T2WI.json")
  534. print(" |-- 002/")
  535. print(" |-- ...")
  536. print("-" * 80)
  537. print("RESEARCH-READY FEATURES:")
  538. print("+ MS-specific protocol standardization")
  539. print("+ Comprehensive DICOM header preservation")
  540. print("+ Research-quality NIfTI format with proper spatial information")
  541. print("+ Detailed JSON metadata files with >50 DICOM attributes")
  542. print("+ Professional naming convention: {PatientID}_{Protocol}.nii.gz")
  543. print("+ UTF-8 encoding support for international characters")
  544. print("+ Enhanced spatial alignment and orientation")
  545. if self.method == 'dcm2niix':
  546. print("+ BIDS-compatible output")
  547. print("=" * 80)
  550. # Example usage
  551. if __name__ == "__main__":
  552. # MS Dataset directories
  553. input_directory = r"E:\MBashiri\Thesis\p6\Data\MS_100_patient_full"
  554. output_directory = r"E:\MBashiri\Thesis\p6\Data\MS_100_patient_nifti"
  556. print("MS DATASET DICOM TO NIFTI CONVERTER - RESEARCH EDITION")
  557. print("=" * 60)
  558. print("Directory Structure Expected:")
  559. print("Input/")
  560. print(" |-- 001/ # 6-digit patient ID")
  561. print(" | |-- FLAIR/ # Protocol folders")
  562. print(" | |-- FLAIR_SG/")
  563. print(" | |-- T1WI/")
  564. print(" | |-- T2WI/")
  565. print(" |-- 002/")
  566. print(" |-- ...")
  567. print("=" * 60)
  568. print("Available conversion methods:")
  569. print("1. 'dicom2nifti' - Reliable Python library (recommended)")
  570. print("2. 'dcm2niix' - Most comprehensive (requires installation)")
  571. print("3. 'nibabel' - Enhanced fallback method with better header preservation")
  572. print("=" * 60)
  574. # Initialize converter with dicom2nifti (recommended for MS research)
  575. converter = MSDatasetDicomToNiftiConverter(
  576. input_directory=input_directory,
  577. output_directory=output_directory,
  578. method='dicom2nifti' # Change to 'dcm2niix' if available
  579. )
  581. # Start conversion
  583. converter.convert_all()

dicom_to_nifti.py at commit c265bae, under MIT · at the source

Overview

Authors: Mahdi Bashiri Bawil1, Mousa Shamsi1, Aydin Ghalehasadi2, Ali Fahmi Jafargholkhanloo3, Abolhassan Shakeri Bavil4
ORCID iDs: Mahdi Bashiri Bawil, Mousa Shamsi, Aydin Ghalehasadi, Ali Fahmi Jafargholkhanloo, Abolhassan Shakeri Bavil
  1. Biomedical Engineering Faculty, Sahand University of Technology,Tabriz, Iran
  2. Faculty of Physics, University of Tabriz,Tabriz, Iran
  3. Department of Engineering Sciences, Faculty of Advanced Technologies, University of Mohaghegh Ardabili,Namin, Iran
  4. Radiology Department, Tabriz University of Medical Sciences,Tabriz, Iran
Institutions: Sahand University of Technology (Iran); University of Tabriz (Iran); University of Mohaghegh Ardabili (Iran); Tabriz University of Medical Sciences (Iran)
Journal: Scientific data, volume 13, issue 1, article 867
Dates: received 11 October 2025; accepted 31 March 2026; published online 14 April 2026
Type: Data paper · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41597-026-07184-5 · PMID 41980977 · PMCID PMC13249843 · OpenAlex W7154269800
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), multiple sclerosis (population), methods / tools (subfield)
Methods: Connectivity
MeSH: Magnetic Resonance Imaging*, Multiple Sclerosis*, Datasets as Topic, Female, Humans, Male, White Matter (* major topic)
Journal subjects: Data Descriptor
Topic: Medical Image Segmentation Techniques (Computer Vision and Pattern Recognition, Computer Science), according to OpenAlex
Citations: cited by 4 papers (Europe PMC); 30 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

Its files are read in the Code ↔ Paper reader above, with 17 matches between paragraphs and lines of code.

Mahdi-Bashiri/MS3SEG

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: c265bae327691c279ff6651a98e264d70103def7, 14 February 2026
Languages: Python (24)
Size: 43 files, 24 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (15 files), Keras (10 files), TensorFlow (10 files), NiBabel (6 files), pandas (6 files), pydicom (6 files), SciPy (4 files), OpenCV (3 files), Matplotlib (2 files), scikit-image (2 files), scikit-learn (2 files), seaborn (2 files), dcm2niix (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
26 files
At the source: github.com/Mahdi-Bashiri/MS3SEG

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41597-026-07184-5.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 24 scripts, each with its path and the digest of its content;
  • 17 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Availability statements

The paper has a data availability statement and a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing them here; in short, from what the harvester recognized in them:

  • no repository, dataset or request procedure was recognized in them

Read them in the paper: doi.org/10.1038/s41597-026-07184-5.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 7 MeSH terms, 29 references.

Cite

This paper

Bawil, M. B., Shamsi, M., Ghalehasadi, A., Jafargholkhanloo, A. F., & Bavil, A. S. (2026). A Multiple Sclerosis MRI Dataset with Tri-Mask Annotations for Lesion Segmentation. Scientific data, 13(1), 867. https://doi.org/10.1038/s41597-026-07184-5

BibTeX

@article{bawil2026multiple,
author = {Bawil, Mahdi Bashiri and Shamsi, Mousa and Ghalehasadi, Aydin and Jafargholkhanloo, Ali Fahmi and Bavil, Abolhassan Shakeri},
title = {{A Multiple Sclerosis MRI Dataset with Tri-Mask Annotations for Lesion Segmentation}},
journal = {Scientific data},
year = {2026},
month = apr,
volume = {13},
number = {1},
pages = {867},
publisher = {Nature Publishing Group},
issn = {2052-4463},
doi = {10.1038/s41597-026-07184-5},
url = {https://doi.org/10.1038/s41597-026-07184-5},
pmid = {41980977},
pmcid = {PMC13249843}
}

RIS

TY - JOUR
AU - Bawil, Mahdi Bashiri
AU - Shamsi, Mousa
AU - Ghalehasadi, Aydin
AU - Jafargholkhanloo, Ali Fahmi
AU - Bavil, Abolhassan Shakeri
TI - A Multiple Sclerosis MRI Dataset with Tri-Mask Annotations for Lesion Segmentation
T2 - Scientific data
J2 - Sci Data
PY - 2026
DA - 2026/04/14
VL - 13
IS - 1
SP - 867
SN - 2052-4463
PB - Nature Publishing Group
DO - 10.1038/s41597-026-07184-5
UR - https://doi.org/10.1038/s41597-026-07184-5
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41597-026-07184-5",
"type": "article-journal",
"title": "A Multiple Sclerosis MRI Dataset with Tri-Mask Annotations for Lesion Segmentation",
"container-title": "Scientific data",
"author": [
{
"family": "Bawil",
"given": "Mahdi Bashiri"
},
{
"family": "Shamsi",
"given": "Mousa"
},
{
"family": "Ghalehasadi",
"given": "Aydin"
},
{
"family": "Jafargholkhanloo",
"given": "Ali Fahmi"
},
{
"family": "Bavil",
"given": "Abolhassan Shakeri"
}
],
"container-title-short": "Sci Data",
"volume": "13",
"issue": "1",
"page": "867",
"DOI": "10.1038/s41597-026-07184-5",
"PMID": "41980977",
"PMCID": "PMC13249843",
"ISSN": "2052-4463",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41597-026-07184-5",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
14
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1186/s12880-026-02481-2 [code]
Deep learning-based neuroanatomical profiling reveals population-specific brain changes in multiple sclerosis: a large-scale Middle Eastern study.
Journal: BMC medical imaging
In common: pydicom, Keras, TensorFlow, 9 other tools, multiple sclerosis, structural MRI / diffusion, 6 references, 3 authors
[2] doi:10.1186/s12938-026-01555-0 [code]
Incorporating normal periventricular changes for enhanced pathological white matter hyperintensity segmentation: on multiclass deep learning approaches.
Journal: Biomedical engineering online
In common: Keras, TensorFlow, OpenCV, 7 other tools, methods / tools, structural MRI / diffusion, 3 references, 4 authors
[3] doi:10.1371/journal.pdig.0001316 [code]
Reliability of a convolutional neural network in segmenting multiple sclerosis lesions from MRI: Impact of data augmentation, image modality and tolerance with U-Net architecture.
Journal: PLOS digital health
In common: scikit-image, NiBabel, scikit-learn, 3 other tools, multiple sclerosis, methods / tools, structural MRI / diffusion, 6 references
[4] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: pydicom, Keras, TensorFlow, 8 other tools
[5] doi:10.1162/imag.a.1183 [code]
Learning-based segmentation of diffusion-weighted MR images with arbitrary <i>q</i>-space samplings.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Keras, TensorFlow, scikit-image, 5 other tools, methods / tools, structural MRI / diffusion, 3 references
[6] doi:10.1080/07853890.2026.2685416 [code]
Pulmonary and cerebral damage in COVID-19 survivors: is there any association?
Journal: Annals of medicine
In common: pydicom, Keras, TensorFlow, 7 other tools, structural MRI / diffusion
[7] doi:10.21037/qims-2026-0792 [code]
An nnU-Net-based framework with adaptive feature representation for 3D brain tumor segmentation.
Journal: Quantitative imaging in medicine and surgery
In common: OpenCV, scikit-image, NiBabel, 6 other tools, methods / tools, structural MRI / diffusion, 2 references
[8] doi:10.3389/frai.2026.1771088 [code]
Few-shot deployment of pretrained MRI transformers in brain imaging tasks.
Journal: Frontiers in artificial intelligence
In common: pydicom, OpenCV, scikit-image, 7 other tools, methods / tools, structural MRI / diffusion
[9] doi:10.64898/2026.07.15.26357954 [code]
Portable Ultra-Low Field MRI Deep-Learning Algorithms for White Matter Lesion Segmentation Improve Accuracy and Reflect Clinical Disability in Multiple Sclerosis
Journal: medRxiv (preprint)
In common: scikit-image, NiBabel, seaborn, 5 other tools, multiple sclerosis, structural MRI / diffusion, 2 references
[10] doi:10.1002/epi.70296 [code]
Fully automated three-dimensional deep learning-based magnetic resonance imaging segmentation of brain cavities in epilepsy surgery.
Journal: Epilepsia
In common: Keras, TensorFlow, OpenCV, 7 other tools, structural MRI / diffusion

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.