Datasets:

didsr
/

msynth

	# Copyright 2022 for msynth dataset
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	'''
	Custom dataset-builder for msynth dataset
	'''

	import os
	import datasets
	import glob
	import re

	logger = datasets.logging.get_logger(__name__)

	_CITATION = """\
	@article{sizikova2023knowledge,
	title={Knowledge-based in silico models and dataset for the comparative evaluation of mammography AI for a range of breast characteristics, lesion conspicuities and doses},
	author={Sizikova, Elena and Saharkhiz, Niloufar and Sharma, Diksha and Lago, Miguel and Sahiner, Berkman and Delfino, Jana G. and Badano, Aldo},
	journal={Advances in Neural Information Processing Systems},
	volume={},
	pages={16764--16778},
	year={2023}
	"""


	_DESCRIPTION = """\
	M-SYNTH is a synthetic digital mammography (DM) dataset with four breast fibroglandular density distributions imaged using Monte Carlo x-ray simulations with the publicly available Virtual Imaging Clinical Trial for Regulatory Evaluation (VICTRE) toolkit.
	Curated by: Elena Sizikova, Niloufar Saharkhiz, Diksha Sharma, Miguel Lago, Berkman Sahiner, Jana Gut Delfino, Aldo Badano
	License: Creative Commons 1.0 Universal License (CC0)
	"""


	_HOMEPAGE = "link to the dataset description page (FDA/CDRH/OSEL/DIDSR/VICTRE_project)"

	_REPO = "https://huggingface.co/datasets/didsr/msynth/resolve/main/data"

	# satting parameters for the URLS
	_LESIONDENSITY = ["1.0","1.06", "1.1"]
	_DOSE = ["20%","40%","60%","80%","100%"]
	_DENSITY = ["fatty", "dense", "hetero","scattered"]
	_SIZE = ["5.0","7.0", "9.0"]
	_DETECTOR = 'SIM'

	_DOSETABLE = {
	"dense": {
	"20%": '1.73e09',
	"40%": '3.47e09',
	"60%": '5.20e09',
	"80%": '6.94e09',
	"100%": '8.67e09'
	},
	"hetero": {
	"20%": '2.04e09',
	"40%": '4.08e09',
	"60%": '6.12e09',
	"80%": '8.16e09',
	"100%": '1.02e10'
	},
	"scattered": {
	"20%": '4.08e09',
	"40%": '8.16e09',
	"60%": '1.22e10',
	"80%": '1.63e10',
	"100%": '2.04e10'
	},
	"fatty": {
	"20%": '4.44e09',
	"40%": '8.88e09',
	"60%": '1.33e10',
	"80%": '1.78e10',
	"100%": '2.22e10'
	}
	}
	# Links to download readme files
	_URLS = {
	"meta_data": f"{_REPO}/metadata/bounds.zip",
	"read_me": f"{_REPO}/README.md"
	}



	# Define the labels or classes in your dataset
	#_NAMES = ["raw", "mhd", "dicom", "loc"]

	DATA_DIR = {"all_data": "SIM", "seg": "SIM", "info": "bounds"}

	class msynthConfig(datasets.BuilderConfig):
	"""msynth dataset"""
	lesion_density = _LESIONDENSITY
	dose = _DOSE
	density = _DENSITY
	size = _SIZE
	def __init__(self, name, **kwargs):
	super(msynthConfig, self).__init__(
	version=datasets.Version("1.0.0"),
	name=name,
	description="msynth",
	**kwargs,
	)

	class msynth(datasets.GeneratorBasedBuilder):
	"""msynth dataset."""

	DEFAULT_WRITER_BATCH_SIZE = 256
	BUILDER_CONFIGS = [
	msynthConfig("device_data"),
	msynthConfig("segmentation_mask"),
	msynthConfig("metadata"),
	]

	def _info(self):
	if self.config.name == "device_data":
	# Define dataset features and keys
	features = datasets.Features(
	{
	"Raw": datasets.Value("string"),
	"mhd": datasets.Value("string"),
	"loc": datasets.Value("string"),
	"dcm": datasets.Value("string"),
	"density": datasets.Value("string"),
	"mass_radius": datasets.Value("float32")
	}
	)
	#keys = ("image", "metadata")
	elif self.config.name == "segmentation_mask":
	# Define features and keys
	features = datasets.Features(
	{
	"Raw": datasets.Value("string"),
	"mhd": datasets.Value("string"),
	"loc": datasets.Value("string"),
	"density": datasets.Value("string"),
	"mass_radius": datasets.Value("string")
	}
	)

	elif self.config.name == "metadata":
	# Define features and keys
	features = datasets.Features(
	{
	"fatty": datasets.Value("string"),
	"dense": datasets.Value("string"),
	"hetero": datasets.Value("string"),
	"scattered": datasets.Value("string")
	}
	)

	return datasets.DatasetInfo(
	description=_DESCRIPTION,
	features=features,
	supervised_keys=None,
	homepage=_HOMEPAGE,
	citation=_CITATION,
	)

	def _split_generators(
	self, dl_manager: datasets.utils.download_manager.DownloadManager):
	# Setting up the **config_kwargs parameters
	if self.config.lesion_density == "all":
	self.config.lesion_density = _LESIONDENSITY

	if self.config.dose == "all":
	self.config.dose = _DOSE

	if self.config.density == "all":
	self.config.density = _DENSITY

	if self.config.size == "all":
	self.config.size = _SIZE


	if self.config.name == "device_data":
	file_name = []
	for ld in self.config.lesion_density:
	for ds in self.config.dose:
	for den in self.config.density:
	value = _DOSETABLE[den][ds]
	for sz in self.config.size:
	temp_name = []
	temp_name = (
	"device_data_VICTREPhantoms_spic_"
	+ ld
	+ "/"
	+ value
	+ "/"
	+ den
	+ "/2/"
	+ sz
	+ "/"
	+ _DETECTOR
	+ ".zip"
	)
	file_name.append(_REPO +"/"+ temp_name)

	# Downloading the data files
	# data_dir = dl_manager.download_and_extract(file_name)
	data_dir = []
	for url in file_name:
	try:
	temp_down_file = []
	# Attempt to download the file
	temp_down_file = dl_manager.download_and_extract(url)
	data_dir.append(temp_down_file)

	except Exception as e:
	# If an exception occurs (e.g., file not found), log the error and add the URL to the failed_urls list
	#logger.error(f"Failed to download {url}: {e} because it is not present. Moving on to the next available file")
	logger.error(f"Data combination {url} is not included")

	return [
	datasets.SplitGenerator(
	name="device_data",
	gen_kwargs={
	"files": [data_dir_t for data_dir_t in data_dir],
	"name": "all_data",
	},
	),
	]

	elif self.config.name == "segmentation_mask":
	seg_file_name = []
	for den in self.config.density:
	for sz in self.config.size:
	temp_name = []
	temp_name = (
	"segmentation_masks"
	+ "/"
	+ den
	+ "/2/"
	+ sz
	+ "/"
	+ _DETECTOR
	+ ".zip"
	)
	seg_file_name.append(_REPO+ "/" + temp_name)

	# Downloading the files
	seg_dir = []
	#seg_dir = dl_manager.download_and_extract(seg_file_name)

	for url in seg_file_name:
	try:
	# Attempt to download the file
	temp_down_file = []
	temp_down_file = dl_manager.download_and_extract(url)
	seg_dir.append(temp_down_file)

	except Exception as e:
	# If an exception occurs (e.g., file not found), log the error and add the URL to the failed_urls list
	logger.error(f"Failed to download {url}: {e} because it is not present. Moving on to the next available file")

	return [
	datasets.SplitGenerator(
	name="segmentation_mask",
	gen_kwargs={
	"files": [data_dir_t for data_dir_t in seg_dir],
	"name": "seg",
	},
	),
	]

	elif self.config.name == "metadata":
	meta_dir = dl_manager.download_and_extract(_URLS['meta_data'])
	return [
	datasets.SplitGenerator(
	name="metadata",
	gen_kwargs={
	"files": meta_dir,
	"name": "info",
	},
	),
	]


	def get_all_file_paths(self, root_directory):
	file_paths = [] # List to store file paths

	# Walk through the directory and its subdirectories using os.walk
	for folder, _, files in os.walk(root_directory):
	for file in files:
	if file.endswith('.raw'):
	# Get the full path of the file
	file_path = os.path.join(folder, file)
	file_paths.append(file_path)
	return file_paths

	def get_support_file_path(self, raw_file_path, ext):
	folder_path = os.path.dirname(raw_file_path)
	# Use os.path.basename() to extract the filename
	raw_file_name = os.path.basename(raw_file_path)
	# Use os.path.splitext() to split the filename into root and extension
	root, extension = os.path.splitext(raw_file_name)
	if ext == "dcm":
	supp_file_name = f"000.{ext}"
	file_path = os.path.join(folder_path,"DICOM_dm",supp_file_name)
	else:
	supp_file_name = f"{root}.{ext}"
	file_path = os.path.join(folder_path, supp_file_name)

	if os.path.isfile(file_path):
	return file_path
	else:
	return "Not available for this raw file"

	def sort_file_paths(self, file_paths):
	digit_numbers = []
	for file_path in file_paths:
	for word in _DENSITY:
	if word in file_path:
	if self.config.name == "device_data":
	pattern = rf"{word}.(\d+\.)(\d+)"
	elif self.config.name == "segmentation_mask":
	pattern = rf"{word}.(\d+)"
	match = re.search(pattern, file_path)
	if self.config.name == "device_data":
	digit_numbers.append(int(match.group(2)))
	elif self.config.name == "segmentation_mask":
	digit_numbers.append(int(match.group(1)))
	break


	# Sort the list of numbers while keeping track of the original indices
	sorted_numbers_with_indices = sorted(enumerate(digit_numbers), key=lambda x: x[1])

	# Extract the sorted numbers and their original indices
	sorted_indices, sorted_numbers = zip(*sorted_numbers_with_indices)

	# Sort the file paths
	sorted_file_paths = [file_paths[i] for i in sorted_indices]

	return sorted_file_paths

	def _generate_examples(self, files, name):
	if self.config.name == "device_data":
	key = 0
	data_dir = []
	for folder in files:
	tmp_dir = []
	tmp_dir = self.get_all_file_paths(os.path.join(folder, DATA_DIR[name]))
	tmp_dir = self.sort_file_paths(tmp_dir)
	data_dir = data_dir + tmp_dir

	#data_dir = self.sort_file_paths(data_dir)
	for path in data_dir:
	res_dic = {}
	for word in _DENSITY:
	if word in path:
	breast_density = word
	pattern = rf"(\d+\.\d+)_{word}"
	match = re.search(pattern, path)
	matched_text = match.group(1)
	break

	# Get image id to filter the respective row of the csv
	image_id = os.path.basename(path)
	# Use os.path.splitext() to split the filename into root and extension
	root, extension = os.path.splitext(image_id)
	# Get the extension without the dot
	image_labels = extension.lstrip(".")
	res_dic["Raw"] = path
	res_dic["mhd"] = self.get_support_file_path(path, "mhd")
	res_dic["loc"] = self.get_support_file_path(path, "loc")
	res_dic["dcm"] = self.get_support_file_path(path, "dcm")
	res_dic["density"] = breast_density
	res_dic["mass_radius"] = matched_text

	yield key, res_dic
	key += 1


	if self.config.name == "segmentation_mask":
	key = 0
	data_dir = []
	examples = []
	for folder in files:
	tmp_dir = []
	tmp_dir = self.get_all_file_paths(os.path.join(folder, DATA_DIR[name]))
	tmp_dir = self.sort_file_paths(tmp_dir)
	data_dir = data_dir + tmp_dir

	#data_dir = self.sort_file_paths(data_dir)

	new_data_dir = [];
	count = 1;
	loc = 0;
	while loc < len(data_dir):
	if count % 2 == 1:
	new_data_dir.append(data_dir[loc])
	loc += 1
	else:
	new_data_dir.append("None")
	count += 1
	new_data_dir.append("None")

	for path in new_data_dir:
	res_dic = {}
	if path == "None":
	res_dic["Raw"] = "None"
	res_dic["mhd"] = "None"
	res_dic["loc"] = "None"
	res_dic["density"] = "None"
	res_dic["mass_radius"] = "None"

	else:
	for word in _DENSITY:
	if word in path:
	breast_density = word
	pattern = rf"(\d+\.\d+)_{word}"
	match = re.search(pattern, path)
	matched_text = match.group(1)
	break
	# Get image id to filter the respective row of the csv
	image_id = os.path.basename(path)
	# Use os.path.splitext() to split the filename into root and extension
	root, extension = os.path.splitext(image_id)
	# Get the extension without the dot
	image_labels = extension.lstrip(".")
	res_dic["Raw"] = path
	res_dic["mhd"] = self.get_support_file_path(path, "mhd")
	res_dic["loc"] = self.get_support_file_path(path, "loc")
	res_dic["density"] = breast_density
	res_dic["mass_radius"] = matched_text

	examples.append(res_dic)

	for example in examples:
	yield key, {**example}
	key += 1
	examples = []

	if self.config.name == "metadata":
	key = 0
	examples = list()
	meta_dir = os.path.join(files, DATA_DIR[name])

	res_dic = {
	"fatty": os.path.join(meta_dir,'bounds_fatty.npy'),
	"dense": os.path.join(meta_dir,'bounds_dense.npy'),
	"hetero": os.path.join(meta_dir,'bounds_hetero.npy'),
	"scattered": os.path.join(meta_dir,'bounds_scattered.npy')
	}
	yield key, res_dic
	key +=1