def setUp(self): self.jpeg_ls_lossless = read_file(jpeg_ls_lossless_name) self.mr_small = read_file(mr_name) self.emri_jpeg_ls_lossless = read_file(emri_jpeg_ls_lossless) self.emri_small = read_file(emri_name) self.original_handlers = pydicom.config.image_handlers pydicom.config.image_handlers = [pillow_handler, numpy_handler]
def testValuesIdentical(self): """Deferred values exactly matches normal read...............""" ds_norm = read_file(self.testfile_name) ds_defer = read_file(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 test_multivalue_DA(self): """Write DA/DT/TM data elements..........""" multi_DA_expected = (date(1961, 8, 4), date(1963, 11, 22)) DA_expected = date(1961, 8, 4) tzinfo = tzoffset('-0600', -21600) multi_DT_expected = (datetime(1961, 8, 4), datetime(1963, 11, 22, 12, 30, 0, 0, tzoffset('-0600', -21600))) multi_TM_expected = (time(1, 23, 45), time(11, 11, 11)) TM_expected = time(11, 11, 11, 1) ds = read_file(datetime_name) # Add date/time data elements ds.CalibrationDate = MultiValue(DA, multi_DA_expected) ds.DateOfLastCalibration = DA(DA_expected) ds.ReferencedDateTime = MultiValue(DT, multi_DT_expected) ds.CalibrationTime = MultiValue(TM, multi_TM_expected) ds.TimeOfLastCalibration = TM(TM_expected) ds.save_as(datetime_out) # Now read it back in and check the values are as expected ds = read_file(datetime_out) self.assertSequenceEqual(multi_DA_expected, ds.CalibrationDate, "Multiple dates not written correctly (VR=DA)") self.assertEqual(DA_expected, ds.DateOfLastCalibration, "Date not written correctly (VR=DA)") self.assertSequenceEqual(multi_DT_expected, ds.ReferencedDateTime, "Multiple datetimes not written correctly (VR=DT)") self.assertSequenceEqual(multi_TM_expected, ds.CalibrationTime, "Multiple times not written correctly (VR=TM)") self.assertEqual(TM_expected, ds.TimeOfLastCalibration, "Time not written correctly (VR=DA)") if os.path.exists(datetime_out): os.remove(datetime_out) # get rid of the file
def setUp(self): self.jpeg_2k = read_file(jpeg2000_name) self.jpeg_2k_lossless = read_file(jpeg2000_lossless_name) self.mr_small = read_file(mr_name) self.emri_jpeg_2k_lossless = read_file(emri_jpeg_2k_lossless) self.emri_small = read_file(emri_name) self.original_handlers = pydicom.config.image_handlers pydicom.config.image_handlers = [gdcm_handler]
def testPlanarConfig(self): px_data_ds = read_file(color_px_name) pl_data_ds = read_file(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 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 read_file(priv_SQ_name)
def testwrite_short_uid(self): ds = read_file(rtplan_name) ds.SOPInstanceUID = "1.2" ds.save_as(rtplan_out) ds = read_file(rtplan_out) ds.save_as(rtplan_out) self.assertEqual(ds.SOPInstanceUID, "1.2") if os.path.exists(rtplan_out): os.remove(rtplan_out) # get rid of the file
def testNoPixelsRead(self): """Returns all data elements before pixels using stop_before_pixels=False""" # Just check the tags, and a couple of values ctpartial = read_file(ct_name, stop_before_pixels=True) ctpartial_tags = sorted(ctpartial.keys()) ctfull = read_file(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 = read_file(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 testNestedPrivateSQ(self): """Can successfully read a private SQ which contains additional SQ's.....""" # From issue 113. When a private SQ of undefined length is used, the # sequence is read in and the length of the SQ is determined upon # identification of the SQ termination sequence. When using nested # Sequences, the first termination sequence encountered actually # belongs to the nested Sequence not the parent, therefore the # remainder of the file is not read in properly ds = read_file(nested_priv_SQ_name) # Make sure that the entire dataset was read in pixel_data_tag = TupleTag((0x7FE0, 0x10)) self.assertTrue(pixel_data_tag in ds, "Entire dataset was not parsed properly. PixelData is not present") # Check that the DataElement is indeed a Sequence tag = TupleTag((0x01, 0x01)) seq0 = ds[tag] self.assertEqual(seq0.VR, "SQ", "First level sequence not parsed properly") # Now verify the presence of the nested private SQ seq1 = seq0[0][tag] self.assertEqual(seq1.VR, "SQ", "Second level sequence not parsed properly") # Now make sure the values that are parsed are correct got = seq1[0][tag].value expected = b"Double Nested SQ" self.assertEqual(got, expected, "Expected a value of %s, got %s'" % (expected, got)) got = seq0[0][0x01, 0x02].value expected = b"Nested SQ" self.assertEqual(got, expected, "Expected a value of %s, got %s'" % (expected, got))
def testRTstruct(self): """Returns correct values for sample elements in test RTSTRUCT file....""" # RTSTRUCT test file has complex nested sequences -- see rtstruct.dump file # Also has no DICOM header ... so tests 'force' argument of read_file rtss = read_file(rtstruct_name, force=True) expected = '1.2.840.10008.1.2' # implVR little endian got = rtss.file_meta.TransferSyntaxUID msg = "Expected transfer syntax %r, got %r" % (expected, got) self.assertEqual(expected, got, msg) frame_of_ref = rtss.ReferencedFrameOfReferenceSequence[0] study = frame_of_ref.RTReferencedStudySequence[0] uid = study.RTReferencedSeriesSequence[0].SeriesInstanceUID expected = "1.2.826.0.1.3680043.8.498.2010020400001.2.1.1" msg = "Expected Reference Series UID '%s', got '%s'" % (expected, uid) self.assertEqual(expected, uid, msg) got = rtss.ROIContourSequence[0].ContourSequence[2].ContourNumber expected = 3 msg = "Expected Contour Number %d, got %r" % (expected, got) self.assertEqual(expected, got, msg) obs_seq0 = rtss.RTROIObservationsSequence[0] got = obs_seq0.ROIPhysicalPropertiesSequence[0].ROIPhysicalProperty expected = 'REL_ELEC_DENSITY' msg = "Expected Physical Property '%s', got %r" % (expected, got) self.assertEqual(expected, got, msg)
def testCTPixelData(self): """Check that we can read pixel data. Tests that we get last one in array.""" ct = read_file(ct_name) expected = 909 got = ct.pixel_array[-1][-1] msg = "Did not get correct value for last pixel: expected %d, got %r" % (expected, got) self.assertEqual(expected, got, msg)
def testDeflate(self): """Returns correct values for sample data elements in test compressed (zlib deflate) file""" # Everything after group 2 is compressed. If we can read anything else, the decompression must have been ok. ds = read_file(deflate_name) got = ds.ConversionType expected = "WSD" self.assertEqual(got, expected, "Attempted to read deflated file data element Conversion Type, expected '%s', got '%s'" % (expected, got))
def testCT(self): """Returns correct values for sample data elements in test CT file....""" ct = read_file(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 setUp(self): if compat.in_py2: self.utf8_filename = os.path.join(tempfile.gettempdir(), "ДИКОМ.dcm") self.unicode_filename = self.utf8_filename.decode("utf8") shutil.copyfile(jpeg_ls_lossless_name.decode("utf8"), self.unicode_filename) else: self.unicode_filename = os.path.join(tempfile.gettempdir(), "ДИКОМ.dcm") shutil.copyfile(jpeg_ls_lossless_name, self.unicode_filename) self.jpeg_ls_lossless = read_file(self.unicode_filename) self.mr_small = read_file(mr_name) self.emri_jpeg_ls_lossless = read_file(emri_jpeg_ls_lossless) self.emri_small = read_file(emri_name) self.original_handlers = pydicom.config.image_handlers pydicom.config.image_handlers = [numpy_handler, gdcm_handler]
def testExplicitVRBigEndianNoMeta(self): """Read file without file meta with Big Endian Explicit VR dataset.......""" # Example file from CMS XiO 5.0 and above # Still need to force read data since there is no 'DICM' marker present ds = read_file(explicit_vr_be_no_meta, force=True) got = ds.InstanceCreationDate expected = "20150529" self.assertEqual(got, expected, "Sample data element from dataset failed, expected '%s', got '%s'" % (expected, got))
def dump_file(self, file_path): try: print('\n' + file_path) dataset = filereader.read_file( file_path, stop_before_pixels=self.show_image_data, force=True) self.print_dataset(dataset) except (InvalidDicomError, KeyError): print(u'{} is not a valid DICOM file - skipping.'.format(file_path))
def testFileExists(self): """Deferred read raises error if file no longer exists.....""" ds = read_file(self.testfile_name, defer_size=2000) os.remove(self.testfile_name) def read_value(): ds.PixelData self.assertRaises(IOError, read_value)
def testNoPixelsRead(self): """Returns all data elements before pixels using stop_before_pixels=False""" # Just check the tags, and a couple of values ctpartial = read_file(ct_name, stop_before_pixels=True) ctpartial_tags = sorted(ctpartial.keys()) ctfull = read_file(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 testZippedDeferred(self): """Deferred values from a gzipped file works..............""" # Arose from issue 103 "Error for defer_size read of gzip file object" fobj = gzip.open(gzip_name) ds = read_file(fobj, defer_size=1) fobj.close() # before the fix, this threw an error as file reading was not in right place, # it was re-opened as a normal file, not zip file ds.InstanceNumber
def testNoMetaGroupLength(self): """Read file with no group length in file meta...........................""" # Issue 108 -- iView example file with no group length (0002,0002) # Originally crashed, now check no exception, but also check one item # in file_meta, and second one in followinsg dataset ds = read_file(no_meta_group_length) got = ds.InstanceCreationDate expected = "20111130" self.assertEqual(got, expected, "Sample data element after file meta with no group length failed, expected '%s', got '%s'" % (expected, got))
def testCTPixelData(self): """Check that we can read pixel data. Tests that we get last one in array. """ ct = read_file(ct_name) expected = 909 got = ct.pixel_array[-1][-1] msg = ("Did not get correct value for last pixel: " "expected %d, got %r" % (expected, got)) self.assertEqual(expected, got, msg)
def validate_file(self, file_path): self.logger.info('\nProcessing DICOM file "%s"', file_path) try: data_set = filereader.read_file(file_path, stop_before_pixels=True) except InvalidDicomError: return {file_path: {'fatal': 'Invalid DICOM file'}} return { file_path: IODValidator(data_set, self._iod_info, self._module_info, self._dict_info, self.logger.level).validate() }
def test_write_no_ts(self): """Test reading a file with no ts and writing it out identically.""" written_file = TemporaryFile('w+b') ds = read_file(no_ts) ds.save_as(written_file, write_like_original=True) written_file.seek(0) with open(no_ts, 'rb') as ref_file: written_bytes = written_file.read() read_bytes = ref_file.read() self.compare_bytes(read_bytes, written_bytes)
def testEmptyNumbersTag(self): """Tests that an empty tag with a number VR (FL, UL, SL, US, SS, FL, FD, OF) reads as an empty string""" empty_number_tags_ds = read_file(empty_number_tags_name) self.assertEqual(empty_number_tags_ds.ExaminedBodyThickness, "") self.assertEqual(empty_number_tags_ds.SimpleFrameList, "") self.assertEqual(empty_number_tags_ds.ReferencePixelX0, "") self.assertEqual(empty_number_tags_ds.PhysicalUnitsXDirection, "") self.assertEqual(empty_number_tags_ds.TagAngleSecondAxis, "") self.assertEqual(empty_number_tags_ds.TagSpacingSecondDimension, "") self.assertEqual(empty_number_tags_ds.VectorGridData, "")
def testNoTransferSyntaxInMeta(self): """Read file with file_meta, but has no TransferSyntaxUID in it............""" # From issue 258: if file has file_meta but no TransferSyntaxUID in it, # should assume default transfer syntax ds = read_file(meta_missing_tsyntax_name) # is dicom default transfer syntax # Repeat one test from nested private sequence test to maker sure # file was read correctly pixel_data_tag = TupleTag((0x7FE0, 0x10)) self.assertTrue(pixel_data_tag in ds, "Failed to properly read a file with no Transfer Syntax in file_meta")
def testSpecificTags(self): """Returns only tags specified by user.""" ctspecific = read_file(ct_name, specific_tags=[ Tag(0x0010, 0x0010), 'PatientID', 'ImageType', 'ViewName']) ctspecific_tags = sorted(ctspecific.keys()) expected = [ # ViewName does not exist in the data set Tag(0x0008, 0x0008), Tag(0x0010, 0x0010), Tag(0x0010, 0x0020) ] self.assertEqual(expected, ctspecific_tags)
def testEmptyNumbersTag(self): """Tests that an empty tag with a number VR (FL, UL, SL, US, SS, FL, FD, OF) reads as an empty string""" empty_number_tags_ds = read_file(empty_number_tags_name) self.assertEqual(empty_number_tags_ds.ExaminedBodyThickness, '') self.assertEqual(empty_number_tags_ds.SimpleFrameList, '') self.assertEqual(empty_number_tags_ds.ReferencePixelX0, '') self.assertEqual(empty_number_tags_ds.PhysicalUnitsXDirection, '') self.assertEqual(empty_number_tags_ds.TagAngleSecondAxis, '') self.assertEqual(empty_number_tags_ds.TagSpacingSecondDimension, '') self.assertEqual(empty_number_tags_ds.VectorGridData, '')
def testReadFileWithMissingPixelDataArray(self): mr = read_file(truncated_mr_name) mr.decode() msg = (r"(Amount of pixel data.*" "does not match the expected data|" "Unexpected end of file. Read.*bytes of.*expected|" "'str' object has no attribute 'reshape'|" "'bytes' object has no attribute 'reshape')") with self.assertRaisesRegexp(AttributeError, msg): mr.pixel_array
def testDeflate(self): """Returns correct values for sample data elements in test compressed (zlib deflate) file""" # Everything after group 2 is compressed. If we can read anything else, the decompression must have been ok. ds = read_file(deflate_name) got = ds.ConversionType expected = "WSD" self.assertEqual( got, expected, "Attempted to read deflated file data element Conversion Type, expected '%s', got '%s'" % (expected, got))
def test_read_UR_explicit_little(self): """Check creation of DataElement from byte data works correctly.""" ds = read_file(self.fp_ex, force=True) ref_elem = ds.get(0x00080120) # URNCodeValue elem = DataElement(0x00080120, 'UR', 'http://test.com') self.assertEqual(ref_elem, elem) # Test trailing spaces ignored ref_elem = ds.get(0x00081190) # RetrieveURL elem = DataElement(0x00081190, 'UR', 'ftp://test.com') self.assertEqual(ref_elem, elem)
def test_meta_no_dataset(self): """Test reading only meta elements""" bytestream = b'\x02\x00\x00\x00\x55\x4C\x04\x00\x0A\x00\x00\x00' \ b'\x02\x00\x02\x00\x55\x49\x16\x00\x31\x2e\x32\x2e\x38\x34\x30\x2e\x31' \ b'\x30\x30\x30\x38\x2e\x35\x2e\x31\x2e\x31\x2e\x39\x00\x02\x00\x10\x00' \ b'\x55\x49\x12\x00\x31\x2e\x32\x2e\x38\x34\x30\x2e\x31\x30\x30\x30\x38' \ b'\x2e\x31\x2e\x32\x00' fp = BytesIO(bytestream) ds = read_file(fp, force=True) self.assertTrue('TransferSyntaxUID' in ds.file_meta) self.assertEqual(ds[:], Dataset())
def __initialized(self): try: header = read_file(self.__filename, defer_size=None, stop_before_pixels=True) except InvalidDicomError: self.__isDicom = False return try: #find the manufacturer self.__manufacturer = 'UNKNOWN' if 'Manufacturer' in header: for manufacturer in manufacturers: if manufacturer in header.Manufacturer: self.__manufacturer = manufacturer self.__patientName = util.slugify(header.PatientName) self.__seriesDescription = util.slugify(header.SeriesDescription) self.__seriesNumber = header.SeriesNumber self.__instanceNumber = header.InstanceNumber self.__echoTime = header.EchoTime self.__isDicom = True except AttributeError as a: if "EchoTime" in a.message: try: self.__echoTime = header[Tag((0x2001, 0x1025))].value self.__isDicom = True except KeyError as k: self.__isDicom = False else: self.__isDicom = False if self.isSiemens(): #inherith Siemens ascconv properties Ascconv.__init__(self, self.__filename) bandwidthPerPixelPhaseEncodeTag = Tag((0x0019, 0x1028)) try: if header.has_key(bandwidthPerPixelPhaseEncodeTag): val = header[bandwidthPerPixelPhaseEncodeTag].value try: self.__bandwidthPerPixelPhaseEncode = float(val) except ValueError: # some data have wrong VR in dicom, try to unpack self.__bandwidthPerPixelPhaseEncode = struct.unpack('d', val)[0] self.__echoSpacing = 1/(self.__bandwidthPerPixelPhaseEncode* self.getEpiFactor()) *1000.0 * \ self.getPatFactor() * self.getPhaseResolution() * \ self.getPhaseOversampling() except (KeyError, IndexError, TypeError, ValueError): self.__echoSpacing = None
def testNoTransferSyntaxInMeta(self): """Read file with file_meta, but has no TransferSyntaxUID in it............""" # From issue 258: if file has file_meta but no TransferSyntaxUID in it, # should assume default transfer syntax ds = read_file(meta_missing_tsyntax_name) # is dicom default transfer syntax # Repeat one test from nested private sequence test to maker sure # file was read correctly pixel_data_tag = TupleTag((0x7fe0, 0x10)) self.assertTrue(pixel_data_tag in ds, "Failed to properly read a file with no Transfer Syntax in file_meta")
def testListItemWriteBack(self): """Change item in a list and confirm it is written to file ..""" DS_expected = 0 CS_expected = "new" SS_expected = 999 ds = read_file(ct_name) ds.ImagePositionPatient[2] = DS_expected ds.ImageType[1] = CS_expected ds[(0x0043, 0x1012)].value[0] = SS_expected ds.save_as(ct_out) # Now read it back in and check that the values were changed ds = read_file(ct_out) self.assertTrue(ds.ImageType[1] == CS_expected, "Item in a list not written correctly to file (VR=CS)") self.assertTrue(ds[0x00431012].value[0] == SS_expected, "Item in a list not written correctly to file (VR=SS)") self.assertTrue(ds.ImagePositionPatient[2] == DS_expected, "Item in a list not written correctly to file (VR=DS)") if os.path.exists(ct_out): os.remove(ct_out)
def testReadFileWithMissingPixelData(self): mr = read_file(truncated_mr_name) mr.decode() self.assertEqual(mr.PatientName, 'CompressedSamples^MR1', "Wrong patient name") self.assertEqual(mr.PatientName, mr[0x10, 0x10].value, "Name does not match value found when " "accessed by tag number") got = mr.PixelSpacing DS = pydicom.valuerep.DS expected = [DS('0.3125'), DS('0.3125')] self.assertTrue(got == expected, "Wrong pixel spacing")
def testMR(self): """Returns correct values for sample data elements in test MR file.....""" mr = read_file(mr_name) # (0010, 0010) Patient's Name 'CompressedSamples^MR1' mr.decode() self.assertEqual(mr.PatientName, 'CompressedSamples^MR1', "Wrong patient name") self.assertEqual(mr.PatientName, mr[0x10, 0x10].value, "Name does not match value found when accessed by tag number") got = mr.PixelSpacing DS = pydicom.valuerep.DS expected = [DS('0.3125'), DS('0.3125')] self.assertTrue(got == expected, "Wrong pixel spacing")
def testRTDose(self): """Returns correct values for sample data elements in test RT Dose file""" dose = read_file(rtdose_name) self.assertEqual(dose.FrameIncrementPointer, Tag((0x3004, 0x000c)), "Frame Increment Pointer not the expected value") self.assertEqual(dose.FrameIncrementPointer, dose[0x28, 9].value, "FrameIncrementPointer does not match the value accessed by tag number") # try a value that is nested the deepest (so deep I break it into two steps!) fract = dose.ReferencedRTPlanSequence[0].ReferencedFractionGroupSequence[0] beamnum = fract.ReferencedBeamSequence[0].ReferencedBeamNumber self.assertEqual(beamnum, 1, "Beam number not the expected value")
def testReadFileWithMissingPixelData(self): mr = read_file(truncated_mr_name) mr.decode() self.assertEqual(mr.PatientName, 'CompressedSamples^MR1', "Wrong patient name") self.assertEqual(mr.PatientName, mr[0x10, 0x10].value, "Name does not match value found when accessed by tag number") got = mr.PixelSpacing DS = pydicom.valuerep.DS expected = [DS('0.3125'), DS('0.3125')] self.assertTrue(got == expected, "Wrong pixel spacing") with self.assertRaisesRegexp(AttributeError, "Amount of pixel data.*does not match the expected data"): mr.pixel_array
def testReadFileGivenFileLikeObject(self): """filereader: can read using a file-like (BytesIO) file....""" with open(ct_name, 'rb') as f: file_like = BytesIO(f.read()) ct = read_file(file_like) # Tests here simply repeat some of testCT test 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(len(ct.PixelData), 128 * 128 * 2, "Pixel data not expected length") # Should also be able to close the file ourselves without exception raised: file_like.close()
def test_long_specific_char_set(self): """Test that specific character set is read even if it is longer than defer_size""" ds = Dataset() long_specific_char_set_value = ['ISO 2022IR 100'] * 9 ds.add(DataElement(0x00080005, 'CS', long_specific_char_set_value)) fp = BytesIO() file_ds = FileDataset(fp, ds) file_ds.save_as(fp) ds = read_file(fp, defer_size=65, force=True) self.assertEqual(ds[0x00080005].value, long_specific_char_set_value)
def test_read_UR(self): """Check creation of DataElement from byte data works correctly.""" ds = read_file(self.fp, force=True) ref_elem = ds.get(0x00080120) # URNCodeValue ref_elem.file_tell = None # Workaround for Issue #294 elem = DataElement(0x00080120, 'UR', 'http://test.com') self.assertEqual(ref_elem, elem) # Test trailing spaces ignored ref_elem = ds.get(0x00081190) # RetrieveURL ref_elem.file_tell = None # Workaround for Issue #294 elem = DataElement(0x00081190, 'UR', 'ftp://test.com') self.assertEqual(ref_elem, elem)
def test_commandset_no_dataset(self): """Test reading only command set elements""" bytestream = (b'\x00\x00\x00\x00\x04\x00\x00\x00\x38' b'\x00\x00\x00\x00\x00\x02\x00\x12\x00\x00' b'\x00\x31\x2e\x32\x2e\x38\x34\x30\x2e\x31' b'\x30\x30\x30\x38\x2e\x31\x2e\x31\x00\x00' b'\x00\x00\x01\x02\x00\x00\x00\x30\x00\x00' b'\x00\x10\x01\x02\x00\x00\x00\x07\x00\x00' b'\x00\x00\x08\x02\x00\x00\x00\x01\x01') fp = BytesIO(bytestream) ds = read_file(fp, force=True) self.assertTrue('MessageID' in ds) self.assertTrue(ds.preamble is None) self.assertEqual(ds.file_meta, Dataset())
def compare(self, in_filename, out_filename, decode=False): """Read file1, write file2, then compare. Return value as for files_identical. """ dataset = read_file(in_filename) if decode: dataset.decode() dataset.save_as(out_filename) same, pos = files_identical(in_filename, out_filename) self.assertTrue(same, "Files are not identical - first difference at 0x%x" % pos) if os.path.exists(out_filename): os.remove(out_filename) # get rid of the file
def test_no_preamble_file_meta(self): """Test correct read of group 2 elements with no preamble.""" bytestream = b'\x02\x00\x02\x00\x55\x49\x16\x00\x31\x2e\x32\x2e\x38\x34\x30\x2e\x31' \ b'\x30\x30\x30\x38\x2e\x35\x2e\x31\x2e\x31\x2e\x39\x00\x02\x00\x10\x00' \ b'\x55\x49\x12\x00\x31\x2e\x32\x2e\x38\x34\x30\x2e\x31\x30\x30\x30\x38' \ b'\x2e\x31\x2e\x32\x00\x20\x20\x10\x00\x02\x00\x00\x00\x01\x00\x20\x20' \ b'\x20\x00\x06\x00\x00\x00\x4e\x4f\x52\x4d\x41\x4c' fp = BytesIO(bytestream) ds = read_file(fp, force=True) self.assertTrue('MediaStorageSOPClassUID' in ds.file_meta) self.assertEqual(ds.file_meta.TransferSyntaxUID, ImplicitVRLittleEndian) self.assertEqual(ds.Polarity, 'NORMAL') self.assertEqual(ds.ImageBoxPosition, 1)
def testTimeCheck(self): """Deferred read warns if file has been modified...........""" if stat_available: ds = read_file(self.testfile_name, defer_size=2000) from time import sleep sleep(1) with open(self.testfile_name, "r+") as f: f.write('\0') # "touch" the file warning_start = "Deferred read warning -- file modification time " def read_value(): ds.PixelData assertWarns(self, warning_start, read_value)
def compare(self, in_filename, out_filename, decode=False): """Read file1, write file2, then compare. Return value as for files_identical. """ dataset = read_file(in_filename) if decode: dataset.decode() dataset.save_as(out_filename) same, pos = files_identical(in_filename, out_filename) self.assertTrue( same, "Files are not identical - first difference at 0x%x" % pos) if os.path.exists(out_filename): os.remove(out_filename) # get rid of the file
def test_read_file_does_not_raise(self): """Test that reading from DicomBytesIO does not raise on EOF. Regression test for #358.""" ds = read_file(mr_name) fp = DicomBytesIO() ds.save_as(fp) fp.seek(0) de_gen = data_element_generator(fp, False, True) try: while True: next(de_gen) except StopIteration: pass except EOFError: self.fail('Unexpected EOFError raised')
def test_correct_ambiguous_vr(self): """Test correcting ambiguous VR elements read from file""" ds = Dataset() ds.PixelRepresentation = 0 ds.add(DataElement(0x00280108, 'US', 10)) ds.add(DataElement(0x00280109, 'US', 500)) fp = BytesIO() file_ds = FileDataset(fp, ds) file_ds.is_implicit_VR = True file_ds.is_little_endian = True file_ds.save_as(fp) ds = read_file(fp, force=True) self.assertEqual(ds[0x00280108].VR, 'US') self.assertEqual(ds.SmallestPixelValueInSeries, 10)
def test_preamble_meta_no_dataset(self): """Test reading only preamble and meta elements""" preamble = b'\x00' * 128 prefix = b'DICM' meta = b'\x02\x00\x00\x00\x55\x4C\x04\x00\x0A\x00\x00\x00' \ b'\x02\x00\x02\x00\x55\x49\x16\x00\x31\x2e\x32\x2e\x38\x34\x30\x2e\x31' \ b'\x30\x30\x30\x38\x2e\x35\x2e\x31\x2e\x31\x2e\x39\x00\x02\x00\x10\x00' \ b'\x55\x49\x12\x00\x31\x2e\x32\x2e\x38\x34\x30\x2e\x31\x30\x30\x30\x38' \ b'\x2e\x31\x2e\x32\x00' bytestream = preamble + prefix + meta fp = BytesIO(bytestream) ds = read_file(fp, force=True) self.assertEqual(ds.preamble, b'\x00' * 128) self.assertTrue('TransferSyntaxUID' in ds.file_meta) self.assertEqual(ds[:], Dataset())
def testDir(self): """Returns correct dir attributes for both Dataset and DICOM names (python >= 2.6)..""" # Only python >= 2.6 calls __dir__ for dir() call rtss = read_file(rtstruct_name, force=True) # sample some expected 'dir' values got_dir = dir(rtss) expect_in_dir = ["pixel_array", "add_new", "ROIContourSequence", "StructureSetDate"] for name in expect_in_dir: self.assertTrue(name in got_dir, "Expected name '%s' in dir()" % name) # Now check for some items in dir() of a nested item roi0 = rtss.ROIContourSequence[0] got_dir = dir(roi0) expect_in_dir = ["pixel_array", "add_new", "ReferencedROINumber", "ROIDisplayColor"] for name in expect_in_dir: self.assertTrue(name in got_dir, "Expected name '%s' in dir()" % name)