>(rescale->GetOutput(), "debug.nrrd");`?
What exactly do you mean by that?
> [@dzenanz](#):
>
> It is better to visualize in Slicer, as ITK-SNAP converts intensities to short internally.
The same visual errors occur when I open the images with slicer, unfortunately.
Thank you again!
---
### Author:  [@dzenanz](https://discourse.itk.org/u/dzenanz)
#### Post date: [February 10, 2022, 6:29pm UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/11 "2022-02-10T18:29:18Z")
> [@Keyn34](#):
>
> The same visual errors occur when I open the images with slicer
When you examine the images with Slicer, that eliminates ITK-SNAP’s reduction to 16-bit signed as a potential source of errors.
What I meant by `itk.WriteImage` is to check how the image looks like after intensity rescaling, but before converting/writing it to DICOM format.
---
### Author:  [@Keyn34](https://discourse.itk.org/u/Keyn34)
#### Post date: [February 11, 2022, 9:56am UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/12 "2022-02-11T09:56:53Z")
Thank you @dzenanz for clearing that up for me!
Good, so it is clear that the images themselves are cropped when it comes to their intensity.
I got it working now with the rescaler as well, which confirms that additionally. The result is shown below:
The speckles are gone, and the image looks good now. The issue I face now is that the intensity values are altered (obviously) and not the same anymore between the two datasets for the same cursor position. There is no way to retain the intensities and do the conversion without the speckle issue, I suppose?
Also, when I do the following:
```auto
std::cout << "Input image intensity range is " << rescaler->GetInputMinimum() << " to " << rescaler->GetInputMaximum() << std::endl;
```
I get as output: `Input image intensity range is 3.40282e+38 to 0`, which is kinda unexpected.
Thanks!
---
### Author:  [@dzenanz](https://discourse.itk.org/u/dzenanz)
#### Post date: [February 11, 2022, 1:50pm UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/13 "2022-02-11T13:50:29Z")
> [@Keyn34](#):
>
> `rescaler->GetInputMinimum()`
This will not work properly before `rescaler->Update()`, which might be called implicitly via `writer->Update()`.
> [@Keyn34](#):
>
> retain the intensities and do the conversion
It is probably possible, but you must not use rescaling. Going via setting DICOM tags rescale slope (and rescale intercept) is your best bet. Whoever wrote [this page](http://gdcm.sourceforge.net/wiki/index.php/Pixel_Type) in 2008 thought that writing float pixels with GDCM was impossible. I am not sure whether that has changed.
But looking at [the DICOM standard](https://dicom.nema.org/medical/dicom/2017c/output/chtml/part03/sect_C.7.6.25.html), it should be possible. You might have to use [DCMTK](https://itk.org/Doxygen/html/group__ITKDCMTK.html) instead of GDCM.
---
### Author:  [@Keyn34](https://discourse.itk.org/u/Keyn34)
#### Post date: [February 12, 2022, 8:57pm UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/14 "2022-02-12T20:57:10Z")
As far as I know, writing float with GDCM is still not possible. At least for me, it crashes every time I try to set the pixel type to float.
I tried to build ITK with DCMTK, but I get the same errors as in [here](https://github.com/InsightSoftwareConsortium/ITK/issues/2872). Is there any workaround, building DCMTK by itself, or applying the “patch” manually?
Edit: It was possible to first build DCMTK and afterwords set the flag in ITK to use system DCMTK.
Are there any examples on writing DICOM with DCMTK as ImageIO within and Series Writer? Because I tried replacing the GDCM IO by DCMTK IO and now no files get written.
Thanks!
---
### Author:  [@Keyn34](https://discourse.itk.org/u/Keyn34)
#### Post date: [February 14, 2022, 8:28am UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/15 "2022-02-14T08:28:25Z")
@zivy, sorry to bump you again directly, but I also found [this post](https://discourse.itk.org/t/unable-to-write-dicom-file-with-double-values/2299/10) about the same issue, where the intercept and slope won’t get updated. Maybe this issue wasn’t resolved till now?
Thank you again!
---
### Author:  [@zivy](https://discourse.itk.org/u/zivy)
#### Post date: [February 14, 2022, 1:45pm UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/16 "2022-02-14T13:45:51Z")
Hi @Keyn34,
SimpleITK/ITK can write float pixels to DICOM via GDCM using float values for slope, intercept. The [DicomSeriesFromArray](https://simpleitk.readthedocs.io/en/master/link_DicomSeriesFromArray_docs.html) example illustrates this:
```auto
python DicomSeriesFromArray.py output_dir float64
```
Can you share the original nifti file? If yes, I’ll try and see what settings enable saving it as DICOM with float values, what modifications need to be done to your current SimpleITK script. Once we figure that out you’ll be able to set your ITK code accordingly.
---
### Author:  [@Keyn34](https://discourse.itk.org/u/Keyn34)
#### Post date: [February 14, 2022, 2:08pm UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/17 "2022-02-14T14:08:19Z")
@zivy,
Thank you so much. I send you a private message with a download link to access the nifti file.
---
### Author:  [@zivy](https://discourse.itk.org/u/zivy)
#### Post date: [February 14, 2022, 6:00pm UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/18 "2022-02-14T18:00:17Z")
Hello @Keyn34,
The rescale slope/intercept in the original script were not appropriate for your data. Please try the following script (does not retain the exact values, but nearly, you’ll have to play with this if you want an exact copy):
```auto
import SimpleITK as sitk
import sys
import time
import os
def writeSlices(series_tag_values, new_img, out_dir, i):
image_slice = new_img[:, :, i]
# Tags shared by the series.
list(map(lambda tag_value: image_slice.SetMetaData(tag_value[0],
tag_value[1]),
series_tag_values))
# Slice specific tags.
# Instance Creation Date
image_slice.SetMetaData("0008|0012", time.strftime("%Y%m%d"))
# Instance Creation Time
image_slice.SetMetaData("0008|0013", time.strftime("%H%M%S"))
# Setting the type to CT so that the slice location is preserved and
# the thickness is carried over.
image_slice.SetMetaData("0008|0060", "PT")
# (0020, 0032) image position patient determines the 3D spacing between
# slices.
# Image Position (Patient)
image_slice.SetMetaData("0020|0032", '\\'.join(
map(str, new_img.TransformIndexToPhysicalPoint((0, 0, i)))))
# Instance Number
image_slice.SetMetaData("0020,0013", str(i))
# Write to the output directory and add the extension dcm, to force
# writing in DICOM format.
writer.SetFileName(os.path.join(out_dir, str(i) + '.dcm'))
writer.Execute(image_slice)
if len(sys.argv) < 3:
print("Usage: python " + __file__ + " ")
sys.exit(1)
new_img = sitk.ReadImage(sys.argv[1])
# Write the 3D image as a series
# IMPORTANT: There are many DICOM tags that need to be updated when you modify
# an original image. This is a delicate opration and requires
# knowledge of the DICOM standard. This example only modifies some.
# For a more complete list of tags that need to be modified see:
# http://gdcm.sourceforge.net/wiki/index.php/Writing_DICOM
# If it is critical for your work to generate valid DICOM files,
# It is recommended to use David Clunie's Dicom3tools to validate
# the files:
# http://www.dclunie.com/dicom3tools.html
writer = sitk.ImageFileWriter()
# Use the study/series/frame of reference information given in the meta-data
# dictionary and not the automatically generated information from the file IO
writer.KeepOriginalImageUIDOn()
modification_time = time.strftime("%H%M%S")
modification_date = time.strftime("%Y%m%d")
# Copy some of the tags and add the relevant tags indicating the change.
# For the series instance UID (0020|000e), each of the components is a number,
# cannot start with zero, and separated by a '.' We create a unique series ID
# using the date and time. Tags of interest:
direction = new_img.GetDirection()
series_tag_values = [
("0008|0031", modification_time), # Series Time
("0008|0021", modification_date), # Series Date
("0008|0008", "DERIVED\\SECONDARY"), # Image Type
("0020|000e", "1.2.826.0.1.3680043.2.1125."
+ modification_date + ".1" + modification_time), # Series Instance UID
("0020|0037", '\\'.join(map(str, (direction[0], direction[3], direction[6],
direction[1], direction[4],
direction[7])))), # Image Orientation
# (Patient)
("0008|103e", "Created-SimpleITK") # Series Description
]
# If we want to write floating point values, we need to use the rescale
# slope, "0028|1053", to select the number of digits we want to keep. We
# also need to specify additional pixel storage and representation
# information.
arr_view = sitk.GetArrayViewFromImage(new_img)
i_min = arr_view.min()
i_max = arr_view.max()
# the bulk intensity data range is [-2^15,+2^15], stored using 2's complement
# we rescale the actual data to fit in this discrete range.
rescale_slope = (i_min-i_max)/65536
rescale_intercept = i_min
series_tag_values = series_tag_values + [
('0028|1053', str(rescale_slope)), # rescale slope
('0028|1052', str(rescale_intercept)), # rescale intercept
('0028|0100', '16'), # bits allocated
('0028|0101', '16'), # bits stored,
('0028|0102', '15'), # high bit
('0028|0103', '1')] # pixel representation
# Write slices to output directory
list(map(lambda i: writeSlices(series_tag_values, new_img, sys.argv[2], i),
range(new_img.GetDepth())))
sys.exit(0)
```
---
### Author:  [@Keyn34](https://discourse.itk.org/u/Keyn34)
#### Post date: [February 15, 2022, 9:30am UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/19 "2022-02-15T09:30:21Z")
Thank you @zivy, I just tested your script with the slight modification to just take the first volume for a quick run and the results look very good already. Really thank you very much for that - very helpful.
The remaining question would be how to apply the rescale and intercept to the written series within ITK for C++? Because here I still face the issue that the slope and intercept do not get applied.
---
### Author:  [@zivy](https://discourse.itk.org/u/zivy)
#### Post date: [February 15, 2022, 1:59pm UTC](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798/20 "2022-02-15T13:59:47Z")
Hello @Keyn34,
Happy to hear that you’re closer to solving the problem.
So, I don’t think there is much you need to do beyond a correct configuration of the meta-data information. Going over the C++ snippets above I already identified one difference. The C++ code has PixelRepresentation as 0 and the SimpleITK code has it as 1.
My advice is that you run the SimpleITK code and print out the contents of the meta-data dictionary and do the same for the C++ code. Compare the two and you’ll see what you need to set to get the C++ code to work.
[Next page](https://discourse.itk.org/t/nifti-to-dicom-conversion-introduces-negative-intensities/4798.md?page=2)