def setUp(self):
self.mr_small = dcmread(mr_name)
self.mr_rle = dcmread(mr_rle)
self.emri_small = dcmread(emri_name)
self.emri_rle = dcmread(emri_rle)
self.original_handlers = pydicom.config.image_handlers
pydicom.config.image_handlers = [rle_handler, numpy_handler]
def test_charset_patient_names(self, filename, patient_name):
"""Test patient names are correctly decoded and encoded."""
# check that patient names are correctly read
file_path = get_charset_files(filename + '.dcm')[0]
ds = dcmread(file_path)
ds.decode()
assert patient_name == ds.PatientName
# check that patient names are correctly written back
fp = DicomBytesIO()
fp.is_implicit_VR = False
fp.is_little_endian = True
ds.save_as(fp, write_like_original=False)
fp.seek(0)
ds = dcmread(fp)
assert patient_name == ds.PatientName
# check that patient names are correctly written back
# without original byte string (PersonName3 only)
if hasattr(ds.PatientName, 'original_string'):
ds.PatientName.original_string = None
fp = DicomBytesIO()
fp.is_implicit_VR = False
fp.is_little_endian = True
ds.save_as(fp, write_like_original=False)
fp.seek(0)
ds = dcmread(fp)
assert patient_name == ds.PatientName
def get_path_info_preview(self, path):
path_lower = path.lower()
#name
name = os.path.basename(os.path.normpath(path))
name_final = ("name: " + name)
path_sl = path + "/"
if ".jpg" in path_lower:
preview = ("Used path leads to current image.")
img = io.imread(path)
io.imshow(img)
io.show()
elif ".png" in path_lower:
preview = ("Used path leads to current image.")
img = io.imread(path)
io.imshow(img)
io.show()
elif ".dcm" in path_lower:
preview = ("Used path leads to current image.")
ds = pdicom.dcmread(path)
plt.imshow(ds.pixel_array, cmap=plt.cm.bone)
else:
preview = ("Preview of files in dir: " + name)
only_files = [f for f in listdir(path) if isfile(join(path, f))]
for x in only_files:
if (".dcm" or ".Dcm" or ".DCM") in x:
ending = os.path.basename(os.path.normpath(path_sl + x))
preview_path = path_sl + ending
ds = pdicom.dcmread(preview_path)
plt.imshow(ds.pixel_array, cmap=plt.cm.bone)
break
elif (".jpg" or ".Jpg" or ".JPG") in x:
ending = os.path.basename(os.path.normpath(path_sl + x))
preview_path = path_sl + ending
img = io.imread(preview_path)
io.imshow(img)
io.show()
break
elif (".png" or ".Png" or ".PNG") in x:
ending = os.path.basename(os.path.normpath(path_sl + x))
preview_path = path_sl + ending
img = io.imread(preview_path)
io.imshow(img)
io.show()
break
else:
None
break
def test_changed_character_set(self):
# Regression test for #629
multiPN_name = get_charset_files("chrFrenMulti.dcm")[0]
ds = dcmread(multiPN_name) # is Latin-1
ds.SpecificCharacterSet = 'ISO_IR 192'
from pydicom.filebase import DicomBytesIO
fp = DicomBytesIO()
ds.save_as(fp, write_like_original=False)
fp.seek(0)
ds_out = dcmread(fp)
# we expect UTF-8 encoding here
assert b'Buc^J\xc3\xa9r\xc3\xb4me' == ds_out.get_item(0x00100010).value
def test_encapsulate_single_fragment_per_frame_bot(self):
"""Test encapsulating single fragment per frame with BOT values."""
ds = dcmread(JP2K_10FRAME_NOBOT)
frames = decode_data_sequence(ds.PixelData)
assert len(frames) == 10
data = encapsulate(frames, fragments_per_frame=1, has_bot=True)
test_frames = decode_data_sequence(data)
for a, b in zip(test_frames, frames):
assert a == b
fp = DicomBytesIO(data)
fp.is_little_endian = True
offsets = get_frame_offsets(fp)
assert offsets == [
0x0000, # 0
0x0eee, # 3822
0x1df6, # 7670
0x2cf8, # 11512
0x3bfc, # 15356
0x4ade, # 19166
0x59a2, # 22946
0x6834, # 26676
0x76e2, # 30434
0x8594 # 34196
]
def setup(self):
# MONOCHROME2, 64x64, 1 sample/pixel, 16 bits allocated, 12 bits stored
self.ds = dcmread(EMRI_RLE_10F)
self.frames = decode_data_sequence(self.ds.PixelData)
assert len(self.frames) == 10
self.no_runs = 100
def is_CT_slice(file: str) -> bool:
"""Test if the file is a CT Image storage DICOM file."""
try:
ds = pydicom.dcmread(file, force=True, stop_before_pixels=True)
return ds.SOPClassUID.name == 'CT Image Storage'
except (InvalidDicomError, AttributeError, MemoryError):
return False
def test_invalid_character_set_enforce_valid(self):
"""charset: raise on invalid encoding"""
config.enforce_valid_values = True
ds = dcmread(get_testdata_files("CT_small.dcm")[0])
ds.read_encoding = None
ds.SpecificCharacterSet = 'Unsupported'
with pytest.raises(LookupError, match='unknown encoding: Unsupported'):
ds.decode()
def test_trait_names(self):
"""Test Dataset.trait_names contains element keywords"""
test_file = get_testdata_files('CT_small.dcm')[0]
ds = dcmread(test_file, force=True)
names = ds.trait_names()
assert 'PatientName' in names
assert 'save_as' in names
assert 'PixelData' in names
def is_dicom(path):
"""Whether the file is a readable DICOM file via pydicom."""
try:
ds = pydicom.dcmread(path, force=True)
ds.pixel_array
return True
except:
return False
def test_decoding_with_specific_tags(self):
"""Decoding is correctly applied even if Specific Character Set
is not in specific tags..."""
rus_file = get_charset_files("chrRuss.dcm")[0]
ds = dcmread(rus_file, specific_tags=['PatientName'])
ds.decode()
assert 2 == len(ds) # specific character set is always decoded
assert u'Люкceмбypг' == ds.PatientName
def test_latin1(self):
"""charset: can read and decode latin_1 file........................"""
ds = dcmread(latin1_file)
ds.decode()
# Make sure don't get unicode encode error on converting to string
expected = u'Buc^J\xe9r\xf4me'
got = ds.PatientName
self.assertEqual(expected, got,
"Expected %r, got %r" % (expected, got))
def testRead(self):
"""Unicode: Can read a file with unicode characters in name..."""
uni_name = u'test°'
# verify first that we could encode file name in this environment
try:
_ = uni_name.encode(sys.getfilesystemencoding())
except UnicodeEncodeError:
print("SKIP: Environment doesn't support unicode filenames")
return
try:
dcmread(uni_name)
except UnicodeEncodeError:
self.fail("UnicodeEncodeError generated for unicode name")
# ignore file doesn't exist error
except IOError:
pass
def assign2machine(source_file: str, machine_file: str):
"""Assign a DICOM RT Plan file to a specific machine. The source file is overwritten to contain
the machine of the machine file.
Parameters
----------
source_file : str
Path to the DICOM RTPlan file that contains the fields/plan desired
(e.g. a Winston Lutz set of fields or Varian's default PF files).
machine_file : str
Path to a DICOM RTPlan file that has the desired machine. This is easily obtained from pushing a plan from the TPS
for that specific machine. The file must contain at least one valid field.
"""
dcm_source = pydicom.dcmread(source_file)
dcm_machine = pydicom.dcmread(machine_file)
for beam in dcm_source.BeamSequence:
beam.TreatmentMachineName = dcm_machine.BeamSequence[0].TreatmentMachineName
dcm_source.save_as(source_file)
def test_equality_file_meta(self):
"""Dataset: equality returns correct value if with metadata"""
d = dcmread(self.test_file)
e = dcmread(self.test_file)
self.assertTrue(d == e)
e.is_implicit_VR = not e.is_implicit_VR
self.assertFalse(d == e)
e.is_implicit_VR = not e.is_implicit_VR
self.assertTrue(d == e)
e.is_little_endian = not e.is_little_endian
self.assertFalse(d == e)
e.is_little_endian = not e.is_little_endian
self.assertTrue(d == e)
e.filename = 'test_filename.dcm'
self.assertFalse(d == e)
def test_get_item(self):
"""Test Dataset.get_item"""
ds = Dataset()
ds.CommandGroupLength = 120 # 0000,0000
ds.SOPInstanceUID = '1.2.3.4' # 0008,0018
# Test non-deferred read
assert ds.get_item(0x00000000) == ds[0x00000000]
assert ds.get_item(0x00000000).value == 120
assert ds.get_item(0x00080018) == ds[0x00080018]
assert ds.get_item(0x00080018).value == '1.2.3.4'
# Test deferred read
test_file = get_testdata_files('MR_small.dcm')[0]
ds = dcmread(test_file, force=True, defer_size='0.8 kB')
ds_ref = dcmread(test_file, force=True)
# get_item will follow the deferred read branch
assert ds.get_item((0x7fe00010)).value == ds_ref.PixelData
def test_encoding_with_specific_tags(self):
"""Encoding is correctly applied even if Specific Character Set
is not in specific tags..."""
ds = dcmread(jp_file, specific_tags=['PatientName'])
ds.decode()
self.assertEqual(1, len(ds))
expected = ('Yamada^Tarou='
'\033$B;3ED\033(B^\033$BB@O:\033(B='
'\033$B$d$^$@\033(B^\033$B$?$m$&\033(B')
self.assertEqual(expected, ds.PatientName)
def test_inherited_character_set_in_sequence(self):
"""charset: can read and decode SQ with parent encoding............."""
ds = dcmread(get_charset_files('chrSQEncoding1.dcm')[0])
ds.decode()
# These datasets inside of the SQ shall be decoded with the parent
# dataset's encoding
sequence = ds[0x32, 0x1064][0]
assert ['shift_jis', 'iso2022_jp'] == sequence._character_set
assert u'ﾔﾏﾀﾞ^ﾀﾛｳ=山田^太郎=やまだ^たろう' == sequence.PatientName
def test_invalid_character_set(self):
"""charset: replace invalid encoding with default encoding"""
ds = dcmread(get_testdata_files("CT_small.dcm")[0])
ds.read_encoding = None
ds.SpecificCharacterSet = 'Unsupported'
with pytest.warns(UserWarning,
match=u"Unknown encoding 'Unsupported' "
u"- using default encoding instead"):
ds.decode()
assert u'CompressedSamples^CT1' == ds.PatientName
def test_set_convert_private_elem_from_raw(self):
"""Test Dataset.__setitem__ with a raw private element"""
test_file = get_testdata_files('CT_small.dcm')[0]
ds = dcmread(test_file, force=True)
# 'tag VR length value value_tell is_implicit_VR is_little_endian'
elem = RawDataElement((0x0043, 0x1029), 'OB', 2, b'\x00\x01', 0,
True, True)
ds.__setitem__((0x0043, 0x1029), elem)
assert ds[(0x0043, 0x1029)].value == b'\x00\x01'
assert type(ds[(0x0043, 0x1029)]) == DataElement
def openFileOfItem(self, row, column):
item = self.filesTable.item(row, 0)
path = self.directoryComboBox.currentText() + "/" + item.text()
dataset = pydicom.dcmread(path)
all_tags = ''
for elem in dataset:
print(elem)
tag = str(elem) + '\n'
all_tags += tag
self.displayDicomInformation(all_tags)
def retrieve_dicom_file(file: str) -> pydicom.FileDataset:
"""Read and return the DICOM dataset.
Parameters
----------
file : str
The path to the file.
"""
img = pydicom.dcmread(file, force=True)
if 'TransferSyntaxUID' not in img.file_meta:
img.file_meta.TransferSyntaxUID = pydicom.uid.ImplicitVRLittleEndian
return img
def test_encapsulate_single_fragment_per_frame_no_bot(self):
"""Test encapsulating single fragment per frame with no BOT values."""
ds = dcmread(JP2K_10FRAME_NOBOT)
frames = decode_data_sequence(ds.PixelData)
assert len(frames) == 10
data = encapsulate(frames, fragments_per_frame=1, has_bot=False)
test_frames = decode_data_sequence(data)
for a, b in zip(test_frames, frames):
assert a == b
# Original data has no BOT values
assert data == ds.PixelData
def test_nested_character_sets(self):
"""charset: can read and decode SQ with different encodings........."""
ds = dcmread(get_charset_files("chrSQEncoding.dcm")[0])
ds.decode()
# These datasets inside of the SQ cannot be decoded with
# default_encoding OR UTF-8 (the parent dataset's encoding).
# Instead, we make sure that it is decoded using the
# (0008,0005) tag of the dataset
sequence = ds[0x32, 0x1064][0]
assert ['shift_jis', 'iso2022_jp'] == sequence._character_set
assert u'ﾔﾏﾀﾞ^ﾀﾛｳ=山田^太郎=やまだ^たろう' == sequence.PatientName
def import_dicom(file):
ds = pydicom.dcmread(os.getcwd() + "/data/" + file)
file = file.replace(".dcm", "")
#preprocessing.augment.shear_images(dicoms[0],1)
#ds.PixelData = dicoms[0].shears["pixel_array"][0]
#ds.save_as(os.getcwd() + "/data/shear.dcm")
if file in aneurysm_coordinates.keys():
ac = aneurysm_coordinates[file]
else:
ac = []
return Dicom(file, ac , ds.pixel_array)
def _parseFile(f):
try:
# download file and try to parse dicom
with File().open(f) as fp:
dataset = pydicom.dcmread(
fp,
# don't read huge fields, esp. if this isn't even really dicom
defer_size=1024,
# don't read image data, just metadata
stop_before_pixels=True)
return _coerceMetadata(dataset)
except pydicom.errors.InvalidDicomError:
# if this error occurs, probably not a dicom file
return None
def _getImage(mimeType, extension, data):
"""
Check extension of image and opens it.
:param extension: The extension of the image that needs to be opened.
:param data: The image file stream.
"""
if (extension and extension[-1] == 'dcm') or mimeType == 'application/dicom':
# Open the dicom image
dicomData = pydicom.dcmread(six.BytesIO(data))
return scaleDicomLevels(dicomData)
else:
# Open other types of images
return Image.open(six.BytesIO(data))
def test_inherited_character_set_in_sequence(self):
"""charset: can read and decode SQ with parent encoding............."""
ds = dcmread(sq_encoding1_file)
ds.decode()
# These datasets inside of the SQ shall be decoded with the parent
# dataset's encoding
expected = (u'\uff94\uff8f\uff80\uff9e^\uff80\uff9b\uff73='
u'\u5c71\u7530^\u592a\u90ce='
u'\u3084\u307e\u3060^\u305f\u308d\u3046')
sequence = ds[0x32, 0x1064][0]
assert sequence._character_set == [
'shift_jis', 'iso2022_jp', 'iso2022_jp']
assert expected == sequence.PatientName
def setup(self):
"""Setup the test"""
self.ds_8_1_1 = dcmread(OB_RLE_1F)
self.ds_8_3_1 = dcmread(SC_RLE_1F)
self.ds_16_1_1 = dcmread(MR_RLE_1F)
self.ds_16_3_1 = dcmread(SC_RLE_16_1F)
self.ds_32_1_1 = dcmread(RTDOSE_RLE_1F)
self.ds_32_3_1 = dcmread(SC_RLE_32_1F)
self.no_runs = 100
def code_file(filename, exclude_size=None, include_private=False):
"""Write a complete source code file to recreate a DICOM file
:arg filename: complete path and filename of a DICOM file to convert
:arg exclude_size: if specified, values longer than this (in bytes)
will only have a commented string for a value,
causing a syntax error when the code is run,
and thus prompting the user to remove or fix that line.
:arg include_private: If True, private data elements will be coded.
If False, private elements are skipped
:return: a string containing code lines to recreate entire file
"""
lines = []
ds = pydicom.dcmread(filename, force=True)
# Code a nice header for the python file
lines.append("# Coded version of DICOM file '{0}'".format(filename))
lines.append("# Produced by pydicom codify utility script")
# Code the necessary imports
lines.append(code_imports())
lines.append('')
# Code the file_meta information
lines.append("# File meta info data elements")
code_meta = code_dataset(ds.file_meta, "file_meta", exclude_size,
include_private)
lines.append(code_meta)
lines.append('')
# Code the main dataset
lines.append("# Main data elements")
code_ds = code_dataset(
ds, exclude_size=exclude_size, include_private=include_private)
lines.append(code_ds)
lines.append('')
# Add the file meta to the dataset, and set transfer syntax
lines.append("ds.file_meta = file_meta")
lines.append("ds.is_implicit_VR = " + str(ds.is_implicit_VR))
lines.append("ds.is_little_endian = " + str(ds.is_little_endian))
# Return the complete code string
return line_term.join(lines)
import pydicom
import os
filePath = "C:/zhaoyl/Backup/01.DICOM/04.DICOM_Files/07.Multi-ISO-Center/2 iso plan/RP1.2.752.243.1.1.20190128151700217.4000.28177.dcm"
ds = pydicom.dcmread(filePath)
for i, beam in enumerate(ds.IonBeamSequence):
## Change the Machine Name
beam.TreatmentMachineName = "GTR2-PBS"
## Change the Snout ID
for j, snout in enumerate(beam.SnoutSequence):
snout.SnoutID = "snout40"
# Get Save As File Name
folder = os.path.dirname(filePath)
fileName = os.path.basename(filePath)
fileName, ext = os.path.splitext(fileName)
fileName = fileName + "_modified" + ext
saveFileName = os.path.join(folder, fileName)
## Save to DICOM file
ds.save_as(saveFileName)
def __load_full_instance(self):
"""load metadata and image
"""
self.dicomData = pydicom.dcmread(self.path, force=True)
data_dir = '/projectnb/ece601/kaggle-pulmonary-embolism/rsna-str-pulmonary-embolism-detection/'
train_csv = data_dir + 'train.csv'
train_dir = data_dir + 'train/'
pedataframe = pd.read_csv(train_csv)
print(len(pedataframe))
for file_num in range(18):
h5py_file = h5py.File('/scratch/npy-' + str(file_num + 1) + '.hdf5', "w")
for idx in range(file_num * 100000,
min((file_num + 1) * 100000, len(pedataframe))):
img_name = os.path.join(train_dir, pedataframe.StudyInstanceUID[idx],
pedataframe.SeriesInstanceUID[idx],
pedataframe.SOPInstanceUID[idx] + '.dcm')
dicom_image = pydicom.dcmread(img_name)
if idx % 10000 == 0:
print(idx)
try:
# RuntimeError: The following handlers are available to decode the pixel ...
# data however they are missing required dependencies: GDCM (req. GDCM)
image = dicom_image.pixel_array
except:
print('Error parsing ', img_name)
continue
# in OSIC we find outside-scanner-regions with raw-values of -2000.
# Let's threshold between air (0) and this default (-2000) using -1000
image[image <= -1000] = 0
from pydicom import dcmread
from pydicom.data import get_testdata_files
from pynetdicom import AE
from pynetdicom.sop_class import CTImageStorage
ae = AE()
ae.add_requested_context(CTImageStorage)
file_name = get_testdata_files('CT_small')[0]
ds = dcmread(file_name)
assoc = ae.associate('127.0.0.1', 11112)
if assoc.is_established:
status = assoc.send_c_store(ds)
if status:
print('C-STORE request status: 0x{0:04x}'.format(status.Status))
else:
print('Connection timed out, was aborted or received invalid response')
assoc.release()
else:
print('Association rejected, aborted or never connected')
#coding: utf8
import pydicom
filepath = "./dataone/1/I9500000"
filepath = "/tmp/I9500000"
ds = pydicom.dcmread(filepath)
metas = [
"PatientID",
"PatientName",
"PatientBirthDate",
"PatientSex",
"InstitutionName",
]
for meta in metas:
print(ds.data_element(meta))
# Bonus points:
# 1) What is the modality that you are dealing with here?
# 2) Try to figure out which axis corresponds to what plane is which by searching online.
# You should have a good guess of what anatomy you are looking at if you visualize a middle slice
# 3) Try plotting the slices in non-primary planes with proper aspect ratio
#
# Hints:
# - You may want to rescale the output because your voxels are non-square.
# - Don't forget that you need to order your slices properly. Filename
# may not be the best indicator of the slice order.
# If you're confused, try looking up the first value of ImagePositionPatient
# %%
# Load the volume into array of slices
path = f"volume"
slices = [pydicom.dcmread(os.path.join(path, f)) for f in os.listdir(path)]
slices = sorted(slices, key=lambda dcm: dcm.ImagePositionPatient[0])
# What are the dimensions?
print(f"{len(slices)} of size {slices[0].Rows}x{slices[0].Columns}")
# What is the modality?
print(f"Modality: {slices[0].Modality}")
# %%
# What is the slice spacing?
print(
f"Pixel Spacing: {slices[0].PixelSpacing}, slice thickness: {slices[0].SliceThickness}"
)
# Load into numpy array
logging.error(e, exc_info=True)
predictions_list = [] # empty list of predictions
i = 0 # number of successfully processed studies
### Generate predictions ###
for study in studies:
# load study and create prediction
try:
# predictions are at a study level for this particular data element
# for each studyinstanceUID, find all filepaths
filesByStudy = data.loc[data['studyInstanceUID'] ==
study]['filepath'].to_numpy()
prediction = []
for file in filesByStudy:
dcm = pydicom.dcmread('/input/' + file) # load each image file
image = (255 * (dcm.pixel_array.astype(float) /
((2**dcm.BitsStored) - 1))).astype(np.uint8)
# move image data to device
image = torch.from_numpy(image).float().to(device)
# generate a new prediction for each image
prediction.append(torch.rand(num_classes))
# normalize prediction
prediction = sum(prediction) / (sum(sum(prediction)))
prediction = prediction.numpy().astype(np.float64)
# save study prediction in JSON format
predictions_list.append({
def main(args):
train = []
test = []
test_count = {'normal': 0, 'pneumonia': 0, 'COVID-19': 0}
train_count = {'normal': 0, 'pneumonia': 0, 'COVID-19': 0}
# Create export test and train dirs
TEST_EXPORT = os.path.join(args.save_path, 'test')
os.makedirs(TEST_EXPORT, exist_ok=True)
TRAIN_EXPORT = os.path.join(args.save_path, 'train')
os.makedirs(TRAIN_EXPORT, exist_ok=True)
mapping = dict()
mapping['COVID-19'] = 'COVID-19'
mapping['SARS'] = 'pneumonia'
mapping['MERS'] = 'pneumonia'
mapping['Streptococcus'] = 'pneumonia'
mapping['No Finding'] = 'normal'
mapping['Lung Opacity'] = 'pneumonia'
mapping['1'] = 'pneumonia'
covid_imgs = os.path.join(args.covid_dir, "images")
covid_csv = os.path.join(args.covid_dir, "metadata.csv")
csv = pd.read_csv(covid_csv, nrows=None)
csv = csv[csv["view"] == "PA"]
log.info("Metadata contains {} items with PA".format(len(csv)))
pneumonias = ["COVID-19", "SARS", "MERS", "ARDS", "Streptococcus"]
pathologies = [
"Pneumonia", "Viral Pneumonia", "Bacterial Pneumonia", "No Finding"
] + pneumonias
pathologies = sorted(pathologies)
filename_label = {'normal': [], 'pneumonia': [], 'COVID-19': []}
count = {'normal': 0, 'pneumonia': 0, 'COVID-19': 0}
for row in csv.itertuples():
f = row.finding.split('/')[-1]
if f in mapping:
count[mapping[f]] += 1
entry = [row.patientid, row.filename, mapping[f]]
filename_label[mapping[f]].append(entry)
log.info('Data distribution from covid-chestxray-dataset:')
log.info(count)
# add covid-chestxray-dataset into COVIDx dataset
for key in filename_label.keys():
arr = np.array(filename_label[key])
if arr.size == 0:
continue
# Randomly sample test set patients
patient_ids = np.unique(arr[:, 0])
test_size = int(len(patient_ids) * args.test_size)
test_patients = np.random.choice(patient_ids, test_size, replace=False)
log.info('Category: {}, N test patients {}'.format(key, test_size))
# go through all the patients
for patient in arr:
src_img_pth = os.path.join(covid_imgs, patient[1])
if patient[0] in test_patients:
dst_img_pth = os.path.join(TEST_EXPORT, patient[1])
copyfile(src_img_pth, dst_img_pth)
test.append(patient)
test_count[patient[2]] += 1
else:
dst_img_pth = os.path.join(TRAIN_EXPORT, patient[1])
copyfile(src_img_pth, dst_img_pth)
train.append(patient)
train_count[patient[2]] += 1
log.info('test count: {}'.format(test_count))
log.info('train count: {}'.format(train_count))
# add normal and rest of pneumonia cases from
# https://www.kaggle.com/c/rsna-pneumonia-detection-challenge
kaggle_csv_normal = os.path.join(args.kaggle_data,
"stage_2_detailed_class_info.csv")
kaggle_csv_pneu = os.path.join(args.kaggle_data,
"stage_2_train_labels.csv")
csv_normal = pd.read_csv(kaggle_csv_normal, nrows=None)
csv_pneu = pd.read_csv(kaggle_csv_pneu, nrows=None)
patients = {'normal': [], 'pneumonia': []}
for row in csv_normal.itertuples():
if row[2] == 'Normal':
patients['normal'].append(row.patientId)
for row in csv_pneu.itertuples():
if row.Target == 1:
patients['pneumonia'].append(row.patientId)
log.info("Preparing Kaggle dataset...")
counter = 0
for key in patients.keys():
arr = np.array(patients[key])
if arr.size == 0:
continue
# Choose random test patients
patient_ids = np.unique(arr)
test_size = int(len(patient_ids) * args.test_size)
test_patients = np.random.choice(patient_ids, test_size, replace=False)
log.info('Category: {}, N Test examples: {}'.format(key, test_size))
for patient in arr:
ds = dicom.dcmread(
os.path.join(args.kaggle_data, "stage_2_train_images",
patient + '.dcm'))
pixel_array_numpy = ds.pixel_array
imgname = patient + '.png'
pil_img = Image.fromarray(pixel_array_numpy)
if patient in test_patients:
pil_img.save(os.path.join(TEST_EXPORT, imgname))
test.append([patient, imgname, key])
test_count[key] += 1
else:
pil_img.save(os.path.join(TRAIN_EXPORT, imgname))
train.append([patient, imgname, key])
train_count[key] += 1
counter += 1
if counter % 500 == 0 and counter > 0:
log.info("Converted {} Kaggle dataset images".format(counter))
log.info('test count: {}'.format(test_count))
log.info('train count: {}'.format(train_count))
write_metadata(os.path.join(args.save_path, 'train_metadata.txt'), train)
write_metadata(os.path.join(args.save_path, 'test_metadata.txt'), test)
def dicomloaddir(files, filenamepattern='*.dcm', maxtoread=None, phasemode=None,\
desiredinplansize=None, dformat='float'):
'''
dicomloaddir(files, filenamepattern='*.dcm', maxtoread=None, phasemode=None,\
desiredinplansize=None, dformat='float'):
load multiple dicom files in one or multi directories
Input:
<files>: can be:
(1) a string of a directory
(2) a list of (2)
(3) a rzpath object
(4) a list of (3) object
<filenamepattern>: str, the wildcard for the dicom file in a directory
<maxtoread>: int, maximum number of dicom files to read
<phasemodel>: ...implement later, ignore for now...
<desiredinplansize>: ...implement later, ignore for now...,
a 1x2 array, desired inplace size, if dicom files
do not follow this size, we resize it.
<dformat>: ...implement later, ignore for now
read in data format
Output:
<vollist>: a list of volume arrays for multiple runs, if just one run,
we return the array
<dicominfolist>: a list of dicom info dict for multiple runs, if just one run,
we return the dicom info dict
Note:
1. This function currently works with Siemens Prisma 3T and Magnetom 7T, not sure
other scanners like GE. For Siemens, we focus on these attributes (can update this):
(0018, 0050) Slice Thickness
(0028, 0030) Pixel Spacing
(0051, 100b) AcquisitionMatrixText
(0019, 100a) NumberOfImagesInMosaic, 1 if anatomical data
(0018, 0080) Time (TR)
(0018, 0081) Echo Time (TE)
(0018, 1312) Inplane Phase Encoding Direction
(0019, 1029) MosaicRefAcqTimes (slicetimeorder), None if anatomical data
(0051, 1016) a str, check mosaic, read from the dicom file
(0051, 100c) FOV
We also add keys:
'ismosaic': boolean, whether this is a mosaic image
'voxelsize': 1x3 list, based on Slice Thickness and Pixel Spacing
'AcquisitionMatrix': [phase, frequency] matrix, derived from AcquisitionMatrixText. Phase step
has no meaning if data is structure?
'FovSize':[phase_len, frequency_len] mm, derived from FOV
'epireadouttime': calculated from rz.mri.dicom_readout_msec, only valid for epi, None if other files
2. Note that all these keys are scanner specific. Most of these should work for
Siemens scanner but might not work for GE or Phillipe scanner.
Example:
Todo:
1. figure out how to add read phase data
2. check if some of the fields do no exist
3. resize image to accommodate desired inplane size
4. save all metafile using pickel
History:
20180720 <files> now can accept path-like objects
20180626 RZ fixed the bug for reading the anatomical files
20180605 RZ use nibabel.nicom.csareader.get_csa_header() function to read
csa file and get the [BandWidthPerPixelPhaseEncode]
20180422 RZ change the stack images in the last step so user can see
report while waiting for image stack
20180420 RZ created this function
'''
from pydicom import dcmread
from RZutilpy.rzio import matchfiles
from RZutilpy.array import split2d
from RZutilpy.mri import dicom_readout_msec
from RZutilpy.system import rzpath
from numpy import stack
from progressbar import progressbar as pbar
import re
import time
# deal with input
files = [files] if not isinstance(files, list) else files
# convert it to path-like object
files = [rzpath(p) if not isinstance(p, rzpath) else p for p in files]
# start to load
dicominfolist = []
vollist = []
for iDir, filedir in enumerate(files): # loop directory
filepattern = filedir / filenamepattern
dcmnames = matchfiles(filepattern.str)
if len(dcmnames) == 0:
print(
'This {} does not appear to be a directory containing {} files, so skipping.\n'
.format(filedir, filenamepattern))
break
else:
print(
'This {} appear to be a directory containing {} files, so loading.\n'
.format(filedir, filenamepattern))
dcmnames = dcmnames[:maxtoread] # remove last couple of dcm files
# ====== deal with dicom info, save a customized dicominfo dict =======
ds = dcmread(dcmnames[0].str) # read 1st vol for info purpose
# note current we assume this dicom have all fields below!! And we save
# the very raw dicom info here
dcminfothisrun = dict()
dcminfothisrun['SliceThickness'] = ds.SliceThickness
dcminfothisrun['PixelSpacing'] = ds.PixelSpacing
dcminfothisrun['AcquisitionMatrixText'] = ds.AcquisitionMatrixText
dcminfothisrun['RepetitionTime'] = ds.RepetitionTime
dcminfothisrun['EchoTime'] = ds.EchoTime
dcminfothisrun[
'InPlanePhaseEncodingDirection'] = ds.InPlanePhaseEncodingDirection
dcminfothisrun['FOV'] = ds[int('0051', 16), int('100c', 16)].value
dcminfothisrun['checkmosaic'] = ds[int('0051', 16),
int('1016', 16)].value
# figure out whether it is mosaic image
if dcminfothisrun['checkmosaic'].find('MOSAIC') >= 0:
dcminfothisrun['ismosaic'] = True # indicate this is a epi file
print(
'We are loading some mosaic images, need to convert a mosaic image to 3d,\
this directory might contain epi data ...\n')
else:
dcminfothisrun[
'ismosaic'] = False # indicate this is not a epi file
if [int('0019', 16), int('100a', 16)] in ds: # simense
dcminfothisrun['NumberOfImagesInMosaic'] = ds[
int('0019', 16),
int('100a', 16)].value if dcminfothisrun['ismosaic'] else 1
elif [int('0021', 16), int('104f', 16)] in ds: # GE
dcminfothisrun['NumberOfImagesInMosaic'] = ds[
int('0021', 16),
int('104f', 16)].value if dcminfothisrun['ismosaic'] else 1
dcminfothisrun['MosaicRefAcqTimes'] = ds[
int('0019', 16),
int('1029', 16)].value if dcminfothisrun['ismosaic'] else None
dcminfothisrun['epireadouttime'] = dicom_readout_msec(
ds)[0] if dcminfothisrun['ismosaic'] else None
# save voxel size
dcminfothisrun['voxelsize'] = list(dcminfothisrun['PixelSpacing']) + [
dcminfothisrun['SliceThickness']
]
# figure out inplane matrix, not that we assume
# note this regular expression might fail in normal resolution imaging
p = re.compile(r'^(\d{1,4}).?\*(\d{1,4}).?$')
matchgroup = p.match(dcminfothisrun['AcquisitionMatrixText'])
if matchgroup:
plines = int(
matchgroup.group(1)) # step in phase encoding direction
flines = int(
matchgroup.group(2)) # step in frequency encoding direction
dcminfothisrun['AcquisitionMatrix'] = [plines, flines]
else:
ValueError('can not find the phase encoding direction!')
# figure out inplane matrix, not that we assume
p = re.compile(r'^FoV (\d{1,6})\*(\d{1,6})$')
matchgroup = p.match(dcminfothisrun['FOV'])
p_len = int(matchgroup.group(1)) # step in phase encoding direction
f_len = int(
matchgroup.group(2)) # step in frequency encoding direction
dcminfothisrun['FovSize'] = [
p_len / 10, f_len / 10
] if dcminfothisrun['ismosaic'] else [p_len, f_len]
# have to divide this number by 10 for epidata, not sure why....
# save dicom info in this run
dicominfolist.append(dcminfothisrun)
# show some information
print(dcminfothisrun)
# ================ deal with the volumes ====================
print('\nReading in dicoms ......')
vol = [dcmread(i.str).pixel_array
for i in pbar(dcmnames)] # read pixel data
# split mosaic images
if dcminfothisrun['ismosaic']:
# Note that we assume plines and flines will be exact divided by the image
# this is typically true
vol = [split2d(i, plines, flines)
for i in vol] # split each 2d mosaic image to 3d image
# only keep acquired slices, the last several images are sometimes black
vol = [
i[:, :, :dcminfothisrun['NumberOfImagesInMosaic']] for i in vol
]
# stack images, take a while
print('\n\nStack images ......\n')
vol = stack(vol, axis=-1) # stack to a 3d/4d file
if vol.ndim == 3: # expand to 4d if only 3d
vol = vol[..., None]
vollist.append(vol)
# report info
print(
'The 3D dimensions of the final returned volume are {}.\n'.format(
vol.shape[:3]))
print('There are {} volumes in the fourth dimension.\n'.format(
vol.shape[-1]))
if dcminfothisrun['ismosaic']:
print('These are mosaic images, might be epi data.\n')
else:
print('These are not mosaic images, might not be epi data.\n')
print('The voxel size (mm) of the final returned volume is {}.\n'.format\
(dcminfothisrun['voxelsize']))
print('The in-plane matrix size (PE x FE) appears to be {}.\n'.format\
(dcminfothisrun['AcquisitionMatrix']))
print('The field-of-view (mm) of the final returned volume is {}.\n'.format\
(dcminfothisrun['FovSize']))
print('The TR is {} ms.\n\n\n\n'.format(
dcminfothisrun['RepetitionTime']))
if len(vollist) == 1:
vollist = vollist[0]
if len(dicominfolist) == 1:
dicominfolist = dicominfolist[0]
return vollist, dicominfolist
if test == "Cart":
col1, col2 = st.beta_columns(2)
default_displacement_forward = col1.text_input(
"Selected displacement forward", "", key="1")
measured_displacement_forward = col2.text_input(
"Measured displacement forward", "", key="2")
default_displacement_backward = col1.text_input(
"Selected displacement backward", "", key="3")
measured_displacement_backward = col2.text_input(
"Measured displacement backward", "", key="4")
if file is not None:
if len(file) > 0:
im_list = [pydicom.dcmread(i) for i in file]
if len(im_list) > 1:
slider = st.slider("Image:", min_value=1, max_value=len(im_list))
# test_img=pydicom.dcmread(file[0])
images = [get_data(x)[0] for x in im_list]
fig, ax = plt.subplots()
ax.imshow(images[slider - 1], cmap="gray")
st.write(fig)
else:
#test_img=pydicom.dcmread(file[0])
img, px_dim = get_data(im_list[0])
# dst=np.zeros(img.shape)
# cv_img=cv2.normalize(img,dst,0,255,cv2.NORM_MINMAX)
with xnatutils.connect() as xlogin:
xsession = xlogin.experiments[args.xnat_id] # noqa pylint:disable=no-member
for scan_id in args.scan_ids:
xscan = xsession.scans[scan_id]
xscan.download_dir(args.download_dir)
files_path = op.join(
args.download_dir, args.xnat_id,
'scans', '{}-{}'.format(xscan.id,
re.sub(r'[^a-zA-Z_0-9]', '_', xscan.type)),
'resources', 'DICOM', 'files')
for fname, xfile in sorted(xscan.files.items(), key=itemgetter(0)):
fpath = op.join(files_path, fname)
with open(fpath, 'rb') as f:
dcm = pydicom.dcmread(fpath)
if dcm.file_meta.MediaStorageSOPClassUID == ENHANCED_MR_STORAGE:
print("Deleting '{}".format(fname))
if not args.dry_run:
xfile.delete()
if args.dry_run:
print('Would delete proceeding "Enhanced MR Image Storage" from {}:[{}]'.
format(args.xnat_id, ', '.join(args.scan_ids)))
else:
print('Deleted all "Enhanced MR Image Storage" from {}:[{}]'.format(
args.xnat_id, ', '.join(args.scan_ids)))
def load_image(full_path):
f = pydicom.dcmread(full_path)
return f.pixel_array.astype(np.int)
os.makedirs(new_dir_CT)
#Change directory to the original CT data
os.chdir(original_dir_CT)
#Get the list of file names in the original data directory.
orig_filelist = os.listdir(original_dir_CT)
#Start iterating through the file list in the original DICOM dataset.
for num, file in enumerate(orig_filelist):
#Check to make sure that the file being interrogated is an actual DICOM file in the folder.
if file.endswith('.dcm'):
#Read the first DICOM file in the original data directory.
ds = pydicom.dcmread(file)
#Check if the SOPClassUID tag says that the images are
#from a CT dataset. Since we are only looking for CT images
#with this command, it will also ignore all secondary captures
#and snapshots, so that these won't be part of the de-identified dataset.
#These secondary captures can also contain sensitive, identifying patient
#information.
if ds[0x0008,0x0016].repval == 'CT Image Storage':
#Begin the deidentification of all relevant tags.
ds.PatientName = 'CT_Patient'
ds.AccessionNumber = ' '
ds.Manufacturer = ' '
ds.InstitutionName = ' '
ds.InstitutionAddress = ' '
def slotAdd3(self, a, b):
filenames = os.listdir(path)
self.slices_liver = []
self.slices_tumor = []
idx = []
for i, name in enumerate(filenames):
name = os.path.join(path, name)
slice = pydicom.dcmread(name)
idx.append(slice.InstanceNumber)
self.slices_liver.append(WL(slice, 0, 2048))
self.slices_tumor.append(WL(slice, 100, 150))
idx_new = np.argsort(idx)
self.slices_liver = np.stack(self.slices_liver)[idx_new]
self.slices_tumor = np.stack(self.slices_tumor)[idx_new]
self.liver = np.fromstring(a)
self.liver = np.reshape(self.liver, (len(filenames), 512, 512))
self.liver_backup = self.liver
self.liver *= 255.
self.tumor = np.fromstring(b)
self.tumor = np.reshape(self.tumor, (len(filenames), 512, 512))
self.tumor_backup = self.tumor
self.tumor *= 255.
global sum_number
sum_number = filenames
half_sample_num = sample_num/2
self.num.setText(str(int(half_sample_num)))
num_pic = self.num.text()
num2 = int(num_pic)
self.show_img(self.tumor[num2])
a = self.liver[num2]#liver
b = self.slices_tumor[num2]
c = self.tumor[num2]
overlay = b
overlay = np.uint8(overlay)
overlay = cv.cvtColor(overlay, cv.COLOR_GRAY2RGB)
mask = np.uint8(c)
_, binary_pred = cv.threshold(mask, 127, 255, cv.THRESH_BINARY)
contours_pred, _ = cv.findContours(binary_pred, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
cv.drawContours(overlay, contours_pred, -1, (255, 20, 147), 2) # pink contours stand for prediction
mask_2 = np.uint8(a)
_, binary_pred = cv.threshold(mask_2, 127, 255, cv.THRESH_BINARY)
contours_pred, _ = cv.findContours(binary_pred, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
cv.drawContours(overlay, contours_pred, -1, (0, 255, 0), 2) # pink contours stand for prediction
self.show_img(overlay)
if flag == 1:
self.liver_layer.setEnabled(True)
self.liver_layer.setChecked(True)
elif flag == 3 or flag == 2:
self.liver_layer.setEnabled(True)
self.tumor_layer.setEnabled(True)
self.liver_layer.setChecked(True)
self.tumor_layer.setChecked(True)
self.tri_d_run.setEnabled(True)
self.left.setEnabled(True)
self.right_R.setEnabled(True)
self.show_1.setEnabled(True)
def read_dicom(folder):
"""read_dicom reads MRI dicom files from Siemens, GE, or Philips scanners.
Return values:
raw_data: complex-valued, H x W x D x E
voxel_size: resolution of scan in mm/voxel (ex: .4688 .4688 2.0000)
CF: center frequency in Hz (ex: 127782747)
delta_TE: difference between echoes in ms (ex: 3.6)
TE: times in ms of echoes (ex: 4.5 8.1 ...)
B0_dir: direction of B0 (ex: 0 0 1)
B0: strength of B0 in Tesla (ex: 3)
Sample usage:
>>> file_path = '.../test_data_GE'
>>> raw_data, params = read_DICOM_HW(file_path)
Steven Cao, Hongjiang Wei, Chunlei Liu
University of California, Berkeley
"""
files = [join(folder, f) for f in listdir(folder) if is_dcm(f)]
assert len(files) > 0, 'No dicom files in {0}'.format(folder)
info = dcmread(files[0])
maker = info.Manufacturer
print('Reading', len(files), maker, 'dicom files...')
# Find min and max slice location, number of echoes
min_slice = np.float(info.SliceLocation)
max_slice = np.float(info.SliceLocation)
min_pos = np.array(info.ImagePositionPatient)
max_pos = np.array(info.ImagePositionPatient)
max_echo = int(info.EchoNumbers)
for f in files[1:]:
file = dcmread(f)
slice_loc = np.float(file.SliceLocation)
echo = int(file.EchoNumbers)
if slice_loc < min_slice:
min_slice = slice_loc
min_pos = np.array(file.ImagePositionPatient)
if slice_loc > max_slice:
max_slice = slice_loc
max_pos = np.array(file.ImagePositionPatient)
if echo > max_echo:
max_echo = echo
voxel_size = np.array(
[info.PixelSpacing[0], info.PixelSpacing[1], info.SliceThickness])
slices = np.round(norm(max_pos - min_pos) / voxel_size[2]) + 1
# Fill mag, phase, and TE arrays
shape = (int(info.Rows), int(info.Columns), int(slices), int(max_echo))
mag = np.zeros(shape)
phase = np.zeros(shape)
TE = np.zeros(max_echo)
for f in files:
file = dcmread(f)
slice_num = int(
np.round((norm(np.array(file.ImagePositionPatient) - min_pos) /
voxel_size[2])))
echo = int(file.EchoNumbers) - 1
TE[echo] = float(file.EchoTime)
if maker.startswith('GE'):
if int(file.InstanceNumber) % 2 == 1:
mag[:, :, slice_num, echo] = file.pixel_array
else:
phase[:, :, slice_num, echo] = file.pixel_array
elif maker.startswith('Ph'):
if 'm' in file.ImageType or 'M' in file.ImageType:
mag[:, :, slice_num, echo] = file.pixel_array
elif 'p' in file.ImageType or 'P' in file.ImageType:
phase[:, :, slice_num, echo] = file.pixel_array
elif maker.startswith('SIE'): # does not work with multiple coils
if 'm' in file.ImageType or 'M' in file.ImageType:
mag[:, :, slice_num, echo] = file.pixel_array
elif 'p' in file.ImageType or 'P' in file.ImageType:
phase[:, :, slice_num, echo] = (
(file.pixel_array * np.float(file.RescaleSlope) +
np.float(file.RescaleIntercept)) /
(np.float(file.LargestImagePixelValue) * np.pi))
if maker.startswith('GE') or maker.startswith('Ph'):
phase = 2 * np.pi * phase / (np.max(phase) - np.min(phase))
if maker.startswith('GE'):
phase[:, :, ::2, :] = phase[:, :, ::2, :] + np.pi
data = mag * np.exp(-1j * phase)
# Acq params
CF = info.ImagingFrequency * 1e6
if len(TE) == 1:
delta_TE = TE
else:
delta_TE = TE[1] - TE[0]
affine_2d = np.array(info.ImageOrientationPatient).reshape(3, 2)
z = (max_pos - min_pos) / ((slices - 1) * voxel_size[2] - 1)
z = np.array([z]).T
affine_3d = np.concatenate((affine_2d, z), axis=1)
B0_dir = np.linalg.lstsq(affine_3d, [0, 0, 1])[0]
B0 = int(info.MagneticFieldStrength)
params = {
'voxel_size': voxel_size,
'CF': CF,
'delta_TE': delta_TE,
'TE': TE,
'B0_dir': B0_dir,
'B0': B0
}
return data, params
def addMetadata(frame, filepath):
dicom_file = dicom.dcmread(filepath)
frame['filepath'] = filepath
metadata_attributes_names = ['PatientID', 'StudyInstanceUID', 'SeriesInstanceUID', 'ImagePositionPatient', 'ImageOrientationPatient']
for name in metadata_attributes_names:
frame[name] = dicom_file[name].value
]
list_series = sorted(list_series, key=int)
list_series = ['{}/{}'.format(folder, i) for i in list_series]
except:
call(['rmdir', os.path.join(patient_folder, 'Neeb')])
log.info("8. Non-integer named series... Deleting Neeb folder.")
sys.exit(1)
if (list_series):
for series in list_series:
#print(series)
list_dicoms = sorted(glob.glob(series + '/*[dD][cC][mM]*'))
#print(os.listdir(os.path.join(folder, series)))
if "gz" in list_dicoms[0]:
call(['gunzip', list_dicoms[0]])
list_dicoms[0] = list_dicoms[0][:-3]
ds = pydicom.dcmread(list_dicoms[0])
if ("epi_bh90" in ds.SeriesDescription):
log.info("9. " + str(ds.SeriesDescription))
# call(['cp', '-r', series, os.path.join(patient_folder,'Neeb/epi_highflip')])
#pdb.set_trace()
copytree(series,
os.path.join(patient_folder, 'Neeb/epi_highflip'))
if ("epi_bh30" in ds.SeriesDescription):
log.info("10. " + str(ds.SeriesDescription))
call([
'cp', '-r', series,
os.path.join(patient_folder, 'Neeb/epi_lowflip')
])
if ("epi_bb90" in ds.SeriesDescription):
log.info("11. " + str(ds.SeriesDescription))
call([
import pydicom
from itertools import cycle
from pyTG43 import *
from bokeh.plotting import figure, show, output_file
from bokeh.palettes import Category20
from bokeh.models import CrosshairTool, HoverTool, Legend
rp = pydicom.dcmread('examples/PDR/RP.PDR.dcm')
rs = pydicom.dcmread('examples/PDR/RS.PDR.dcm')
rd = pydicom.dcmread('examples/PDR/RD.PDR.dcm')
source = Source(rp, 'examples/PDR/')
plan = Plan(source, rp, rs, rd)
for roi in plan.ROIs:
if roi.name in ['ctv','bladder','rectum']:
roi.get_DVH_pts()
roi.get_TPS_DVH(rp,rs,rd)
calcDVHs(source,plan,plan.rx*10,['ctv','bladder','rectum'])
cmap = Category20[20]
itr = cycle(cmap)
output_file("dvh.html")
p = figure(plot_width=900, plot_height=560, x_range=(0,plan.rx*10), y_range=(0,101), active_scroll='wheel_zoom', toolbar_location='above')
p.xaxis.axis_label = 'Dose (Gy)'
p.yaxis.axis_label = 'Relative Volume (%)'
items = []
})
slice_size = {}
# COVID-19
all_paths = sorted(
[x for x in os.listdir(dataset_path_covid) if not x.startswith('.')])
for patient_number, path in enumerate(all_paths):
subpath = sorted([
x for x in os.listdir(dataset_path_covid + path)
if not x.startswith('.')
])
slice_numbers = len(subpath) #number of slices
dataset = pydicom.dcmread(
os.path.join(dataset_path_covid + path,
subpath[0])) #read a sample image
#information
patient_csv_data = {}
patient_csv_data['Diagnosis'] = 'COVID-19'
patient_csv_data['Patient Sex'] = [dataset.PatientSex]
patient_csv_data['Patient Age'] = [dataset.PatientAge]
patient_csv_data['Slice Thickness'] = [dataset.SliceThickness]
patient_csv_data['Slices'] = [slice_numbers]
patient_csv_data['Study Date'] = [dataset.StudyDate]
patient_csv_data['XRayTubeCurrent'] = [dataset.XRayTubeCurrent]
patient_csv_data['KVP'] = [dataset.KVP]
patient_csv_data['Exposure Time'] = [dataset.ExposureTime]
patient_csv_data['Study Date'] = [dataset.StudyDate]
patient_csv_data['Date of Last Calibration'] = [
import matplotlib.pyplot as plt
import pydicom
from pydicom.data import get_testdata_files
# Il faut changer le chemin de l'image selon le path ou elle se trouve
base = "/home/zoheir/Documents/Imageire médicale/Projet/AAA/DICOM/S00001/SER00001/"
pass_dicom = "I00002"
filename = pydicom.data.data_manager.get_files(base, pass_dicom)[0]
dataset = pydicom.dcmread(filename)
# Mode normal:
print()
print("Nom de Fichier.........:", filename)
print("Type de sauvegarde.....:", dataset.SOPClassUID)
print()
pat_name = dataset.PatientName
display_name = pat_name.family_name + ", " + pat_name.given_name
print("Nom du Patient...:", display_name)
print("Id du Patient.......:", dataset.PatientID)
print("Modalité.........:", dataset.Modality)
print("Date de passage.......:", dataset.StudyDate)
if 'PixelData' in dataset:
rows = int(dataset.Rows)
cols = int(dataset.Columns)
print("Image size.......: {rows:d} x {cols:d}, {size:d} bytes".format(
rows=rows, cols=cols, size=len(dataset.PixelData)))
if 'PixelSpacing' in dataset:
dicom = pydicom.dcmread(DicomBytesIO(data))
image = dicom.pixel_array
rescale_slope, rescale_intercept = int(dicom.RescaleSlope), int(dicom.RescaleIntercept)
image = rescale_image(image, rescale_slope, rescale_intercept)
image = apply_window_policy(image)
image -= image.min((0,1))
image = (255*image).astype(np.uint8)
Image.fromarray(image)
cv2.imwrite(os.path.join(path_proc, imgnm)+'.jpg', image)
except:
print(name)
path_img = '/Users/dhanley2/Documents/Personal/rsna/data/CQ500'
zipms = glob.glob(path_img+'/*zip')
namesls = []
import zipfile
from pydicom.filebase import DicomBytesIO
for zipf in zipms:
with zipfile.ZipFile(zipf, "r") as f:
for t, name in enumerate(tqdm(f.namelist())):
namesls.append(name)
data = f.read(name)
dicom = pydicom.dcmread(DicomBytesIO(data))
break
imgnm = (name.split('/')[-1]).replace('.dcm', '')
dicom = pydicom.dcmread(DicomBytesIO(data))
convert_dicom_to_jpg(name)
def load_dcm(filename):
return pydicom.dcmread(f'data/{filename}')
This example requires the Numpy library to manipulate the pixel data.
"""
# authors : Guillaume Lemaitre <*****@*****.**>
# license : MIT
import pydicom
from pydicom.data import get_testdata_files
print(__doc__)
# FIXME: add a full-sized MR image in the testing data
filename = get_testdata_files('MR_small.dcm')[0]
ds = pydicom.dcmread(filename)
# get the pixel information into a numpy array
data = ds.pixel_array
print('The image has {} x {} voxels'.format(data.shape[0], data.shape[1]))
data_downsampling = data[::8, ::8]
print('The downsampled image has {} x {} voxels'.format(
data_downsampling.shape[0], data_downsampling.shape[1]))
# copy the data back to the original data set
ds.PixelData = data_downsampling.tobytes()
# update the information regarding the shape of the data array
ds.Rows, ds.Columns = data_downsampling.shape
# print the image information given in the dataset
print('The information of the data set after downsampling: \n')
def predict(self, data):
"""
See https://github.com/mdai/model-deploy/blob/master/mdai/server.py for details on the
schema of `data` and the required schema of the outputs returned by this function.
"""
input_files = data["files"]
input_annotations = data["annotations"]
input_args = data["args"]
outputs = []
for file in input_files:
if file["content_type"] != "application/dicom":
continue
ds = pydicom.dcmread(BytesIO(file["content"]))
image = ds.pixel_array
x = preprocess_image(image)
y_prob = self.model.predict(x)
y_classes = y_prob.argmax(axis=-1)
class_index = y_classes[0]
probability = y_prob[0][class_index]
gradcam = GradCAM()
gradcam_output = gradcam.explain(
validation_data=(x, None),
model=self.model,
layer_name="conv_pw_13_relu",
class_index=class_index,
colormap=cv2.COLORMAP_TURBO,
)
gradcam_output_buffer = BytesIO()
Image.fromarray(gradcam_output).save(gradcam_output_buffer, format="PNG")
smoothgrad = SmoothGrad()
smoothgrad_output = smoothgrad.explain(
validation_data=(x, None), model=self.model, class_index=class_index
)
smoothgrad_output_buffer = BytesIO()
Image.fromarray(smoothgrad_output).save(smoothgrad_output_buffer, format="PNG")
output = {
"type": "ANNOTATION",
"study_uid": str(ds.StudyInstanceUID),
"series_uid": str(ds.SeriesInstanceUID),
"instance_uid": str(ds.SOPInstanceUID),
"class_index": int(class_index),
"probability": float(probability),
"explanations": [
{
"name": "Grad-CAM",
"description": "Visualize how parts of the image affects neural network’s output by looking into the activation maps. From _Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization_ (https://arxiv.org/abs/1610.02391)",
"content": gradcam_output_buffer.getvalue(),
"content_type": "image/png",
},
{
"name": "SmoothGrad",
"description": "Visualize stabilized gradients on the inputs towards the decision. From _SmoothGrad: removing noise by adding noise_ (https://arxiv.org/abs/1706.03825)",
"content": smoothgrad_output_buffer.getvalue(),
"content_type": "image/png",
},
],
}
outputs.append(output)
return outputs
r'C:\Users\Julia Scott\Desktop\Varian 2020_2021\Prashul\Excel\OralCavityImages.xlsx',
'rb'),
sheet_name='Sheet1')
dict = defaultdict(list)
for i in df.index:
try:
startSlice = int(df['Start Slice'][i])
endSlice = int(df['End Slice'][i])
fileLocation = df['File Location'][i]
print(str(startSlice) + "," + str(endSlice) + " " + fileLocation)
dict[fileLocation].append(startSlice)
dict[fileLocation].append(endSlice)
except ValueError:
continue
for folderPath in dict:
startSlice = dict[folderPath][0]
endSlice = dict[folderPath][1]
sliceNo = startSlice
while sliceNo <= endSlice:
fileName = "1-" + str(sliceNo).zfill(3) + ".dcm"
jpegFileName = "1-" + str(sliceNo).zfill(3) + ".jpeg"
jpgFileName = "1-" + str(sliceNo).zfill(3) + ".jpg"
ds = dicom.dcmread(os.path.join(folderPath, fileName), force=True)
pixel_array_numpy = ds.pixel_array
cv2.imwrite(os.path.join(folderPath, jpgFileName), pixel_array_numpy)
os.remove(os.path.join(folderPath, jpegFileName))
sliceNo = sliceNo + 1
# import pdb
logger = logging.getLogger(__name__)
logger.setLevel(level=logging.INFO)
handler = logging.FileHandler("storage_scu_log.txt")
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s\
- %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
logger.addHandler(console)
ds = dcmread('/Volumes/Transcend/mediclouds/PACS/MRI.dcm')
# ds = dcmread('/Volumes/Transcend/mediclouds/PACS/IMG00001')
ae = AE(ae_title=b'ilab_scu')
ae.requested_contexts = StoragePresentationContexts
# ae.add_requested_context(VerificationPresentationContexts)
# ae.add_requested_context(VerificationSOPClass)
# for cx in ae.requested_contexts:
# print(cx)
assoc = ae.associate('192.168.3.5', 4100, ae_title=b'lkjds')
if assoc.is_established:
logger.info('assoc is established')
dataset = dcmread('./MRI.dcm')
def __load_metadata(self):
"""load only metadata
"""
self.dicomData = pydicom.dcmread(self.path,
stop_before_pixels=True,
force=True)
def test_standard_file(self):
"""charset: can read and decode standard file without special char.."""
ds = dcmread(get_testdata_file("CT_small.dcm"))
ds.decode()
assert 'CompressedSamples^CT1' == ds.PatientName
def loadDicom(fullpath: str):
return pydicom.dcmread(fullpath)
def run(self):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
if torch.cuda.is_available():
gpu_flag = '(on GPU)'
else:
gpu_flag = '(on CPU)'
t_start = time.time()
global t_elapsed
if flag == 1:
print('flag = 1')
filenames = os.listdir(path)
results_liver = np.zeros([len(filenames), 512, 512])
results_tumor = np.zeros([len(filenames), 512, 512])
slices_liver = []
slices_tumor = []
idx = []
for i, name in enumerate(filenames):
name = os.path.join(path, name)
slice = pydicom.dcmread(name)
idx.append(int(slice.InstanceNumber))
slices_liver.append(WL(slice, 0, 2048))
slices_tumor.append(WL(slice, 100, 150))
idx_new = np.argsort(idx)
slices_liver = np.stack(slices_liver)
slices_tumor = np.stack(slices_tumor)
slices_liver = slices_liver[idx_new]
slices_tumor = slices_tumor[idx_new]
slices_liver_tensor = torch.tensor(slices_liver)
slices_liver_tensor = slices_liver_tensor.unsqueeze(1).float() / 255.
slices_tumor_tensor = torch.tensor(slices_tumor)
slices_tumor_tensor = slices_tumor_tensor.unsqueeze(1).float() / 255.
model_path = 'liver_7WL.pth'
model = torch.load(model_path, map_location=device)
model = model.to(device)
model = model.eval()
sm = nn.Softmax(dim=1)
for i in range(slices_liver_tensor.shape[0]):
self.sinOut.emit("标记肝脏: " , str(i+1)+"/" +
str(slices_liver_tensor.shape[0]) + gpu_flag)
output = model(slices_liver_tensor[i, :].unsqueeze(0).to(device))
output_sm = sm(output)
_, result = torch.max(output_sm, dim=1)
results_liver[i] = result[0, :].cpu().detach().numpy()
print(results_liver.shape)
a = results_liver.tostring()
b = results_tumor.tostring()
t_end = time.time()
global t_elapsed
t_elapsed = t_end - t_start
t_elapsed = t_end - t_start
#print(str(round(t_elapsed, 4)))
self.sinOut4.emit("耗时: " , str(round(t_elapsed, 4)))
#self.sinOut.emit("耗时: " , 's')
self.sinOut3.emit(a, b)
elif flag == 3 or flag == 2:
filenames = os.listdir(path)
results_liver = np.zeros([len(filenames), 512, 512])
results_tumor = np.zeros([len(filenames), 512, 512])
slices_liver = []
slices_tumor = []
idx = []
for i, name in enumerate(filenames):
name = os.path.join(path, name)
slice = pydicom.dcmread(name)
idx.append(int(slice.InstanceNumber))
slices_liver.append(WL(slice, 0, 2048))
slices_tumor.append(WL(slice, 100, 150))
idx_new = np.argsort(idx)
slices_liver = np.stack(slices_liver)
slices_tumor = np.stack(slices_tumor)
slices_liver = slices_liver[idx_new]
slices_tumor = slices_tumor[idx_new]
slices_liver_tensor = torch.tensor(slices_liver)
slices_liver_tensor = slices_liver_tensor.unsqueeze(1).float() / 255.
slices_tumor_tensor = torch.tensor(slices_tumor)
slices_tumor_tensor = slices_tumor_tensor.unsqueeze(1).float() / 255.
model_path = 'liver_7WL.pth'
model = torch.load(model_path, map_location=device)
model = model.to(device)
model = model.eval()
sm = nn.Softmax(dim=1)
for i in range(slices_liver_tensor.shape[0]):
self.sinOut.emit("标记肝脏: " , str(i+1)+"/" +
str(slices_liver_tensor.shape[0]) + gpu_flag)
output = model(slices_liver_tensor[i, :].unsqueeze(0).to(device))
output_sm = sm(output)
_, result = torch.max(output_sm, dim=1)
results_liver[i] = result[0, :].cpu().detach().numpy()
a = results_liver.tostring()
del(model)
del(output)
del(output_sm)
del(result)
model_path_2 = './best_tumor.pth'
model_2 = torch.load(model_path_2, map_location=device)
model_2 = model_2.to(device)
model_2 = model_2.eval()
sm = nn.Softmax(dim=1)
for i in range(slices_tumor_tensor.shape[0]):
self.sinOut.emit("标记肿瘤: " , str(i+1)+"/" +
str(slices_tumor_tensor.shape[0]) + gpu_flag)
output_2 = model_2(slices_tumor_tensor[i, :].unsqueeze(0).to(device))
output_sm_2 = sm(output_2)
_, result_2 = torch.max(output_sm_2, dim=1)
results_tumor[i] = result_2[0, :].cpu().detach().numpy()
b = results_tumor.tostring()
t_end = time.time()
t_elapsed = t_end - t_start
self.sinOut4.emit("耗时: " , str(round(t_elapsed, 4)))
self.sinOut3.emit(a, b)
