def setUp(self):
self.jpeg_ls_lossless = dcmread(jpeg_ls_lossless_name)
self.mr_small = dcmread(mr_name)
self.emri_jpeg_ls_lossless = dcmread(emri_jpeg_ls_lossless)
self.emri_small = dcmread(emri_name)
self.original_handlers = pydicom.config.pixel_data_handlers
pydicom.config.pixel_data_handlers = [numpy_handler]
def test_big_endian_datasets(self, little, big):
"""Test pixel_array for big endian matches little."""
ds = dcmread(big)
assert ds.file_meta.TransferSyntaxUID == ExplicitVRBigEndian
ref = dcmread(little)
assert ref.file_meta.TransferSyntaxUID != ExplicitVRBigEndian
assert np.array_equal(ds.pixel_array, ref.pixel_array)
def setUp(self):
self.jpeg_ls_lossless = dcmread(jpeg_ls_lossless_name)
self.mr_small = dcmread(mr_name)
self.emri_jpeg_ls_lossless = dcmread(emri_jpeg_ls_lossless)
self.emri_small = dcmread(emri_name)
self.original_handlers = pydicom.config.image_handlers
pydicom.config.image_handlers = [None]
def setUp(self):
self.jpeg_2k = dcmread(jpeg2000_name)
self.jpeg_2k_lossless = dcmread(jpeg2000_lossless_name)
self.mr_small = dcmread(mr_name)
self.emri_jpeg_2k_lossless = dcmread(emri_jpeg_2k_lossless)
self.emri_small = dcmread(emri_name)
self.original_handlers = pydicom.config.image_handlers
pydicom.config.image_handlers = [numpy_handler]
def testPlanarConfig(self):
px_data_ds = dcmread(color_px_name)
pl_data_ds = dcmread(color_pl_name)
assert px_data_ds.PlanarConfiguration != pl_data_ds.PlanarConfiguration
if have_numpy:
px_data = px_data_ds.pixel_array
pl_data = pl_data_ds.pixel_array
self.assertTrue(numpy.all(px_data == pl_data))
def testValuesIdentical(self):
"""Deferred values exactly matches normal read..............."""
ds_norm = dcmread(self.testfile_name)
ds_defer = dcmread(self.testfile_name, defer_size=2000)
for data_elem in ds_norm:
tag = data_elem.tag
self.assertEqual(data_elem.value, ds_defer[tag].value,
"Mismatched value for tag %r" % tag)
def setup(self):
"""Setup the test datasets."""
self.jpeg_2k = dcmread(jpeg2000_name)
self.jpeg_2k_lossless = dcmread(jpeg2000_lossless_name)
self.emri_jpeg_2k_lossless = dcmread(emri_jpeg_2k_lossless)
self.sc_rgb_jpeg2k_gdcm_KY = dcmread(sc_rgb_jpeg2k_gdcm_KY)
self.original_handlers = pydicom.config.pixel_data_handlers
pydicom.config.pixel_data_handlers = [numpy_handler]
def testPrivateSQ(self):
"""Can read private undefined length SQ without error."""
# From issues 91, 97, 98. Bug introduced by fast reading, due to
# VR=None in raw data elements, then an undefined length private
# item VR is looked up, and there is no such tag,
# generating an exception
# Simply read the file, in 0.9.5 this generated an exception
dcmread(priv_SQ_name)
def test_read_UC_explicit_little(self):
"""Check creation of DataElement from byte data works correctly."""
ds = dcmread(self.fp_ex, force=True)
ref_elem = ds.get(0x00189908)
elem = DataElement(0x00189908, 'UC', ['A', 'B', 'C'])
self.assertEqual(ref_elem, elem)
ds = dcmread(self.fp_ex, force=True)
ref_elem = ds.get(0x00100212)
elem = DataElement(0x00100212, 'UC', 'Test')
self.assertEqual(ref_elem, elem)
def testSpecificTagsWithUnknownLengthSQ(self):
"""Returns only tags specified by user."""
unknown_len_sq_tag = Tag(0x3f03, 0x1001)
tags = dcmread(priv_SQ_name, specific_tags=[
unknown_len_sq_tag])
tags = sorted(tags.keys())
self.assertEqual([unknown_len_sq_tag], tags)
tags = dcmread(priv_SQ_name, specific_tags=[
'PatientName'])
tags = sorted(tags.keys())
self.assertEqual([], tags)
def testSpecificTagsWithUnknownLengthTag(self):
"""Returns only tags specified by user."""
unknown_len_tag = Tag(0x7fe0, 0x0010) # Pixel Data
tags = dcmread(emri_jpeg_2k_lossless, specific_tags=[
unknown_len_tag])
tags = sorted(tags.keys())
self.assertEqual([unknown_len_tag], tags)
tags = dcmread(emri_jpeg_2k_lossless, specific_tags=[
'SpecificCharacterSet'])
tags = sorted(tags.keys())
self.assertEqual([Tag(0x08, 0x05)], tags)
def test_correct_ambiguous_vr_compressed(self):
"""Test correcting compressed Pixel Data read from file"""
# Create an implicit VR compressed dataset
ds = dcmread(jpeg_lossless_name)
fp = BytesIO()
file_ds = FileDataset(fp, ds)
file_ds.is_implicit_VR = True
file_ds.is_little_endian = True
file_ds.save_as(fp, write_like_original=True)
ds = dcmread(fp, force=True)
self.assertEqual(ds[0x7fe00010].VR, 'OB')
def test_pixel_array_32bit_un_signed(self):
"""Test pixel_array for 32-bit unsigned -> signed."""
ds = dcmread(EXPL_32_3_1F)
# 0 is unsigned int, 1 is 2's complement
assert ds.PixelRepresentation == 0
ds.PixelRepresentation = 1
arr = ds.pixel_array
ref = dcmread(EXPL_32_3_1F)
assert not np.array_equal(arr, ref.pixel_array)
assert (100, 100, 3) == arr.shape
assert -1 == arr[0, :, 0].min() == arr[0, :, 0].max()
assert -2139062144 == arr[50, :, 0].min() == arr[50, :, 0].max()
def test_pixel_array_8bit_un_signed(self):
"""Test pixel_array for 8-bit unsigned -> signed data."""
ds = dcmread(EXPL_8_1_1F)
# 0 is unsigned int, 1 is 2's complement
assert ds.PixelRepresentation == 0
ds.PixelRepresentation = 1
arr = ds.pixel_array
ref = dcmread(EXPL_8_1_1F)
assert not np.array_equal(arr, ref.pixel_array)
assert (600, 800) == arr.shape
assert -12 == arr[0].min() == arr[0].max()
assert (1, -10, 1) == tuple(arr[300, 491:494])
assert 0 == arr[-1].min() == arr[-1].max()
def testNoPixelsRead(self):
"""Returns all data elements before pixels using
stop_before_pixels=False.
"""
# Just check the tags, and a couple of values
ctpartial = dcmread(ct_name, stop_before_pixels=True)
ctpartial_tags = sorted(ctpartial.keys())
ctfull = dcmread(ct_name)
ctfull_tags = sorted(ctfull.keys())
msg = ("Tag list of partial CT read (except pixel tag and padding) "
"did not match full read")
msg += "\nExpected: %r\nGot %r" % (ctfull_tags[:-2], ctpartial_tags)
missing = [Tag(0x7fe0, 0x10), Tag(0xfffc, 0xfffc)]
self.assertEqual(ctfull_tags, ctpartial_tags + missing, msg)
def testReadFileGivenFileObject(self):
"""filereader: can read using already opened file............"""
f = open(ct_name, 'rb')
ct = dcmread(f)
# Tests here simply repeat testCT -- perhaps should collapse
# the code together?
got = ct.ImagePositionPatient
DS = pydicom.valuerep.DS
expected = [DS('-158.135803'), DS('-179.035797'), DS('-75.699997')]
self.assertTrue(got == expected,
"ImagePosition(Patient) values not as expected")
self.assertEqual(ct.file_meta.ImplementationClassUID,
'1.3.6.1.4.1.5962.2',
"ImplementationClassUID not the expected value")
self.assertEqual(ct.file_meta.ImplementationClassUID,
ct.file_meta[0x2, 0x12].value,
"ImplementationClassUID does not match the "
"value accessed by tag number")
# (0020, 0032) Image Position (Patient)
# [-158.13580300000001, -179.035797, -75.699996999999996]
got = ct.ImagePositionPatient
expected = [DS('-158.135803'), DS('-179.035797'), DS('-75.699997')]
self.assertTrue(got == expected,
"ImagePosition(Patient) values not as expected")
self.assertEqual(ct.Rows, 128, "Rows not 128")
self.assertEqual(ct.Columns, 128, "Columns not 128")
self.assertEqual(ct.BitsStored, 16, "Bits Stored not 16")
self.assertEqual(len(ct.PixelData), 128 * 128 * 2,
"Pixel data not expected length")
# Should also be able to close the file ourselves without
# exception raised:
f.close()
def test_pixel_array_raises(self):
"""Test pixel_array raises exception for all syntaxes."""
ds = dcmread(EXPL_16_1_1F)
for uid in ALL_TRANSFER_SYNTAXES:
ds.file_meta.TransferSyntaxUID = uid
with pytest.raises((NotImplementedError, RuntimeError)):
ds.pixel_array
def test_dataset_pixel_array_handler_needs_convert(self):
"""Test Dataset.pixel_array when converting to RGB."""
ds = dcmread(EXPL_8_3_1F)
# Convert to YBR first
arr = ds.pixel_array
assert (255, 0, 0) == tuple(arr[5, 50, :])
arr = convert_color_space(arr, 'RGB', 'YBR_FULL')
ds.PixelData = arr.tobytes()
del ds._pixel_array # Weird PyPy2 issue without this
# Test normal functioning (False)
assert (76, 85, 255) == tuple(ds.pixel_array[5, 50, :])
def needs_convert(ds):
"""Change the default return to True"""
return True
# Test modified
orig_fn = NP_HANDLER.needs_to_convert_to_RGB
NP_HANDLER.needs_to_convert_to_RGB = needs_convert
# Ensure the pixel array gets updated
ds._pixel_id = None
assert (254, 0, 0) == tuple(ds.pixel_array[5, 50, :])
# Reset
NP_HANDLER.needs_to_convert_to_RGB = orig_fn
def test_empty_file(self):
"""Test reading no elements from file produces empty Dataset"""
with tempfile.NamedTemporaryFile() as f:
ds = dcmread(f, force=True)
self.assertTrue(ds.preamble is None)
self.assertEqual(ds.file_meta, Dataset())
self.assertEqual(ds[:], Dataset())
def test_PI_RGB(test_with_pillow,
image,
PhotometricInterpretation,
results,
ground_truth):
t = dcmread(image)
assert t.PhotometricInterpretation == PhotometricInterpretation
a = t.pixel_array
assert a.shape == (100, 100, 3)
"""
This complete test never gave a different result than
just the 10 point test below
gt = dcmread(ground_truth)
b = gt.pixel_array
for x in range(100):
for y in range(100):
assert tuple(a[x, y]) == tuple(b[x, y])
"""
# this test points are from the ImageComments tag
assert tuple(a[5, 50, :]) == results[0]
assert tuple(a[15, 50, :]) == results[1]
assert tuple(a[25, 50, :]) == results[2]
assert tuple(a[35, 50, :]) == results[3]
assert tuple(a[45, 50, :]) == results[4]
assert tuple(a[55, 50, :]) == results[5]
assert tuple(a[65, 50, :]) == results[6]
assert tuple(a[75, 50, :]) == results[7]
assert tuple(a[85, 50, :]) == results[8]
assert tuple(a[95, 50, :]) == results[9]
assert t.PhotometricInterpretation == PhotometricInterpretation
def test_little_16bit_1sample_1frame_padded(self):
"""Test with padded little 16-bit, 1 sample/pixel, 1 frame."""
ds = dcmread(EXPL_16_1_1F_PAD)
assert ds.file_meta.TransferSyntaxUID == ExplicitVRLittleEndian
assert ds.BitsAllocated == 16
assert ds.SamplesPerPixel == 1
assert ds.PixelRepresentation == 1
nr_frames = getattr(ds, 'NumberOfFrames', 1)
assert nr_frames == 1
# Odd sized data is padded by a final 0x00 byte
size = ds.Rows * ds.Columns * nr_frames * 16 / 8 * ds.SamplesPerPixel
# Has excess padding
assert len(ds.PixelData) > size + size % 2
msg = (
r"The length of the pixel data in the dataset \(8320 bytes\) "
r"indicates it contains excess padding. 128 bytes will be "
r"removed from the end of the data"
)
with pytest.warns(UserWarning, match=msg):
arr = ds.pixel_array
assert (64, 64) == arr.shape
assert arr.dtype == 'int16'
assert arr.flags.writeable
assert (422, 319, 361) == tuple(arr[0, 31:34])
assert (366, 363, 322) == tuple(arr[31, :3])
assert (1369, 1129, 862) == tuple(arr[-1, -3:])
# Last pixel
assert 862 == arr[-1, -1]
def test_little_1bit_3sample_10frame(self):
"""Test pixel_array for little 1-bit, 3 sample/pixel, 10 frame."""
# Check all little endian syntaxes
ds = dcmread(None)
for uid in SUPPORTED_SYNTAXES[:3]:
ds.file_meta.TransferSyntaxUID = uid
arr = ds.pixel_array
def test_no_pixel_data_raises(self):
"""Test get_pixeldata raises if dataset has no PixelData."""
ds = dcmread(EXPL_16_1_1F)
del ds.PixelData
assert 'PixelData' not in ds
with pytest.raises(AttributeError, match=' dataset: PixelData'):
get_pixeldata(ds)
def test_little_32bit_3sample_2frame(self):
"""Test pixel_array for little 32-bit, 3 sample/pixel, 10 frame."""
# Check all little endian syntaxes
ds = dcmread(EXPL_32_3_2F)
for uid in SUPPORTED_SYNTAXES[:3]:
ds.file_meta.TransferSyntaxUID = uid
arr = ds.pixel_array
assert arr.flags.writeable
# Frame 1
assert (4294967295, 0, 0) == tuple(arr[0, 5, 50, :])
assert (4294967295, 2155905152, 2155905152) == tuple(
arr[0, 15, 50, :]
)
assert (0, 4294967295, 0) == tuple(arr[0, 25, 50, :])
assert (2155905152, 4294967295, 2155905152) == tuple(
arr[0, 35, 50, :]
)
assert (0, 0, 4294967295) == tuple(arr[0, 45, 50, :])
assert (2155905152, 2155905152, 4294967295) == tuple(
arr[0, 55, 50, :]
)
assert (0, 0, 0) == tuple(arr[0, 65, 50, :])
assert (1077952576, 1077952576, 1077952576) == tuple(
arr[0, 75, 50, :]
)
assert (3233857728, 3233857728, 3233857728) == tuple(
arr[0, 85, 50, :]
)
assert (4294967295, 4294967295, 4294967295) == tuple(
arr[0, 95, 50, :]
)
# Frame 2 is frame 1 inverted
assert np.array_equal((2**ds.BitsAllocated - 1) - arr[1], arr[0])
def test_unknown_pixel_representation_raises(self):
"""Test get_pixeldata raises if unsupported PixelRepresentation."""
ds = dcmread(EXPL_16_1_1F)
ds.PixelRepresentation = 2
with pytest.raises(ValueError,
match=r"value of '2' for '\(0028,0103"):
get_pixeldata(ds)
def test_unsupported_syntaxes_raises(self):
"""Test get_pixeldata raises if unsupported Transfer Syntax."""
ds = dcmread(EXPL_16_1_1F)
ds.file_meta.TransferSyntaxUID = '1.2.840.10008.1.2.4.50'
with pytest.raises(NotImplementedError,
match=' the transfer syntax is not supported'):
get_pixeldata(ds)
def testRTPlan(self):
"""Returns correct values for sample data elements in test
RT Plan file.
"""
plan = dcmread(rtplan_name)
beam = plan.BeamSequence[0]
# if not two controlpoints, then this would raise exception
cp0, cp1 = beam.ControlPointSequence
self.assertEqual(beam.TreatmentMachineName, "unit001",
"Incorrect unit name")
self.assertEqual(beam.TreatmentMachineName, beam[0x300a, 0x00b2].value,
"beam TreatmentMachineName does not match "
"the value accessed by tag number")
got = cp1.ReferencedDoseReferenceSequence[
0].CumulativeDoseReferenceCoefficient
DS = pydicom.valuerep.DS
expected = DS('0.9990268')
self.assertTrue(got == expected,
"Cum Dose Ref Coeff not the expected value "
"(CP1, Ref'd Dose Ref")
got = cp0.BeamLimitingDevicePositionSequence[0].LeafJawPositions
self.assertTrue(got[0] == DS('-100') and got[1] == DS('100.0'),
"X jaws not as expected (control point 0)")
def testJPEGlossless_odd_data_size(self):
"""Test decoding JPEG with pillow handler succeeds."""
test_file = get_testdata_files('SC_rgb_small_odd_jpeg.dcm')[0]
ds = dcmread(test_file)
pixel_data = ds.pixel_array
assert pixel_data.nbytes == 27
assert pixel_data.shape == (3, 3, 3)
def testCT(self):
"""Returns correct values for sample data elements in test CT file."""
ct = dcmread(ct_name)
self.assertEqual(ct.file_meta.ImplementationClassUID,
'1.3.6.1.4.1.5962.2',
"ImplementationClassUID not the expected value")
self.assertEqual(ct.file_meta.ImplementationClassUID,
ct.file_meta[0x2, 0x12].value,
"ImplementationClassUID does not match the value "
"accessed by tag number")
# (0020, 0032) Image Position (Patient)
# [-158.13580300000001, -179.035797, -75.699996999999996]
got = ct.ImagePositionPatient
DS = pydicom.valuerep.DS
expected = [DS('-158.135803'), DS('-179.035797'), DS('-75.699997')]
self.assertTrue(got == expected,
"ImagePosition(Patient) values not as expected."
"got {0}, expected {1}".format(got, expected))
self.assertEqual(ct.Rows, 128, "Rows not 128")
self.assertEqual(ct.Columns, 128, "Columns not 128")
self.assertEqual(ct.BitsStored, 16, "Bits Stored not 16")
self.assertEqual(len(ct.PixelData), 128 * 128 * 2,
"Pixel data not expected length")
# Also test private elements name can be resolved:
expected = "[Duration of X-ray on]"
got = ct[(0x0043, 0x104e)].name
msg = "Mismatch in private tag name, expected '%s', got '%s'"
self.assertEqual(expected, got, msg % (expected, got))
def test_read_OL_explicit_little(self):
"""Check creation of OL DataElement from byte data works correctly."""
ds = dcmread(self.fp_ex, force=True)
ref_elem = ds.get(0x00720075)
elem = DataElement(0x00720075, 'OL',
b'\x00\x01\x02\x03\x04\x05\x06\x07'
b'\x01\x01\x02\x03')
self.assertEqual(ref_elem, elem)
def jpeg_2k(self):
return dcmread(jpeg2000_name)
def mr_small(self):
return dcmread(mr_name)
def jpeg_2k_lossless(self):
return dcmread(jpeg2000_lossless_name)
def emri_small(self):
return dcmread(emri_name)
def test_unknown_pixel_representation_raises(self):
"""Test get_pixeldata raises if unsupported PixelRepresentation."""
ds = dcmread(EXPL_16_1_1F)
ds.PixelRepresentation = 2
with pytest.raises(ValueError, match=r"value of '2' for '\(0028,0103"):
get_pixeldata(ds)
def ground_truth_sc_rgb_jpeg2k_gdcm_KY_gdcm(self):
return dcmread(ground_truth_sc_rgb_jpeg2k_gdcm_KY_gdcm)
def jpeg_lossless_odd_data_size(self):
return dcmread(jpeg_lossless_odd_data_size_name)
def setUp(self):
self.test_data = dcmread(one_bit_allocated_name)
self.original_handlers = pydicom.config.image_handlers
pydicom.config.image_handlers = [None]
def setup(self):
self.jpeg_lossless = dcmread(jpeg_lossless_name)
self.original_handlers = pydicom.config.pixel_data_handlers
pydicom.config.pixel_data_handlers = []
def preptraindata(path):
'''
This method is used to load the training data.
'''
count = 0
for root, dirs, file in os.walk(path):
if not dirs:
continue
else:
# print(root, dirs, file)
# Taking first level with path in root and second level with dirs.
# File is empty
for nroot, ndirs, nfile in os.walk(root):
if not nfile:
continue
else:
start_time = time.time()
dcm_file_path_str = nroot + '/' + nfile[0]
if not dcm_file_path_str.endswith('.dcm'):
continue
dcm_data = dcmread(dcm_file_path_str)
# Structuring metadata
metadata_dict = {"file_path": dcm_file_path_str}
metadata_dict["storage_type"] = dcm_data.SOPClassUID
metadata_dict["patient_name"] = dcm_data.PatientName.family_name \
+ " " \
+ dcm_data.PatientName.given_name
metadata_dict["patient_id"] = dcm_data.PatientID
metadata_dict["patient_age"] = dcm_data.PatientAge
metadata_dict["patient_sex"] = dcm_data.PatientSex
metadata_dict["modality"] = dcm_data.Modality
metadata_dict[
"body_part_examined"] = dcm_data.BodyPartExamined
metadata_dict["view_position"] = dcm_data.ViewPosition
if "PixelData" in dcm_data:
rows = int(dcm_data.Rows)
cols = int(dcm_data.Columns)
metadata_dict["image_height"] = rows
metadata_dict["image_width"] = cols
metadata_dict["image_size"] = len(
dcm_data.PixelData)
else:
metadata_dict["image_height"] = np.nan
metadata_dict["image_width"] = np.nan
metadata_dict["image_size"] = np.nan
if "PixelSpacing" in dcm_data:
metadata_dict[
"pixel_spacing_x"] = dcm_data.PixelSpacing[0]
metadata_dict[
"pixel_spacing_y"] = dcm_data.PixelSpacing[1]
else:
metadata_dict["pixel_spacing_x"] = np.nan
metadata_dict["pixel_spacing_y"] = np.nan
# Insert a count. If first iteration create new dataframe.
# Else append data on dataframe already created
print(
"--- Iteration loaded. Loading time: %s seconds ---"
% (time.time() - start_time))
count += 1
print(count)
if count == 1:
metadata_df = pd.DataFrame.from_records(
[metadata_dict])
else:
metadata_df = metadata_df.append([metadata_dict])
# Resetting index
metadata_df = metadata_df.reset_index()
# Dropping useless index column (all values to zero)
metadata_df = metadata_df.drop(columns=['index'])
# Saving dataframe to local pickle to be loaded from another module
with open('./dataframe/sample_images.pickle', 'wb') as save_file:
pickle.dump(metadata_df, save_file)
return metadata_df
def sc_rgb_jpeg2k_gdcm_KY(self):
return dcmread(sc_rgb_jpeg2k_gdcm_KY)
def test_functional(self):
"""Test against a real dataset."""
ds = dcmread(EXPL_1_1_3F)
arr = ds.pixel_array
arr = arr.ravel()
assert ds.PixelData == pack_bits(arr)
def jpeg_lossy(self):
return dcmread(jpeg_lossy_name)
def jpeg_lossless(self):
return dcmread(jpeg_lossless_name)
def test_can_access_unsupported_dataset(self, fpath, data):
"""Test can read and access elements in unsupported datasets."""
ds = dcmread(fpath)
assert data[0] == ds.file_meta.TransferSyntaxUID
assert data[1] == ds.PatientName
def color_3d_jpeg(self):
return dcmread(color_3d_jpeg_baseline)
def test_using_numpy_handler_raises(self):
ds = dcmread(EXPL_16_1_1F)
msg = ("The pixel data handler 'numpy' is not available on your "
"system. Please refer to the pydicom documentation*")
with pytest.raises(RuntimeError, match=msg):
ds.decompress('numpy')
def emri_jpeg_2k_lossless(self):
return dcmread(emri_jpeg_2k_lossless)
def setup_method(self, method):
self.jpeg_ls_lossless = dcmread(jpeg_ls_lossless_name)
self.mr_small = dcmread(mr_name)
self.emri_jpeg_ls_lossless = dcmread(emri_jpeg_ls_lossless)
self.emri_small = dcmread(emri_name)
self.original_handlers = pydicom.config.image_handlers
def setUp(self):
self.original_handlers = pydicom.config.image_handlers
pydicom.config.image_handlers = [None]
self.emri_big_endian = dcmread(emri_big_endian_name)
self.emri_small = dcmread(emri_name)
def test_change_photometric_interpretation(self):
"""Test returned value."""
ds = dcmread(J2KR_16_12_1_0_1F_M2)
func = LJ_HANDLER.should_change_PhotometricInterpretation_to_RGB
assert func(ds) is False
def dataset_3d(self):
return dcmread(color_3d_jpeg_baseline)
DATA_PATH = CONFIG['lidc_idri_dival']['data_path']
FILE_LIST_FILE = os.path.join(os.path.dirname(__file__),
'lidc_idri_file_list.json')
SERIES_DICT_FILE = os.path.join(os.path.dirname(__file__),
'lidc_idri_series_dict.json')
with open(FILE_LIST_FILE, 'r') as json_file:
file_dict = json.load(json_file)
file_list = []
for files in file_dict.values():
file_list += files
ct_dirs = get_dirs()
series_dict = dict()
for ct_dir in tqdm(ct_dirs):
dcm_files = [
f for f in os.listdir(os.path.join(DATA_PATH, ct_dir))
if (os.path.isfile(os.path.join(DATA_PATH, ct_dir, f))
and f.endswith('.dcm'))
]
dcm_files.sort()
dataset = dcmread(os.path.join(DATA_PATH, ct_dir, dcm_files[0]))
file_dict = {
i: f
for i, f in enumerate(dcm_files)
if os.path.join(ct_dir, f) in file_list
}
series_dict[dataset.SeriesInstanceUID] = [ct_dir, file_dict]
with open(SERIES_DICT_FILE, 'w') as json_file:
json.dump(series_dict, json_file, indent=True)
def jpeg_ls_lossless(self, unicode_filename):
return dcmread(unicode_filename)
def dataset_2d_compressed(self):
return dcmread(jpeg2000_name)
def setup(self):
"""Setup the test datasets."""
self.jpeg_lossless = dcmread(jpeg_lossless_name)
self.original_handlers = pydicom.config.pixel_data_handlers
pydicom.config.pixel_data_handlers = [pillow_handler, numpy_handler]
def dataset_2d(self):
return dcmread(mr_name)
def setup(self):
"""Setup the test datasets."""
self.jpeg_lossy = dcmread(jpeg_lossy_name)
self.color_3d_jpeg = dcmread(color_3d_jpeg_baseline)
self.original_handlers = pydicom.config.pixel_data_handlers
pydicom.config.pixel_data_handlers = [pillow_handler, numpy_handler]
def setUp(self):
self.original_handlers = pydicom.config.image_handlers
pydicom.config.image_handlers = [numpy_handler]
self.jpeg = dcmread(jpeg_lossless_name)
def setup(self):
self.jpeg_lossy = dcmread(jpeg_lossy_name)
self.color_3d_jpeg = dcmread(color_3d_jpeg_baseline)
self.original_handlers = pydicom.config.pixel_data_handlers
pydicom.config.pixel_data_handlers = []
