def downloadSeries(self, studyUID, seriesUID, outputdir, patientID=None):
hashdir = hashlib.sha224(studyUID + "/" + seriesUID).hexdigest()
targetdir = outputdir + "/" + hashdir + "/"
if not os.path.exists(outputdir): os.makedirs(outputdir)
if not os.path.exists(targetdir): os.makedirs(targetdir)
self.de_infmodel = gdcm.DataElement(self.tag_infmodel)
self.de_infmodel.SetByteValue('SERIES', gdcm.VL(len('SERIES')))
self.de_StudyUID = gdcm.DataElement(self.tag_StudyUID)
self.de_StudyUID.SetByteValue(studyUID, gdcm.VL(len(studyUID)))
self.de_SeriesUID = gdcm.DataElement(self.tag_SeriesUID)
self.de_SeriesUID.SetByteValue(seriesUID, gdcm.VL(len(seriesUID)))
self.dataset_seriesQuery = gdcm.DataSet()
self.dataset_seriesQuery.Insert(self.de_StudyUID)
self.dataset_seriesQuery.Insert(self.de_infmodel)
self.dataset_seriesQuery.Insert(self.de_SeriesUID)
self.cnf_series = gdcm.CompositeNetworkFunctions()
self.theSeriesQuery = self.cnf_series.ConstructQuery(
gdcm.eStudyRootType, gdcm.eSeries, self.dataset_seriesQuery)
# Execute the C-FIND query
self.cnf_series.CMove(self.server, self.remoteport,
self.theSeriesQuery, self.localport,
self.aetitle, self.caller, targetdir)
return targetdir
def study(request, study_iuid):
# Patient Name
response = {}
study_iuid_tag = gdcm.Tag(0x20, 0xD)
study_iuid_element = gdcm.DataElement(study_iuid_tag)
study_descr_tag = gdcm.Tag(0x8, 0x1030)
study_descr_element = gdcm.DataElement(study_descr_tag)
study_iuid_element.SetByteValue(str(study_iuid), gdcm.VL(len(study_iuid)))
ds = gdcm.DataSet()
ds.Insert(study_iuid_element)
ds.Insert(study_descr_element)
cnf = gdcm.CompositeNetworkFunctions()
theQuery = cnf.ConstructQuery(gdcm.eStudyRootType, gdcm.eStudy, ds)
# prepare the variable for output
ret = gdcm.DataSetArrayType()
# Execute the C-FIND query
cnf.CFind(settings.SC_DICOM_SERVER, settings.SC_DICOM_PORT, theQuery, ret,
'GDCM_PYTHON', settings.AET)
response["description"] = str(
ret[0].GetDataElement(study_descr_tag).GetValue())
ds = gdcm.DataSet()
series_descr_tag = gdcm.Tag(0x8, 0x103E)
series_descr_element = gdcm.DataElement(series_descr_tag)
series_iuid_tag = gdcm.Tag(0x20, 0xE)
series_iuid_element = gdcm.DataElement(series_iuid_tag)
series_number_tag = gdcm.Tag(0x20, 0x11)
series_number_element = gdcm.DataElement(series_number_tag)
ds.Insert(study_iuid_element)
ds.Insert(series_descr_element)
ds.Insert(series_iuid_element)
ds.Insert(series_number_element)
series_query = cnf.ConstructQuery(gdcm.eStudyRootType, gdcm.eSeries, ds)
ret = gdcm.DataSetArrayType()
cnf.CFind(settings.SC_DICOM_SERVER, settings.SC_DICOM_PORT, series_query,
ret, 'GDCM_PYTHON', settings.AET)
sorted_ret = sorted(
ret,
key=lambda x: int(str(x.GetDataElement(series_number_tag).GetValue())))
response["series"] = [{
"description":
str(x.GetDataElement(series_descr_tag).GetValue()),
"uid":
str(x.GetDataElement(series_iuid_tag).GetValue())
} for x in sorted_ret]
json_response = json.dumps(response)
if request.GET.has_key('callback'):
json_response = "(function(){%s(%s);})();" % (request.GET['callback'],
json_response)
return HttpResponse(json_response, content_type="application/json")
def RunCMove(self, values):
ds = gdcm.DataSet()
#for v in values:
tg_patient = gdcm.Tag(0x0010, 0x0020)
tg_serie = gdcm.Tag(0x0020, 0x000e)
de_patient = gdcm.DataElement(tg_patient)
de_serie = gdcm.DataElement(tg_serie)
patient_id = str(values[0])
serie_id = str(values[1])
print "(0x0010, 0x0020)",patient_id
print "(0x0020, 0x000e)",serie_id
print "\n\n"
de_patient.SetByteValue(patient_id, gdcm.VL(len(patient_id)))
de_serie.SetByteValue(serie_id, gdcm.VL(len(serie_id)))
ds.Insert(de_patient)
ds.Insert(de_serie)
cnf = gdcm.CompositeNetworkFunctions()
theQuery = cnf.ConstructQuery(gdcm.ePatientRootType, gdcm.eImageOrFrame, ds)
#ret = gdcm.DataSetArrayType()
"""
CMove (const char *remote,
uint16_t portno,
const BaseRootQuery *query,
uint16_t portscp,
const char *aetitle=NULL,
const char *call=NULL,
const char *outputdir=NULL)"""
print ">>>>>", self.address, int(self.port), theQuery, 11112, self.aetitle,\
self.aetitle_call, "/home/phamorim/Desktop/output/"
cnf.CMove(self.address, int(self.port), theQuery, 11112, self.aetitle,\
self.aetitle_call, "/home/phamorim/Desktop/")
print "BAIXOUUUUUUUU"
def TestModifyFields(filename):
outfilename = filename + ".rewrite"
r = gdcm.Reader()
r.SetFileName(filename)
sucess = r.Read()
#print r.GetFile().GetDataSet()
ds = r.GetFile().GetDataSet()
#print dir(ds)
# eg, let's remove a tag
removetag = gdcm.Tag(0x0043, 0x106f)
if ds.FindDataElement(removetag):
ds.Remove(removetag)
# let's replace a value:
replacetag = gdcm.Tag(0x0010, 0x0010)
if ds.FindDataElement(replacetag):
de = ds.GetDataElement(replacetag)
#print dir(de)
patname = "This^is^an^example"
vl = gdcm.VL(len(patname))
de.SetByteValue(patname, vl)
# let's insert a new dataelement
# <entry group="0012" element="0062" vr="CS" vm="1" name="Patient Identity Removed"/>
pir = gdcm.DataElement(gdcm.Tag(0x0012, 0x0062))
pir.SetVR(gdcm.VR(gdcm.VR.CS)) # specify the VR explicitely
yes = "YES"
pir.SetByteValue(yes, gdcm.VL(len(yes)))
ds.Insert(pir)
# try again but pretend we don't know the VR
# <entry group="0012" element="0063" vr="LO" vm="1-n" name="De-identification Method"/>
deidmethod = gdcm.Tag(0x0012, 0x0063)
# retrieve the supreme global instance, sum of all knowledge in da whole universe:
dicomdicts = gdcm.GlobalInstance.GetDicts()
dictel = dicomdicts.GetDictEntry(deidmethod)
#print dictel.GetVR()
deid = gdcm.DataElement(deidmethod)
deid.SetVR(dictel.GetVR())
methodstr = "Well known Company"
#deid.SetByteValue( methodstr, gdcm.VL(len(methodstr)) )
deid.SetByteValue(methodstr, gdcm.VL(len(methodstr)))
ds.Insert(deid)
#w = gdcm.Writer()
#w.SetFileName( outfilename )
#w.SetFile( r.GetFile() )
#sucess = w.Write()
return sucess
def create_data_element(dicom_dataset):
"""Create a gdcm.DataElement containing PixelData from a FileDataset
Parameters
----------
dicom_dataset : FileDataset
Returns
-------
gdcm.DataElement
Converted PixelData element
"""
data_element = gdcm.DataElement(gdcm.Tag(0x7fe0, 0x0010))
if dicom_dataset.file_meta.TransferSyntaxUID.is_compressed:
if getattr(dicom_dataset, 'NumberOfFrames', 1) > 1:
pixel_data_sequence = pydicom.encaps.decode_data_sequence(
dicom_dataset.PixelData)
else:
pixel_data_sequence = [
pydicom.encaps.defragment_data(dicom_dataset.PixelData)
]
fragments = gdcm.SequenceOfFragments.New()
for pixel_data in pixel_data_sequence:
fragment = gdcm.Fragment()
fragment.SetByteStringValue(pixel_data)
fragments.AddFragment(fragment)
data_element.SetValue(fragments.__ref__())
else:
data_element.SetByteStringValue(dicom_dataset.PixelData)
return data_element
def create_data_element(dicom_dataset):
"""Return a ``gdcm.DataElement`` for the *Pixel Data*.
Parameters
----------
dicom_dataset : dataset.Dataset
The :class:`~pydicom.dataset.Dataset` containing the *Pixel
Data*.
Returns
-------
gdcm.DataElement
The converted *Pixel Data* element.
"""
data_element = gdcm.DataElement(gdcm.Tag(0x7fe0, 0x0010))
if dicom_dataset.file_meta.TransferSyntaxUID.is_compressed:
if getattr(dicom_dataset, 'NumberOfFrames', 1) > 1:
pixel_data_sequence = pydicom.encaps.decode_data_sequence(
dicom_dataset.PixelData)
else:
pixel_data_sequence = [
pydicom.encaps.defragment_data(dicom_dataset.PixelData)
]
fragments = gdcm.SequenceOfFragments.New()
for pixel_data in pixel_data_sequence:
fragment = gdcm.Fragment()
fragment.SetByteStringValue(pixel_data)
fragments.AddFragment(fragment)
data_element.SetValue(fragments.__ref__())
else:
data_element.SetByteStringValue(dicom_dataset.PixelData)
return data_element
def series(request, series_iuid):
series_iuid_tag = gdcm.Tag(0x20, 0xE)
series_iuid_element = gdcm.DataElement(series_iuid_tag)
series_iuid_element.SetByteValue(str(series_iuid),
gdcm.VL(len(series_iuid)))
instance_uid_tag = gdcm.Tag(0x8, 0x18)
instance_uid_element = gdcm.DataElement(instance_uid_tag)
instance_number_tag = gdcm.Tag(0x20, 0x13)
instance_number_element = gdcm.DataElement(instance_number_tag)
ds = gdcm.DataSet()
ds.Insert(series_iuid_element)
ds.Insert(instance_uid_element)
ds.Insert(instance_number_element)
cnf = gdcm.CompositeNetworkFunctions()
instance_query = cnf.ConstructQuery(gdcm.eStudyRootType, gdcm.eImage, ds)
ret = gdcm.DataSetArrayType()
cnf.CFind(settings.SC_DICOM_SERVER, settings.SC_DICOM_PORT, instance_query,
ret, 'GDCM_PYTHON', settings.AET)
sorted_ret = sorted(
ret,
key=lambda x: int(str(
x.GetDataElement(instance_number_tag).GetValue())))
response = [
str(x.GetDataElement(instance_uid_tag).GetValue()) for x in sorted_ret
]
json_response = json.dumps(response)
if request.GET.has_key('callback'):
json_response = "(function(){%s(%s);})();" % (request.GET['callback'],
json_response)
return HttpResponse(json_response, content_type="application/json")
def construct_dataset(self, dic_keys, dataset_rsp=None):
#fill dataset
dataset = gdcm.DataSet()
for tags in dic_keys:
group = tags[0]
element = tags[1]
de = gdcm.DataElement(gdcm.Tag(group, element))
if dataset_rsp and group == 0x0020 and element == 0x000D:
de = dataset_rsp.GetDataElement(gdcm.Tag(group, element))
value = str(de.GetByteValue())
else:
value = dic_keys[tags]
if value:
value_length = len(value)
de.SetByteValue(value, gdcm.VL(value_length))
#de.SetVR(gdcm.VR(gdcm.VR.PN))
dataset.Insert(de)
return dataset
def create_data_element(ds: "Dataset") -> "DataElement":
"""Return a ``gdcm.DataElement`` for the *Pixel Data*.
Parameters
----------
ds : dataset.Dataset
The :class:`~pydicom.dataset.Dataset` containing the *Pixel
Data*.
Returns
-------
gdcm.DataElement
The converted *Pixel Data* element.
"""
file_meta: "FileMetaDataset" = ds.file_meta # type: ignore[has-type]
tsyntax = cast(UID, file_meta.TransferSyntaxUID)
data_element = gdcm.DataElement(gdcm.Tag(0x7fe0, 0x0010))
if tsyntax.is_compressed:
if getattr(ds, 'NumberOfFrames', 1) > 1:
pixel_data_sequence = (
pydicom.encaps.decode_data_sequence(ds.PixelData)
)
else:
pixel_data_sequence = [
pydicom.encaps.defragment_data(ds.PixelData)
]
fragments = gdcm.SequenceOfFragments.New()
for pixel_data in pixel_data_sequence:
fragment = gdcm.Fragment()
fragment.SetByteStringValue(pixel_data)
fragments.AddFragment(fragment)
data_element.SetValue(fragments.__ref__())
else:
data_element.SetByteStringValue(ds.PixelData)
return data_element
def get_query_and_level(self, dic_keys):
"""Esta funcion retorna un dataset con los maching key y return key y
el nivel de consulta QR"""
# Estos diccionarios pueden estar en ficheros
level_patient = {
"PatientName": (0x0010, 0x0010),
"PatientID": (0x0010, 0x0020),
"PatientSex": (0x0010, 0x0040),
"PatientAge": (0x0010, 0x1010),
"PatientBirthDate": (0010, 0030)
}
level_study = {
"StudyDescription": (0x0008, 0x1030),
"StudyDate": (0x0008, 0x0020),
"StudyTime": (0x0008, 0x0030),
"StudyInstanceUID": (0x0020, 0x000D),
"NumberStudyRelatedInstances": (0x0020, 0x1208)
}
level_series = {
"SeriesInstanceUID": (0x0020, 0x000E),
"Modality": (0x0008, 0x0060),
"SeriesDate": (0x0008, 0x0021),
"SeriesTime": (0x0008, 0x0031),
"NumberSeriesRelatedInstances": (0x0020, 0x1209)
}
level_image = {
"SopInstanceUID": (0x0008, 0x0018),
"InstanceNumber": (0x0020, 0x0013),
"SopClassUID": (0x0008, 0x0016)
}
alias_tags = {}
alias_tags.update(level_patient)
alias_tags.update(level_study)
alias_tags.update(level_series)
alias_tags.update(level_image)
query_level = -1
for attr_key in dic_keys:
value = dic_keys[attr_key]
if attr_key in level_image:
if value:
query_level = gdcm.eImageOrFrame
break
elif attr_key in level_patient:
if value and query_level < gdcm.ePatient:
query_level = gdcm.ePatient
elif attr_key in level_study:
if value and query_level < gdcm.eStudy:
query_level = gdcm.eStudy
elif attr_key in level_series:
if value and query_level < gdcm.eSeries:
query_level = gdcm.eSeries
else:
raise Exception("Invaliud Tag")
keys_dataset = gdcm.DataSet()
#fill dataset
for attr_key in dic_keys:
group = alias_tags[attr_key][0]
element = alias_tags[attr_key][1]
de = gdcm.DataElement(gdcm.Tag(group, element))
value = dic_keys[attr_key]
if value:
value_length = len(value)
de.SetByteValue(value, gdcm.VL(value_length))
#de.SetVR(gdcm.VR(gdcm.VR.PN))
keys_dataset.Insert(de)
return (query_level, keys_dataset)
def RunCFind(self):
tags = [(0x0010, 0x0010), (0x0010, 0x1010), (0x0010,0x0040), (0x0008,0x1030),\
(0x0008,0x0060), (0x0008,0x0022), (0x0008,0x0080), (0x0010,0x0030),\
(0x0008,0x0050), (0x0008,0x0090), (0x0008,0x103E), (0x0008,0x0033),\
(0x0008,0x0032), (0x0020,0x000d)]
ds = gdcm.DataSet()
for tag in tags:
tg = gdcm.Tag(tag[0], tag[1])
de = gdcm.DataElement(tg)
if self.search_type == 'patient' and tag == (0x0010, 0x0010):
bit_size = len(self.search_word) + 1
de.SetByteValue(str(self.search_word + '*'), gdcm.VL(bit_size))
else:
de.SetByteValue('*', gdcm.VL(1))
ds.Insert(de)
cnf = gdcm.CompositeNetworkFunctions()
theQuery = cnf.ConstructQuery(gdcm.ePatientRootType,
gdcm.eImageOrFrame, ds)
ret = gdcm.DataSetArrayType()
cnf.CFind(self.address, int(self.port), theQuery, ret, self.aetitle,\
self.aetitle_call)
patients = {}
exist_images = False
c = 0
for i in range(0, ret.size()):
patient_id = str(ret[i].GetDataElement(gdcm.Tag(
0x0010, 0x0020)).GetValue())
serie_id = str(ret[i].GetDataElement(gdcm.Tag(0x0020,
0x000e)).GetValue())
if not (patient_id in patients.keys()):
patients[patient_id] = {}
if not (serie_id in patients[patient_id]):
rt = ret[i]
name = self.GetValueFromDICOM(rt, (0x0010, 0x0010))
age = self.GetValueFromDICOM(rt, (0x0010, 0x1010))
gender = self.GetValueFromDICOM(rt, (0x0010, 0x0040))
study_description = self.GetValueFromDICOM(
rt, (0x0008, 0x1030))
modality = self.GetValueFromDICOM(rt, (0x0008, 0x0060))
institution = self.GetValueFromDICOM(rt, (0x0008, 0x0080))
date_of_birth = utils.format_date(
self.GetValueFromDICOM(rt, (0x0010, 0x0030)))
acession_number = self.GetValueFromDICOM(rt, (0x0008, 0x0050))
ref_physician = self.GetValueFromDICOM(rt, (0x0008, 0x0090))
serie_description = self.GetValueFromDICOM(
rt, (0x0008, 0x103E))
acquisition_time = utils.format_time(
self.GetValueFromDICOM(rt, (0x0008, 0x0032)))
acquisition_date = utils.format_date(
self.GetValueFromDICOM(rt, (0x0008, 0x0022)))
teste = self.GetValueFromDICOM(rt, (0x0020, 0x000d))
patients[patient_id][serie_id] = {'name':name, 'age':age, 'gender':gender,\
'study_description':study_description,\
'modality':modality, \
'acquisition_time':acquisition_time,\
'acquisition_date':acquisition_date,\
'institution':institution,\
'date_of_birth':date_of_birth,\
'acession_number':acession_number,\
'ref_physician':ref_physician,\
'serie_description':serie_description}
patients[patient_id][serie_id]['n_images'] = 1
else:
patients[patient_id][serie_id]['n_images'] += 1
return patients
ds = reader.GetFile().GetDataSet() #print ds # (2005,1409) DS 4 0.0 # (2005,140a) DS 16 1.52283272283272 # (2005,0014) LO 26 Philips MR Imaging DD 005 tag1 = gdcm.PrivateTag(0x2005, 0x09, "Philips MR Imaging DD 005") tag2 = gdcm.PrivateTag(0x2005, 0x0a, "Philips MR Imaging DD 005") print tag1 print tag2 # make sure to do a copy, we want the private tag to remain # otherwise gdcm gives us a reference el1 = gdcm.DataElement(ds.GetDataElement(tag1)) print el1 el2 = gdcm.DataElement(ds.GetDataElement(tag2)) print el2 # (0028,1052) DS [-1000] # 6, 1 RescaleIntercept # (0028,1053) DS [1] # 2, 1 RescaleSlope el1.SetTag(gdcm.Tag(0x0028, 0x1052)) el2.SetTag(gdcm.Tag(0x0028, 0x1053)) ds.Insert(el1) ds.Insert(el2) w = gdcm.Writer() w.SetCheckFileMetaInformation(False)
if __name__ == "__main__":
file1 = sys.argv[1]
file2 = sys.argv[2]
r = gdcm.Reader()
r.SetFileName( file1 )
if not r.Read():
sys.exit(1)
f = r.GetFile()
ds = f.GetDataSet()
#tsis = gdcm.Tag(0x0008,0x2112) # SourceImageSequence
# Create a dataelement
de = gdcm.DataElement(gdcm.Tag(0x0010, 0x2180))
de.SetByteStringValue("Occupation")
de.SetVR(gdcm.VR(gdcm.VR.SH))
# Create an item
it=gdcm.Item()
it.SetVLToUndefined() # Needed to not popup error message
#it.InsertDataElement(de)
nds=it.GetNestedDataSet()
nds.Insert(de)
# Create a Sequence
sq=gdcm.SequenceOfItems().New()
sq.SetLengthToUndefined()
sq.AddItem(it)
"""
import sys
import gdcm
if __name__ == "__main__":
file1 = sys.argv[1]
file2 = sys.argv[2]
r = gdcm.Reader()
r.SetFileName(file1)
if not r.Read():
sys.exit(1)
f = r.GetFile()
ds = f.GetDataSet()
# Create a dataelement
de = gdcm.DataElement(gdcm.Tag(0x0051, 0x1011))
de.SetByteStringValue("p2")
de.SetVR(gdcm.VR(gdcm.VR.SH))
ds.Insert(de)
w = gdcm.Writer()
w.SetFile(f)
w.SetFileName(file2)
if not w.Write():
sys.exit(1)
"""
This example shows how one can use the gdcm.CompositeNetworkFunctions class
for executing a C-FIND query
It will print the list of patient name found
Usage:
python FindAllPatientName.py
"""
import gdcm
# Patient Name
tag = gdcm.Tag(0x10, 0x10)
de = gdcm.DataElement(tag)
# Search all patient name where string match 'F*'
de.SetByteValue('F*', gdcm.VL(2))
ds = gdcm.DataSet()
ds.Insert(de)
cnf = gdcm.CompositeNetworkFunctions()
theQuery = cnf.ConstructQuery(gdcm.ePatientRootType, gdcm.ePatient, ds)
#print theQuery.ValidateQuery()
# prepare the variable for output
ret = gdcm.DataSetArrayType()
def add(self, tag, value=""):
self.dataelement = gdcm.DataElement(tag)
self.dataelement.SetByteValue(value, gdcm.VL(len(value)))
self.dataset.Insert(self.dataelement)
return self
def _create_gdcm_image(src: bytes, **kwargs: Any) -> "gdcm.Image":
"""Return a gdcm.Image from the `src`.
Parameters
----------
src : bytes
The raw image frame data to be encoded.
**kwargs
Required parameters:
* `rows`: int
* `columns`: int
* `samples_per_pixel`: int
* `number_of_frames`: int
* `bits_allocated`: int
* `bits_stored`: int
* `pixel_representation`: int
* `photometric_interpretation`: str
Returns
-------
gdcm.Image
An Image containing the `src` as a single uncompressed frame.
"""
rows = kwargs['rows']
columns = kwargs['columns']
samples_per_pixel = kwargs['samples_per_pixel']
number_of_frames = kwargs['number_of_frames']
pixel_representation = kwargs['pixel_representation']
bits_allocated = kwargs['bits_allocated']
bits_stored = kwargs['bits_stored']
photometric_interpretation = kwargs['photometric_interpretation']
pi = gdcm.PhotometricInterpretation.GetPIType(photometric_interpretation)
# GDCM's null photometric interpretation gets used for invalid values
if pi == gdcm.PhotometricInterpretation.PI_END:
raise ValueError(
"An error occurred with the 'gdcm' plugin: invalid photometric "
f"interpretation '{photometric_interpretation}'")
# `src` uses little-endian byte ordering
ts = gdcm.TransferSyntax.ImplicitVRLittleEndian
image = gdcm.Image()
image.SetNumberOfDimensions(2)
image.SetDimensions((columns, rows, 1))
image.SetPhotometricInterpretation(gdcm.PhotometricInterpretation(pi))
image.SetTransferSyntax(gdcm.TransferSyntax(ts))
pixel_format = gdcm.PixelFormat(samples_per_pixel, bits_allocated,
bits_stored, bits_stored - 1,
pixel_representation)
image.SetPixelFormat(pixel_format)
if samples_per_pixel > 1:
# Default `src` is planar configuration 0 (i.e. R1 G1 B1 R2 G2 B2)
image.SetPlanarConfiguration(0)
# Add the Pixel Data element and set the value to `src`
elem = gdcm.DataElement(gdcm.Tag(0x7FE0, 0x0010))
elem.SetByteStringValue(src)
image.SetDataElement(elem)
return cast("gdcm.Image", image)
import sys,os if __name__ == "__main__": r = gdcm.Reader() # Will require Testing... dataroot = gdcm.Testing.GetDataRoot() filename = os.path.join( dataroot, '012345.002.050.dcm' ) r.SetFileName( filename ) r.Read() f = r.GetFile() ds = f.GetDataSet() uid = "1.2.840.10008.5.1.4.1.1.66" # f = gdcm.File() # ds = f.GetDataSet() de = gdcm.DataElement( gdcm.Tag(0x0008,0x0016) ) de.SetByteStringValue( uid ) vr = gdcm.VR( gdcm.VR.UI ) de.SetVR( vr ) ds.Replace( de ) ano = gdcm.Anonymizer() ano.SetFile( r.GetFile() ) ano.RemovePrivateTags() ano.RemoveGroupLength() taglist = [ gdcm.Tag(0x0008,0x0008), gdcm.Tag(0x0008,0x0022), gdcm.Tag(0x0008,0x0032), gdcm.Tag(0x0008,0x2111), gdcm.Tag(0x0008,0x1150),
print ir.GetDimension(0)
print ir.GetDimension(1)
print "Dims:", dims
# Just for fun:
dircos = ir.GetDirectionCosines()
t = gdcm.Orientation.GetType(tuple(dircos))
l = gdcm.Orientation.GetLabel(t)
print "Orientation label:", l
image.SetDimension(0, ir.GetDimension(0))
image.SetDimension(1, ir.GetDimension(1))
pixeltype = ir.GetPixelFormat()
image.SetPixelFormat(pixeltype)
pi = ir.GetPhotometricInterpretation()
image.SetPhotometricInterpretation(pi)
pixeldata = gdcm.DataElement(gdcm.Tag(0x7fe0, 0x0010))
str1 = ir.GetBuffer()
#print ir.GetBufferLength()
pixeldata.SetByteStringValue(str1)
image.SetDataElement(pixeldata)
w.SetFileName(file2)
w.SetFile(r.GetFile())
w.SetImage(image)
if not w.Write():
sys.exit(1)
def _rle_encode(src: bytes, **kwargs: Any) -> bytes:
"""Return RLE encoded image data from `src`.
Parameters
----------
src : bytes
The raw image frame data to be encoded.
**kwargs
Required parameters:
* `rows`: int
* `columns`: int
* `samples_per_pixel`: int
* `number_of_frames`: int
* `bits_allocated`: int
* `bits_stored`: int
* `pixel_representation`: int
* `photometric_interpretation`: str
Returns
-------
bytes
The encoded image data.
"""
# Check the parameters are valid for RLE encoding with GDCM
rows = kwargs['rows']
columns = kwargs['columns']
samples_per_pixel = kwargs['samples_per_pixel']
number_of_frames = kwargs['number_of_frames']
pixel_representation = kwargs['pixel_representation']
bits_allocated = kwargs['bits_allocated']
bits_stored = kwargs['bits_stored']
photometric_interpretation = kwargs['photometric_interpretation']
# Bug up to v3.0.9 (Apr 2021) in handling 32-bit, 3 sample/px data
gdcm_version = [int(c) for c in gdcm.Version.GetVersion().split('.')]
if gdcm_version < [3, 0, 10]:
if bits_allocated == 32 and samples_per_pixel == 3:
raise RuntimeError(
"The 'gdcm' plugin is unable to RLE encode 32-bit, 3 "
"samples/px data with GDCM v3.0.9 or older"
)
if bits_allocated > 32:
raise ValueError(
f"The 'gdcm' plugin is unable to encode {bits_allocated}-bit data"
)
# Create a gdcm.Image with the uncompressed `src` data
pi = gdcm.PhotometricInterpretation.GetPIType(
photometric_interpretation
)
# GDCM's null photometric interpretation gets used for invalid values
if pi == gdcm.PhotometricInterpretation.PI_END:
raise ValueError(
"An error occurred with the 'gdcm' plugin: invalid photometric "
f"interpretation '{photometric_interpretation}'"
)
# `src` uses little-endian byte ordering
ts = gdcm.TransferSyntax.ImplicitVRLittleEndian
# Must use ImageWriter().GetImage() to create a gdcmImage
# also have to make sure `writer` doesn't go out of scope
writer = gdcm.ImageWriter()
image = writer.GetImage()
image.SetNumberOfDimensions(2)
image.SetDimensions((columns, rows, 1))
image.SetPhotometricInterpretation(
gdcm.PhotometricInterpretation(pi)
)
image.SetTransferSyntax(gdcm.TransferSyntax(ts))
pixel_format = gdcm.PixelFormat(
samples_per_pixel,
bits_allocated,
bits_stored,
bits_stored - 1,
pixel_representation
)
image.SetPixelFormat(pixel_format)
if samples_per_pixel > 1:
# Default `src` is planar configuration 0 (i.e. R1 G1 B1 R2 G2 B2)
image.SetPlanarConfiguration(0)
# Add the Pixel Data element and set the value to `src`
elem = gdcm.DataElement(gdcm.Tag(0x7FE0, 0x0010))
elem.SetByteStringValue(src)
image.SetDataElement(elem)
# Converts an image to match the set transfer syntax
converter = gdcm.ImageChangeTransferSyntax()
# Set up the converter with the intended transfer syntax...
rle = gdcm.TransferSyntax.GetTSType(kwargs['transfer_syntax_uid'])
converter.SetTransferSyntax(gdcm.TransferSyntax(rle))
# ...and image to be converted
converter.SetInput(image)
# Perform the conversion, returns bool
# 'PALETTE COLOR' and a lossy transfer syntax will return False
result = converter.Change()
if not result:
raise RuntimeError(
"An error occurred with the 'gdcm' plugin: "
"ImageChangeTransferSyntax.Change() returned a failure result"
)
# A new gdcmImage with the converted pixel data element
image = converter.GetOutput()
# The element's value is the encapsulated encoded pixel data
seq = image.GetDataElement().GetSequenceOfFragments()
# RLECodec::Code() uses only 1 fragment per frame
if seq is None or seq.GetNumberOfFragments() != 1:
# Covers both no sequence and unexpected number of fragments
raise RuntimeError(
"An error occurred with the 'gdcm' plugin: unexpected number of "
"fragments found in the 'Pixel Data'"
)
fragment = seq.GetFragment(0).GetByteValue().GetBuffer()
return cast(bytes, fragment.encode("utf-8", "surrogateescape"))
