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 = []