Code Recipes

Opening a DICOM file object

Used functions

• dicom::open_dicomfile()
• dicom::open_dicomfile_from_memory()

Opening a DICOM file object from a file

dicom::dicomfile *df;

df = dicom::open_dicomfile("img001.dcm");
if (!df) {
        printf("%s\n", dicom::get_error_message());
    goto __dicom_open_error__; // process error
}

// do something with dicomfile object

dicom::close_dicomfile(df);

import dicom
   
df = dicom.open_dicomfile('img001.dcm')
if df:
        pass # Do something with dicomfile object
else:
        print dicom.get_error_message()

# You don't need to close_dicomfile().
# If you want to remove object explicitly, use 'del'.

Opening a DICOM file object from memory buffer

FILE *fp;
dicom::dicomfile *df;
char *membuf;
long membufsiz;
   
fp = fopen("img001.dcm", "rb");
if (!fp) goto __file_error__; // process error
   
fseek(fp, 0, SEEK_END);
membufsiz = ftell(fp);
fseek(fp, 0, SEEK_SET);
   
membuf = (char *)malloc(membufsiz);
if (!membuf) goto __memory_error__; // process error 
   
fread(membuf, 1, membufsiz, fp);
fclose(fp);

df = dicom::open_dicomfile_from_memory(membuf, membufsiz);
free(membuf);
if (!df) goto __dicom_open_error__; // process error
   
// do something with dicomfile object
   
dicom::close_dicomfile(df);

import dicom
   
fileimage = file('img001.dcm', 'rb').read()
df = dicom.open_dicomfile_from_memory(fileimage)

Get a data element and its value

Used functions

• dicom::dicomfile::get_dataelement()
• dicom::dataset::operator[]
• dicom::dataset::get_dataelement()
• dicom::dataset::operator[]
• dicom::dataelement::is_valid()
• dicom::dataelement::operator bool()

You have to get dicom::dataelement objects before accessing values in a dicom file. A dicom::dicomelement object can be obtained using function dicom::dataset::get_dataelement or dicom::dicomfile::get_dataelement.

dicom::dicomfile *df;
dicom::dataelement *de;
std::string value;
   
// ... open dicomfile
   
// Get a data element that holds study date (0008,0020).
de = df->get_dataelement(0x00080020);
   
// check existence of the data element.
if (de->is_valid()) { 
        // retrieve value
        value = de->to_string();
} else {
        // set value for 'non-exist' data element.
        value = std::string("N/A");
}

You may shorten get dataelement->check existence->get value process into one line.

// to_string() will return "N/A" string if get_dataelement() returns
//   'invalid' or 'non-exist' dataelement.    
value = df->get_dataelement(0x00080020)->to_string("N/A"); 

dicom::dicomfile::get_dataelement takes 'tag value' in several forms. If gggg,eeee mean group and element number of tag in hex form, following forms are acceptable.

• 0xggggeeee
• "0xggggeeee"
• "ggggeeee"
• "ggggeeee.n.ggggeeee"
• "KeyWord"

For example, following forms indicate a data element contains study description

• 0x00081030
• "0x00081030"
• "00081030"
• "StudyDescription"

KeyWords are defined in ftp://medical.nema.org/medical/dicom/2009/09_06pu3.pdf

Get a data element in a nested dataset

If you need to access a data element in a nested dataset, you can use "ggggeeee.n.ggggeeee" form.

dicomfile *df = open_dicomfile("somefile.dcm");
   
dataset *ds;
dataelement *de;
double radionuclide_dose;
   
// get 0th dataset in the dataset sequence at (0054,0016)
// (0054,0016) = Radiopharmaceutical Information Sequence
ds = df->get_dataelement(0x00540016)->dataset_at(0);

if (ds != NULL) {
        // (0018,1074) = RadionuclideTotalDose
        de = ds->get_dataelement(0x00181074);
        radionuclide_dose = de->to_double(0.0);
} else {
        radionuclide_dose = 0.0;
}

Above codes can be shortened using "ggggeeee.n.ggggeeee" form.

radionuclide_dose = df->get_dataelement("00540016.0.00181074")->to_double(0.0);

Functions to get values

A dicom::dataelement objects has several functions name like to_variabletype().

Used functions

• dicom::dataelement::to_int()
• dicom::dataelement::operator int()
• dicom::dataelement::to_int_values_a()
• dicom::dataelement::to_int_values()
• dicom::dataelement::operator std::vector<int>()
• dicom::dataelement::to_double()
• dicom::dataelement::operator double()
• dicom::dataelement::to_double_values_a()
• dicom::dataelement::to_double_values()
• dicom::dataelement::operator std::vector<double>()
• dicom::dataelement::to_string()
• dicom::dataelement::to_string_a()
• dicom::dataelement::raw_value()

dicomfile *df;

/*** get a value in 'int' form ***/

int number_of_slices;
number_of_slices = df->get_dataelement(0x00540081)->to_int(0);
// another equivalent form
number_of_slices = (*df)[0x00540081].to_int(0);
// yet another equivalent form
number_of_slices = (*df)[0x00540081];


/*** get a value in 'real' form ***/

double slice_thickeness
slice_thickenss = df->get_dataelement(0x00180050)->to_double(0.0);
slice_thickness = (*df)[0x00180050].to_double(0.0)
slice_thickness = (*df)[0x00180050];


/*** get multiple 'int' values in a dataelement ***/

int *matrix_values;
int n;
(*df)["AcquisitionMatrix"].to_int_values_a(&matrix_values, &n);
if (matrix_values != NULL) {
        printf("Acquisition Matrix");
        for (int i = 0; i < n; i++)
                printf(" %d", matrix_values[i]);
        free(matrix_values); // user SHOULD free() memories for array!
}

// much simpler codes using std::vector
std::vector<int> matrix_values;
matrix_values =(*df)["AcquisitionMatrix"].to_int_values();
// or
matrix_values =(*df)["AcquisitionMatrix"];


/*** get multiple 'double' values ***/   

double *image_position;
int n;
(*df)["ImagePositionPatient"].to_double_values_a(&image_position, &n);
if (image_position != NULL) {
        printf("Image Patient Position");
        for (int i = 0; i < n; i++)
                printf(" %lf", image_position[i]);
        free(image_position); // user SHOULD free() memories for array!
}

// much simpler codes using std::vector
std::vector<double> image_position;
image_position =(*df)["ImagePositionPatient"].to_double_values();
// or
image_position =(*df)["ImagePositionPatient"];


/*** get string values ***/

char *patient_name;
(*df)["PatientName"].to_string_a(&patient_name);
if (patient_name) {
        printf("Patient name = %s\n", patient_name);
        free(patient_name); // user SHOULD free() memories for array!
} else {
        printf("Patient name is not available\n");
}

// much simpler codes using std::string
std::string patient_name;
patient_name = (*df)["PatientName"].to_string("N/A");
// or
patient_name = (*df)["PatientName"];


/*** get a value in binary form ***/

char *pixeldata;
int pixeldata_len;
df->get_dataelement(0x7fe00010)->raw_value(&pixeldata, &pixeldata_len);
if (pixeldata) {
        // do something with pixel data
        // DO NOT free() pixeldata
}

Get values with Python

df = open_dicomfile("img001")

# get a value in 'int' form

number_of_slices = df.get_dataelement(0x00540081).to_int(0)

# equivalent forms to get 'int' values
number_of_slices = df.get_dataelement(0x00540081).get_value()
number_of_slices = df[0x00540081]

# get a value in 'real' form

slice_thickenss = df.get_dataelement(0x00180050).to_double(0.0)
slice_thickenss = df.get_dataelement(0x00180050).get_value()
slice_thickness = df[0x00180050]
   
# get multiple 'int' values in a dataelement

acq_mat = df.get_dataelement("AcquisitionMatrix").to_int_values()
acq_mat = df.get_dataelement("AcquisitionMatrix").get_value()
acq_mat = df["AcquisitionMatrix"]

# get multiple 'double' values

img_pos = df.get_dataelement("ImagePositionPatient").to_double_values()
img_pos = df.get_dataelement("ImagePositionPatient").get_value()
img_pos = df["ImagePositionPatient"]

# get string values

pat_name = df.get_dataelement("PatientName").to_string()
pat_name = df.get_dataelement("PatientName").to_string("N/A")
pat_name = df["PatientName"]

# get a value in binary form

raw_pixeldata = df.get_dataelement(0x7fe00010).raw_value()

Setting Values

Write to a file

Getting pixel data

Getting pixel data with C++

Used functions

• dicom::dicomfile::get_image_info()
• dicom::dicomfile::copy_pixeldata_to()
• dicom::dicomfile::get_pixeldata_a()

dicomfile *df;

int width, height;
int precision, signedness;
int ncomponents, bytes_per_pixel;
int nframes;

char* pixel_buffer;
int buffer_length; 
int row_step, frame_step;

df = dicom::open_dicomfile("img001");

if (df) {
        df->get_image_info(&width, &height,
                &precision, &signedness,
                &ncomponents, &bytes_per_pixel, &nframes);
        
        if (width) {
                buffer_length = width*bytes_per_pixel*height*nframes;
                pixel_buffer = new char[buffer_length];
                
                row_step = width*bytes_per_pixel;
                frame_step = width*bytes_per_pixel*height;
                copy_pixeldata_to(&pixel_buffer, row_step, frame_step);
                
                /* do something with pixel data */
                
                delete pixel_buffer;
        }
        else {
                printf("Problem in get pixel data from a dicom file.\n");
        }
        
        dicom::close_dicomfile(df);
}
else {
        printf("Error in opening file: %s\n", dicom::get_error_message());
}

Getting pixel data with Python

import numpy

def extract_pixeldata(filename):
        df = dicom.open_dicomfile(filename)
        if not df:
                return None

        width, height, prec, sgnd, ncomps, bpp, nframes = df.get_image_info()
        pixeldata = df.get_pixeldata()
        if not pixeldata:
                return None
        if width*height*prec == 0:
                return None
                
        shape = [height, width]
        if ncomps > 1:
                shape += [ncomps]
        if nframes > 1:
                shape = [nframes] + shape
        
        if prec > 8:
                dtype = numpy.int16 if sgnd else numpy.uint16
        elif prec > 0:
                dtype = numpy.int8 if sgnd else numpy.uint8     
        else:
                return None
                
        ar = numpy.fromstring(pixeldata, dtype=dtype)
        ar.shape = shape
        return ar
        
def extract_pixeldata_much_simpler_version(filename):
        df = dicom.open_dicomfile(file)
        if df:
                return df.to_numpy_array(self)
        else:
                return None

Setting pixel data

Used functions

• dicom::dicomfile::set_pixeldata()