bool LabelSetImageIO::SaveLabelSetImagePreset(const std::string & presetFilename, LabelSetImage::Pointer & inputImage)
{
TiXmlDocument * presetXmlDoc = new TiXmlDocument();
TiXmlDeclaration * decl = new TiXmlDeclaration( "1.0", "", "" );
presetXmlDoc->LinkEndChild( decl );
TiXmlElement * presetElement = new TiXmlElement("LabelSetImagePreset");
presetElement->SetAttribute("layers", inputImage->GetNumberOfLayers());
presetXmlDoc->LinkEndChild(presetElement);
for (unsigned int layerIdx=0; layerIdx<inputImage->GetNumberOfLayers(); layerIdx++)
{
TiXmlElement * layerElement = new TiXmlElement("Layer");
layerElement->SetAttribute("index", layerIdx);
layerElement->SetAttribute("labels", inputImage->GetNumberOfLabels(layerIdx));
presetElement->LinkEndChild(layerElement);
for (unsigned int labelIdx=0; labelIdx<inputImage->GetNumberOfLabels(layerIdx); labelIdx++)
{
TiXmlElement * labelAsXml = LabelSetImageIO::GetLabelAsTiXmlElement(inputImage->GetLabel(labelIdx,layerIdx));
layerElement->LinkEndChild(labelAsXml);
}
}
bool wasSaved = presetXmlDoc->SaveFile(presetFilename);
delete presetXmlDoc;
return wasSaved;
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode(Image *original,
const std::string &organName,
const mitk::Color &color)
{
// we NEED a reference image for size etc.
if (!original)
return nullptr;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>());
LabelSetImage::Pointer segmentation = LabelSetImage::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = {original->GetDimension(0), original->GetDimension(1), 1};
segmentation->Initialize(pixelType, 3, dimensions);
segmentation->AddLayer();
}
else
{
segmentation->Initialize(original);
}
mitk::Label::Pointer label = mitk::Label::New();
label->SetName(organName);
label->SetColor(color);
label->SetValue(1);
segmentation->GetActiveLabelSet()->AddLabel(label);
segmentation->GetActiveLabelSet()->SetActiveLabel(1);
unsigned int byteSize = sizeof(mitk::Label::PixelType);
if (segmentation->GetDimension() < 4)
{
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(0));
memset(writeAccess.GetData(), 0, byteSize);
}
else
{
// if we have a time-resolved image we need to set memory to 0 for each time step
for (unsigned int dim = 0; dim < 3; ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
for (unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
{
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(volumeNumber));
memset(writeAccess.GetData(), 0, byteSize);
}
}
if (original->GetTimeGeometry())
{
TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
segmentation->SetTimeGeometry(originalGeometry);
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return nullptr;
}
// Add some DICOM Tags as properties to segmentation image
PropertyList::Pointer dicomSegPropertyList = mitk::DICOMSegmentationPropertyHandler::GetDICOMSegmentationProperties(original->GetPropertyList());
segmentation->GetPropertyList()->ConcatenatePropertyList(dicomSegPropertyList);
mitk::DICOMSegmentationPropertyHandler::GetDICOMSegmentProperties(segmentation->GetActiveLabel(segmentation->GetActiveLayer()));
return CreateSegmentationNode(segmentation, organName, color);
}
std::vector<BaseData::Pointer> LabelSetImageIO::Read()
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
mitkThrow() << "Could not set locale.";
}
}
// begin regular image loading, adapted from mitkItkImageIO
itk::NrrdImageIO::Pointer nrrdImageIO = itk::NrrdImageIO::New();
Image::Pointer image = Image::New();
const unsigned int MINDIM = 2;
const unsigned int MAXDIM = 4;
const std::string path = this->GetLocalFileName();
MITK_INFO << "loading " << path << " via itk::ImageIOFactory... " << std::endl;
// Check to see if we can read the file given the name or prefix
if (path.empty())
{
mitkThrow() << "Empty filename in mitk::ItkImageIO ";
}
// Got to allocate space for the image. Determine the characteristics of
// the image.
nrrdImageIO->SetFileName(path);
nrrdImageIO->ReadImageInformation();
unsigned int ndim = nrrdImageIO->GetNumberOfDimensions();
if (ndim < MINDIM || ndim > MAXDIM)
{
MITK_WARN << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D.";
ndim = MAXDIM;
}
itk::ImageIORegion ioRegion(ndim);
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[MAXDIM];
dimensions[0] = 0;
dimensions[1] = 0;
dimensions[2] = 0;
dimensions[3] = 0;
ScalarType spacing[MAXDIM];
spacing[0] = 1.0f;
spacing[1] = 1.0f;
spacing[2] = 1.0f;
spacing[3] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for (i = 0; i < ndim; ++i)
{
ioStart[i] = 0;
ioSize[i] = nrrdImageIO->GetDimensions(i);
if (i<MAXDIM)
{
dimensions[i] = nrrdImageIO->GetDimensions(i);
spacing[i] = nrrdImageIO->GetSpacing(i);
if (spacing[i] <= 0)
spacing[i] = 1.0f;
}
if (i<3)
{
origin[i] = nrrdImageIO->GetOrigin(i);
}
}
ioRegion.SetSize(ioSize);
ioRegion.SetIndex(ioStart);
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
nrrdImageIO->SetIORegion(ioRegion);
void* buffer = new unsigned char[nrrdImageIO->GetImageSizeInBytes()];
nrrdImageIO->Read(buffer);
image->Initialize(MakePixelType(nrrdImageIO), ndim, dimensions);
image->SetImportChannel(buffer, 0, Image::ManageMemory);
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3 ? 3 : ndim);
for (i = 0; i < itkDimMax3; ++i)
for (j = 0; j < itkDimMax3; ++j)
matrix[i][j] = nrrdImageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = image->GetSlicedGeometry(0)->GetPlaneGeometry(0);
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
MITK_INFO << slicedGeometry->GetCornerPoint(false, false, false);
MITK_INFO << slicedGeometry->GetCornerPoint(true, true, true);
// re-initialize TimeGeometry
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
image->SetTimeGeometry(timeGeometry);
buffer = NULL;
MITK_INFO << "number of image components: " << image->GetPixelType().GetNumberOfComponents() << std::endl;
const itk::MetaDataDictionary& dictionary = nrrdImageIO->GetMetaDataDictionary();
for (itk::MetaDataDictionary::ConstIterator iter = dictionary.Begin(), iterEnd = dictionary.End();
iter != iterEnd; ++iter)
{
std::string key = std::string("meta.") + iter->first;
if (iter->second->GetMetaDataObjectTypeInfo() == typeid(std::string))
{
std::string value = dynamic_cast<itk::MetaDataObject<std::string>*>(iter->second.GetPointer())->GetMetaDataObjectValue();
image->SetProperty(key.c_str(), mitk::StringProperty::New(value));
}
}
// end regular image loading
LabelSetImage::Pointer output = LabelSetImageConverter::ConvertImageToLabelSetImage(image);
// get labels and add them as properties to the image
char keybuffer[256];
unsigned int numberOfLayers = GetIntByKey(dictionary, "layers");
std::string _xmlStr;
mitk::Label::Pointer label;
for (unsigned int layerIdx = 0; layerIdx < numberOfLayers; layerIdx++)
{
sprintf(keybuffer, "layer_%03d", layerIdx);
int numberOfLabels = GetIntByKey(dictionary, keybuffer);
mitk::LabelSet::Pointer labelSet = mitk::LabelSet::New();
for (int labelIdx = 0; labelIdx < numberOfLabels; labelIdx++)
{
TiXmlDocument doc;
sprintf(keybuffer, "label_%03d_%05d", layerIdx, labelIdx);
_xmlStr = GetStringByKey(dictionary, keybuffer);
doc.Parse(_xmlStr.c_str());
TiXmlElement * labelElem = doc.FirstChildElement("Label");
if (labelElem == 0)
mitkThrow() << "Error parsing NRRD header for mitk::LabelSetImage IO";
label = LoadLabelFromTiXmlDocument(labelElem);
if (label->GetValue() == 0) // set exterior label is needed to hold exterior information
output->SetExteriorLabel(label);
labelSet->AddLabel(label);
labelSet->SetLayer(layerIdx);
}
output->AddLabelSetToLayer(layerIdx, labelSet);
}
MITK_INFO << "...finished!" << std::endl;
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
mitkThrow() << "Could not reset locale!";
}
std::vector<BaseData::Pointer> result;
result.push_back(output.GetPointer());
return result;
}
std::vector<BaseData::Pointer> DICOMSegmentationIO::Read()
{
mitk::LocaleSwitch localeSwitch("C");
LabelSetImage::Pointer labelSetImage;
std::vector<BaseData::Pointer> result;
const std::string path = this->GetLocalFileName();
MITK_INFO << "loading " << path << std::endl;
if (path.empty())
mitkThrow() << "Empty filename in mitk::ItkImageIO ";
try
{
// Get the dcm data set from file path
DcmFileFormat dcmFileFormat;
OFCondition status = dcmFileFormat.loadFile(path.c_str());
if (status.bad())
mitkThrow() << "Can't read the input file!";
DcmDataset *dataSet = dcmFileFormat.getDataset();
if (dataSet == nullptr)
mitkThrow() << "Can't read data from input file!";
// Read the DICOM SEG images (segItkImages) and DICOM tags (metaInfo)
dcmqi::ImageSEGConverter *converter = new dcmqi::ImageSEGConverter();
pair<map<unsigned, ImageType::Pointer>, string> dcmqiOutput = converter->dcmSegmentation2itkimage(dataSet);
map<unsigned, ImageType::Pointer> segItkImages = dcmqiOutput.first;
// For each itk image add a layer to the LabelSetImage output
for (auto &element : segItkImages)
{
// Get the labeled image and cast it to mitkImage
typedef itk::CastImageFilter<itkInternalImageType, itkInputImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(element.second);
castFilter->Update();
Image::Pointer layerImage;
CastToMitkImage(castFilter->GetOutput(), layerImage);
// Get pixel value of the label
itkInternalImageType::ValueType segValue = 1;
typedef itk::ImageRegionIterator<const itkInternalImageType> IteratorType;
// Iterate over the image to find the pixel value of the label
IteratorType iter(element.second, element.second->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
itkInputImageType::PixelType value = iter.Get();
if (value != 0)
{
segValue = value;
break;
}
++iter;
}
dcmqi::JSONSegmentationMetaInformationHandler metaInfo(dcmqiOutput.second.c_str());
metaInfo.read();
MITK_INFO << "Input " << metaInfo.getJSONOutputAsString();
// TODO: Read all DICOM Tags
// Get the label information from segment attributes
vector<map<unsigned, dcmqi::SegmentAttributes *>>::const_iterator segmentIter =
metaInfo.segmentsAttributesMappingList.begin();
map<unsigned, dcmqi::SegmentAttributes *> segmentMap = (*segmentIter);
map<unsigned, dcmqi::SegmentAttributes *>::const_iterator segmentMapIter = (*segmentIter).begin();
dcmqi::SegmentAttributes *segmentAttr = (*segmentMapIter).second;
OFString labelName;
if (segmentAttr->getSegmentedPropertyTypeCodeSequence() != nullptr)
segmentAttr->getSegmentedPropertyTypeCodeSequence()->getCodeMeaning(labelName);
else
{
labelName = std::to_string(segmentAttr->getLabelID()).c_str();
if (labelName.empty())
labelName = "Unnamed";
}
float tmp[3] = {0.0, 0.0, 0.0};
if (segmentAttr->getRecommendedDisplayRGBValue() != nullptr)
{
tmp[0] = segmentAttr->getRecommendedDisplayRGBValue()[0] / 255.0;
tmp[1] = segmentAttr->getRecommendedDisplayRGBValue()[1] / 255.0;
tmp[2] = segmentAttr->getRecommendedDisplayRGBValue()[2] / 255.0;
}
// If labelSetImage do not exists (first image)
if (labelSetImage.IsNull())
{
// Initialize the labelSetImage with the read image
labelSetImage = LabelSetImage::New();
labelSetImage->InitializeByLabeledImage(layerImage);
// Already a label was generated, so set the information to this
Label *activeLabel = labelSetImage->GetActiveLabel(labelSetImage->GetActiveLayer());
activeLabel->SetName(labelName.c_str());
activeLabel->SetColor(Color(tmp));
activeLabel->SetValue(segValue);
}
else
{
// Add a new layer to the labelSetImage. Background label is set automatically
labelSetImage->AddLayer(layerImage);
// Add new label
Label *newLabel = new Label;
newLabel->SetName(labelName.c_str());
newLabel->SetColor(Color(tmp));
newLabel->SetValue(segValue);
labelSetImage->GetLabelSet(labelSetImage->GetActiveLayer())->AddLabel(newLabel);
}
++segmentIter;
}
// Clean up
if (converter != nullptr)
delete converter;
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while reading the DICOM Seg file: " << e.what();
return result;
}
// Set active layer to th first layer of the labelset image
if (labelSetImage->GetNumberOfLayers() > 1 && labelSetImage->GetActiveLayer() != 0)
labelSetImage->SetActiveLayer(0);
result.push_back(labelSetImage.GetPointer());
return result;
}