inline void checkFileForGlobal(const std::string &exodusFilename, const std::string &globalVarName, const double value)
{
Ioss::DatabaseIO *iossDb = Ioss::IOFactory::create("exodus", exodusFilename, Ioss::READ_MODEL, MPI_COMM_WORLD);
Ioss::Region ioRegion(iossDb);
ioRegion.begin_state(1);
ASSERT_TRUE(ioRegion.field_exists(globalVarName));
double valueOnFile = 0.0;
ioRegion.get_field_data(globalVarName, &valueOnFile, sizeof(double));
EXPECT_EQ(value, valueOnFile);
}
inline void checkFileForNodalVarNames(const std::string &exodusFilename, const std::vector<std::string>& nodalVarNames)
{
Ioss::DatabaseIO *iossDb = Ioss::IOFactory::create("exodus", exodusFilename, Ioss::READ_MODEL, MPI_COMM_WORLD);
Ioss::Region ioRegion(iossDb);
Ioss::NodeBlock *nodeBlockAssociatedWithField0 = ioRegion.get_node_blocks()[0];
Ioss::NameList fieldNames;
nodeBlockAssociatedWithField0->field_describe(Ioss::Field::TRANSIENT, &fieldNames);
ASSERT_EQ(nodalVarNames.size(), fieldNames.size());
for (size_t i=0;i<nodalVarNames.size();i++)
{
EXPECT_TRUE(nodeBlockAssociatedWithField0->field_exists(nodalVarNames[i])) << nodalVarNames[i];
}
}
void ItkImageIO::Write()
{
const mitk::Image *image = dynamic_cast<const mitk::Image *>(this->GetInput());
if (image == NULL)
{
mitkThrow() << "Cannot write non-image data";
}
// Switch the current locale to "C"
LocaleSwitch localeSwitch("C");
// Clone the image geometry, because we might have to change it
// for writing purposes
BaseGeometry::Pointer geometry = image->GetGeometry()->Clone();
// Check if geometry information will be lost
if (image->GetDimension() == 2 && !geometry->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might "
"consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = geometry->GetSpacing();
mitk::Point3D origin = geometry->GetOrigin();
geometry->SetIndexToWorldTransform(affTrans);
geometry->SetSpacing(spacing);
geometry->SetOrigin(origin);
}
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
const unsigned int dimension = image->GetDimension();
const unsigned int *const dimensions = image->GetDimensions();
const mitk::PixelType pixelType = image->GetPixelType();
const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
const mitk::Point3D mitkOrigin = geometry->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
// though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
// Set the necessary information for imageIO
m_ImageIO->SetNumberOfDimensions(dimension);
m_ImageIO->SetPixelType(pixelType.GetPixelType());
m_ImageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
m_ImageIO->SetNumberOfComponents(pixelType.GetNumberOfComponents());
itk::ImageIORegion ioRegion(dimension);
for (unsigned int i = 0; i < dimension; i++)
{
m_ImageIO->SetDimensions(i, dimensions[i]);
m_ImageIO->SetSpacing(i, spacing4D[i]);
m_ImageIO->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
{
direction4D[3] = 1; // homogenous component
}
else
{
direction4D[3] = 0;
}
vnl_vector<double> axisDirection(dimension);
for (unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
m_ImageIO->SetDirection(i, axisDirection);
ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
}
// use compression if available
m_ImageIO->UseCompressionOn();
m_ImageIO->SetIORegion(ioRegion);
m_ImageIO->SetFileName(path);
// Handle time geometry
const ArbitraryTimeGeometry *arbitraryTG = dynamic_cast<const ArbitraryTimeGeometry *>(image->GetTimeGeometry());
if (arbitraryTG)
{
itk::EncapsulateMetaData<std::string>(m_ImageIO->GetMetaDataDictionary(),
PROPERTY_KEY_TIMEGEOMETRY_TYPE,
ArbitraryTimeGeometry::GetStaticNameOfClass());
std::stringstream stream;
stream << arbitraryTG->GetTimeBounds(0)[0];
for (TimeStepType pos = 0; pos < arbitraryTG->CountTimeSteps(); ++pos)
{
stream << " " << arbitraryTG->GetTimeBounds(pos)[1];
}
std::string data = stream.str();
itk::EncapsulateMetaData<std::string>(
m_ImageIO->GetMetaDataDictionary(), PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS, data);
}
// Handle properties
mitk::PropertyList::Pointer imagePropertyList = image->GetPropertyList();
for (const auto &property : *imagePropertyList->GetMap())
{
IPropertyPersistence::InfoResultType infoList =
mitk::CoreServices::GetPropertyPersistence()->GetInfo(property.first, GetMimeType()->GetName(), true);
if (infoList.empty())
{
continue;
}
std::string value = infoList.front()->GetSerializationFunction()(property.second);
if (value == mitk::BaseProperty::VALUE_CANNOT_BE_CONVERTED_TO_STRING)
{
continue;
}
std::string key = infoList.front()->GetKey();
itk::EncapsulateMetaData<std::string>(m_ImageIO->GetMetaDataDictionary(), key, value);
}
ImageReadAccessor imageAccess(image);
m_ImageIO->Write(imageAccess.GetData());
}
catch (const std::exception &e)
{
mitkThrow() << e.what();
}
}
std::vector<BaseData::Pointer> ItkImageIO::Read()
{
std::vector<BaseData::Pointer> result;
mitk::LocaleSwitch localeSwitch("C");
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.
m_ImageIO->SetFileName(path);
m_ImageIO->ReadImageInformation();
unsigned int ndim = m_ImageIO->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] = m_ImageIO->GetDimensions(i);
if (i < MAXDIM)
{
dimensions[i] = m_ImageIO->GetDimensions(i);
spacing[i] = m_ImageIO->GetSpacing(i);
if (spacing[i] <= 0)
spacing[i] = 1.0f;
}
if (i < 3)
{
origin[i] = m_ImageIO->GetOrigin(i);
}
}
ioRegion.SetSize(ioSize);
ioRegion.SetIndex(ioStart);
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
m_ImageIO->SetIORegion(ioRegion);
void *buffer = new unsigned char[m_ImageIO->GetImageSizeInBytes()];
m_ImageIO->Read(buffer);
image->Initialize(MakePixelType(m_ImageIO), ndim, dimensions);
image->SetImportChannel(buffer, 0, Image::ManageMemory);
const itk::MetaDataDictionary &dictionary = m_ImageIO->GetMetaDataDictionary();
// 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] = m_ImageIO->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
TimeGeometry::Pointer timeGeometry;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TYPE) || dictionary.HasKey(PROPERTY_KEY_TIMEGEOMETRY_TYPE))
{ // also check for the name because of backwards compatibility. Past code version stored with the name and not with
// the key
itk::MetaDataObject<std::string>::ConstPointer timeGeometryTypeData = nullptr;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TYPE))
{
timeGeometryTypeData =
dynamic_cast<const itk::MetaDataObject<std::string> *>(dictionary.Get(PROPERTY_NAME_TIMEGEOMETRY_TYPE));
}
else
{
timeGeometryTypeData =
dynamic_cast<const itk::MetaDataObject<std::string> *>(dictionary.Get(PROPERTY_KEY_TIMEGEOMETRY_TYPE));
}
if (timeGeometryTypeData->GetMetaDataObjectValue() == ArbitraryTimeGeometry::GetStaticNameOfClass())
{
MITK_INFO << "used time geometry: " << ArbitraryTimeGeometry::GetStaticNameOfClass() << std::endl;
typedef std::vector<TimePointType> TimePointVector;
TimePointVector timePoints;
if (dictionary.HasKey(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS))
{
timePoints = ConvertMetaDataObjectToTimePointList(dictionary.Get(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS));
}
else if (dictionary.HasKey(PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS))
{
timePoints = ConvertMetaDataObjectToTimePointList(dictionary.Get(PROPERTY_KEY_TIMEGEOMETRY_TIMEPOINTS));
}
if (timePoints.size() - 1 != image->GetDimension(3))
{
MITK_ERROR << "Stored timepoints (" << timePoints.size() - 1 << ") and size of image time dimension ("
<< image->GetDimension(3) << ") do not match. Switch to ProportionalTimeGeometry fallback"
<< std::endl;
}
else
{
ArbitraryTimeGeometry::Pointer arbitraryTimeGeometry = ArbitraryTimeGeometry::New();
TimePointVector::const_iterator pos = timePoints.begin();
TimePointVector::const_iterator prePos = pos++;
for (; pos != timePoints.end(); ++prePos, ++pos)
{
arbitraryTimeGeometry->AppendTimeStepClone(slicedGeometry, *pos, *prePos);
}
timeGeometry = arbitraryTimeGeometry;
}
}
}
if (timeGeometry.IsNull())
{ // Fallback. If no other valid time geometry has been created, create a ProportionalTimeGeometry
MITK_INFO << "used time geometry: " << ProportionalTimeGeometry::GetStaticNameOfClass() << std::endl;
ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
propTimeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
timeGeometry = propTimeGeometry;
}
image->SetTimeGeometry(timeGeometry);
buffer = NULL;
MITK_INFO << "number of image components: " << image->GetPixelType().GetNumberOfComponents() << std::endl;
for (itk::MetaDataDictionary::ConstIterator iter = dictionary.Begin(), iterEnd = dictionary.End(); iter != iterEnd;
++iter)
{
if (iter->second->GetMetaDataObjectTypeInfo() == typeid(std::string))
{
const std::string &key = iter->first;
std::string assumedPropertyName = key;
std::replace(assumedPropertyName.begin(), assumedPropertyName.end(), '_', '.');
std::string mimeTypeName = GetMimeType()->GetName();
// Check if there is already a info for the key and our mime type.
IPropertyPersistence::InfoResultType infoList = mitk::CoreServices::GetPropertyPersistence()->GetInfoByKey(key);
auto predicate = [mimeTypeName](const PropertyPersistenceInfo::ConstPointer &x) {
return x.IsNotNull() && x->GetMimeTypeName() == mimeTypeName;
};
auto finding = std::find_if(infoList.begin(), infoList.end(), predicate);
if (finding == infoList.end())
{
auto predicateWild = [](const PropertyPersistenceInfo::ConstPointer &x) {
return x.IsNotNull() && x->GetMimeTypeName() == PropertyPersistenceInfo::ANY_MIMETYPE_NAME();
};
finding = std::find_if(infoList.begin(), infoList.end(), predicateWild);
}
PropertyPersistenceInfo::ConstPointer info;
if (finding != infoList.end())
{
assumedPropertyName = (*finding)->GetName();
info = *finding;
}
else
{ // we have not found anything suitable so we generate our own info
PropertyPersistenceInfo::Pointer newInfo = PropertyPersistenceInfo::New();
newInfo->SetNameAndKey(assumedPropertyName, key);
newInfo->SetMimeTypeName(PropertyPersistenceInfo::ANY_MIMETYPE_NAME());
info = newInfo;
}
std::string value =
dynamic_cast<itk::MetaDataObject<std::string> *>(iter->second.GetPointer())->GetMetaDataObjectValue();
mitk::BaseProperty::Pointer loadedProp = info->GetDeserializationFunction()(value);
image->SetProperty(assumedPropertyName.c_str(), loadedProp);
// Read properties should be persisted unless they are default properties
// which are written anyway
bool isDefaultKey(false);
for (const auto &defaultKey : m_DefaultMetaDataKeys)
{
if (defaultKey.length() <= assumedPropertyName.length())
{
// does the start match the default key
if (assumedPropertyName.substr(0, defaultKey.length()).find(defaultKey) != std::string::npos)
{
isDefaultKey = true;
break;
}
}
}
if (!isDefaultKey)
{
mitk::CoreServices::GetPropertyPersistence()->AddInfo(info);
}
}
}
MITK_INFO << "...finished!" << std::endl;
result.push_back(image.GetPointer());
return result;
}
void LabelSetImageIO::Write()
{
ValidateOutputLocation();
const LabelSetImage* input = static_cast<const LabelSetImage*>(this->GetInput());
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 " << currLocale;
}
}
mitk::Image::Pointer inputVector = mitk::LabelSetImageConverter::ConvertLabelSetImageToImage(input);
// image write
if ( inputVector.IsNull() )
{
mitkThrow() << "Cannot write non-image data";
}
itk::NrrdImageIO::Pointer nrrdImageIo = itk::NrrdImageIO::New();
// Clone the image geometry, because we might have to change it
// for writing purposes
BaseGeometry::Pointer geometry = inputVector->GetGeometry()->Clone();
// Check if geometry information will be lost
if (inputVector->GetDimension() == 2 &&
!geometry->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = geometry->GetSpacing();
mitk::Point3D origin = geometry->GetOrigin();
geometry->SetIndexToWorldTransform(affTrans);
geometry->SetSpacing(spacing);
geometry->SetOrigin(origin);
}
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
const unsigned int dimension = inputVector->GetDimension();
const unsigned int* const dimensions = inputVector->GetDimensions();
const mitk::PixelType pixelType = inputVector->GetPixelType();
const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
const mitk::Point3D mitkOrigin = geometry->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
// though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
// Set the necessary information for imageIO
nrrdImageIo->SetNumberOfDimensions(dimension);
nrrdImageIo->SetPixelType(pixelType.GetPixelType());
nrrdImageIo->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
nrrdImageIo->SetNumberOfComponents(pixelType.GetNumberOfComponents());
itk::ImageIORegion ioRegion(dimension);
for (unsigned int i = 0; i < dimension; i++)
{
nrrdImageIo->SetDimensions(i, dimensions[i]);
nrrdImageIo->SetSpacing(i, spacing4D[i]);
nrrdImageIo->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
{
direction4D[3] = 1; // homogenous component
}
else
{
direction4D[3] = 0;
}
vnl_vector<double> axisDirection(dimension);
for (unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
nrrdImageIo->SetDirection(i, axisDirection);
ioRegion.SetSize(i, inputVector->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, inputVector->GetLargestPossibleRegion().GetIndex(i));
}
//use compression if available
nrrdImageIo->UseCompressionOn();
nrrdImageIo->SetIORegion(ioRegion);
nrrdImageIo->SetFileName(path);
// label set specific meta data
char keybuffer[512];
char valbuffer[512];
sprintf(keybuffer, "modality");
sprintf(valbuffer, "org.mitk.image.multilabel");
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
sprintf(keybuffer, "layers");
sprintf(valbuffer, "%1d", input->GetNumberOfLayers());
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
for (unsigned int layerIdx = 0; layerIdx<input->GetNumberOfLayers(); layerIdx++)
{
sprintf(keybuffer, "layer_%03d", layerIdx); // layer idx
sprintf(valbuffer, "%1d", input->GetNumberOfLabels(layerIdx)); // number of labels for the layer
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
mitk::LabelSet::LabelContainerConstIteratorType iter = input->GetLabelSet(layerIdx)->IteratorConstBegin();
unsigned int count(0);
while (iter != input->GetLabelSet(layerIdx)->IteratorConstEnd())
{
std::auto_ptr<TiXmlDocument> document;
document.reset(new TiXmlDocument());
TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "", ""); // TODO what to write here? encoding? etc....
document->LinkEndChild(decl);
TiXmlElement * labelElem = GetLabelAsTiXmlElement(iter->second);
document->LinkEndChild(labelElem);
TiXmlPrinter printer;
printer.SetIndent("");
printer.SetLineBreak("");
document->Accept(&printer);
sprintf(keybuffer, "org.mitk.label_%03u_%05u", layerIdx, count);
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), printer.Str());
++iter;
++count;
}
}
// end label set specific meta data
ImageReadAccessor imageAccess(inputVector);
nrrdImageIo->Write(imageAccess.GetData());
}
catch (const std::exception& e)
{
mitkThrow() << e.what();
}
// end image write
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
mitkThrow() << "Could not reset locale " << currLocale;
}
}
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;
}
void ToFNrrdImageWriter::ConvertStreamToNrrdFormat( std::string fileName )
{
int CaptureWidth = 0;
int CaptureHeight = 0;
int PixelNumber = 0;
int ImageSizeInBytes = 0;
if (fileName==this->m_RGBImageFileName)
{
CaptureWidth = this->m_RGBCaptureWidth;
CaptureHeight = this->m_RGBCaptureHeight;
PixelNumber = this->m_RGBPixelNumber;
ImageSizeInBytes = this->m_RGBImageSizeInBytes;
} else
{
CaptureWidth = this->m_ToFCaptureWidth;
CaptureHeight = this->m_ToFCaptureHeight;
PixelNumber = this->m_ToFPixelNumber;
ImageSizeInBytes = this->m_ToFImageSizeInBytes;
}
Image::Pointer imageTemplate = Image::New();
int dimension ;
unsigned int* dimensions;
if(m_ToFImageType == ToFImageType2DPlusT)
{
dimension = 4;
dimensions = new unsigned int[dimension];
dimensions[0] = CaptureWidth;
dimensions[1] = CaptureHeight;
dimensions[2] = 1;
dimensions[3] = this->m_NumOfFrames;
}
else if( m_ToFImageType == ToFImageType3D)
{
dimension = 3;
dimensions = new unsigned int[dimension];
dimensions[0] = CaptureWidth;
dimensions[1] = CaptureHeight;
dimensions[2] = this->m_NumOfFrames;
}
else
{
throw std::logic_error("No image type set, please choose between 2D+t and 3D!");
}
float* floatData;
unsigned char* rgbData;
if (fileName==this->m_RGBImageFileName)
{
rgbData = new unsigned char[PixelNumber*3];
for(int i=0; i<PixelNumber*3; i++)
{
rgbData[i] = i + 0.0;
}
mitk::PixelType RGBType = MakePixelType<unsigned char, itk::RGBPixel<unsigned char>, 3>();
imageTemplate->Initialize( RGBType,dimension, dimensions, 1);
imageTemplate->SetSlice(rgbData, 0, 0, 0);
}
else
{
floatData = new float[PixelNumber];
for(int i=0; i<PixelNumber; i++)
{
floatData[i] = i + 0.0;
}
mitk::PixelType FloatType = MakeScalarPixelType<float>();
imageTemplate->Initialize( FloatType,dimension, dimensions, 1);
imageTemplate->SetSlice(floatData, 0, 0, 0);
}
itk::NrrdImageIO::Pointer nrrdWriter = itk::NrrdImageIO::New();
nrrdWriter->SetNumberOfDimensions(dimension);
nrrdWriter->SetPixelType( imageTemplate->GetPixelType().GetPixelType());
nrrdWriter->SetComponentType( (itk::ImageIOBase::IOComponentType) imageTemplate->GetPixelType().GetComponentType());
if(imageTemplate->GetPixelType().GetNumberOfComponents() > 1)
{
nrrdWriter->SetNumberOfComponents(imageTemplate->GetPixelType().GetNumberOfComponents());
}
itk::ImageIORegion ioRegion( dimension );
mitk::Vector3D spacing = imageTemplate->GetGeometry()->GetSpacing();
mitk::Point3D origin = imageTemplate->GetGeometry()->GetOrigin();
for(unsigned int i = 0; i < dimension; i++)
{
nrrdWriter->SetDimensions(i,dimensions[i]);
nrrdWriter->SetSpacing(i,spacing[i]);
nrrdWriter->SetOrigin(i,origin[i]);
mitk::Vector3D direction;
direction.Set_vnl_vector(imageTemplate->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
vnl_vector< double > axisDirection(dimension);
for(unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction[j]/spacing[i];
}
nrrdWriter->SetDirection( i, axisDirection );
ioRegion.SetSize(i, imageTemplate->GetLargestPossibleRegion().GetSize(i) );
ioRegion.SetIndex(i, imageTemplate->GetLargestPossibleRegion().GetIndex(i) );
}
nrrdWriter->SetIORegion(ioRegion);
nrrdWriter->SetFileName(fileName);
nrrdWriter->SetUseStreamedWriting(true);
std::ifstream stream(fileName.c_str(), std::ifstream::binary);
if (fileName==m_RGBImageFileName)
{
unsigned int size = PixelNumber*3 * this->m_NumOfFrames;
unsigned int sizeInBytes = size * sizeof(unsigned char);
unsigned char* data = new unsigned char[size];
stream.read((char*)data, sizeInBytes);
nrrdWriter->Write(data);
stream.close();
delete[] data;
}
else
{
unsigned int size = PixelNumber * this->m_NumOfFrames;
unsigned int sizeInBytes = size * sizeof(float);
float* data = new float[size];
stream.read((char*)data, sizeInBytes);
try
{
nrrdWriter->Write(data);
}
catch (itk::ExceptionObject* e)
{
MITK_ERROR<< e->what();
return;
}
stream.close();
delete[] data;
}
delete[] dimensions;
if (fileName==m_RGBImageFileName)
{
delete[] rgbData;
}
else
{
delete[] floatData;
}
}
void ItkReader::ReadImageDirect(DataContainer& data) {
typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
itk::ImageIOBase::Pointer imageIO =
itk::ImageIOFactory::CreateImageIO(p_url.getValue().c_str(), itk::ImageIOFactory::ReadMode);
if (imageIO.IsNotNull())
{
WeaklyTypedPointer wtp;
imageIO->SetFileName(p_url.getValue());
imageIO->ReadImageInformation();
const ScalarPixelType pixelType = imageIO->GetComponentType();
const size_t numDimensions = imageIO->GetNumberOfDimensions();
LDEBUG("Reading Image with Reader " << imageIO->GetNameOfClass());
LDEBUG("Pixel Type is " << imageIO->GetComponentTypeAsString(pixelType));
LDEBUG("numDimensions: " << numDimensions);
if (numDimensions > 3) {
LERROR("Error: Dimensions higher than 3 not supported!");
return;
}
itk::ImageIORegion ioRegion(numDimensions);
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
cgt::vec3 imageOffset(0.f);
cgt::vec3 voxelSize(1.f);
cgt::ivec3 size_i(1);
//we assured above that numDimensions is < 3
for (int i = 0; i < static_cast<int>(numDimensions); i++) {
size_i[i] = imageIO->GetDimensions(i);
imageOffset[i] = imageIO->GetOrigin(i);
voxelSize[i] = imageIO->GetSpacing(i);
ioStart[i] = 0;
ioSize[i] = size_i[i];
}
cgt::svec3 size(size_i);
size_t dimensionality = (size_i[2] == 1) ? ((size_i[1] == 1) ? 1 : 2) : 3;
LDEBUG("Image Size is " << size);
LDEBUG("Voxel Size is " << voxelSize);
LDEBUG("Image Offset is " << imageOffset);
LDEBUG("component size: " << imageIO->GetComponentSize());
LDEBUG("components: " << imageIO->GetNumberOfComponents());
LDEBUG("pixel type (string): " << imageIO->GetPixelTypeAsString(imageIO->GetPixelType())); // 'vector'
LDEBUG("pixel type: " << imageIO->GetPixelType()); // '5'
switch (pixelType) {
case itk::ImageIOBase::CHAR:
wtp._baseType = WeaklyTypedPointer::INT8; break;
case itk::ImageIOBase::UCHAR:
wtp._baseType = WeaklyTypedPointer::UINT8; break;
case itk::ImageIOBase::SHORT:
wtp._baseType = WeaklyTypedPointer::INT16; break;
case itk::ImageIOBase::USHORT:
wtp._baseType = WeaklyTypedPointer::UINT16; break;
case itk::ImageIOBase::INT:
wtp._baseType = WeaklyTypedPointer::INT32; break;
case itk::ImageIOBase::UINT:
wtp._baseType = WeaklyTypedPointer::UINT32; break;
case itk::ImageIOBase::DOUBLE:
LWARNING("Pixel Type is DOUBLE. Conversion to float may result in loss of precision!");
case itk::ImageIOBase::FLOAT:
wtp._baseType = WeaklyTypedPointer::FLOAT; break;
default:
LERROR("Error while loading ITK image: unsupported type: " << pixelType);
return;
}
wtp._numChannels = imageIO->GetNumberOfComponents();
//Setup the image region to read
ioRegion.SetIndex(ioStart);
ioRegion.SetSize(ioSize);
imageIO->SetIORegion(ioRegion);
if (pixelType != itk::ImageIOBase::DOUBLE) {
//Finally, allocate buffer and read the image data
wtp._pointer = new uint8_t[imageIO->GetImageSizeInBytes()];
imageIO->Read(wtp._pointer);
}
else {
//convert float volume to double volume
double * inputBuf = new double[imageIO->GetImageSizeInComponents()];
wtp._pointer = new uint8_t[imageIO->GetImageSizeInComponents() * sizeof(float)];
imageIO->Read(inputBuf);
double * dptr = inputBuf;
float * fptr = static_cast<float*>(wtp._pointer);
for (int i = 0, s = imageIO->GetImageSizeInComponents(); i < s; ++i) {
*fptr = *dptr;
fptr++;
dptr++;
}
delete[] inputBuf;
}
ImageData* image = new ImageData(dimensionality, size, wtp._numChannels);
ImageRepresentationLocal::create(image, wtp);
image->setMappingInformation(ImageMappingInformation(size, imageOffset/* + p_imageOffset.getValue()*/, voxelSize /** p_voxelSize.getValue()*/));
data.addData(p_targetImageID.getValue(), image);
}
else {
LWARNING("Unable to create ImageIO Instance; No suitable reader found!");
}
}
void ItkReader::ReadImageSeries(DataContainer& data) {
typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
std::vector<std::string> imageFileNames = GetImageFileNames();
if (!imageFileNames.size())
return;
itk::ImageIOBase::Pointer imageIO =
itk::ImageIOFactory::CreateImageIO(imageFileNames[0].c_str(), itk::ImageIOFactory::ReadMode);
const int numSlices = imageFileNames.size();
if (imageIO.IsNotNull())
{
WeaklyTypedPointer wtp;
imageIO->SetFileName(imageFileNames[0]);
imageIO->ReadImageInformation();
const ScalarPixelType pixelType = imageIO->GetComponentType();
const size_t numDimensions = imageIO->GetNumberOfDimensions();
LDEBUG("Reading Image with Reader " << imageIO->GetNameOfClass());
LDEBUG("Pixel Type is " << imageIO->GetComponentTypeAsString(pixelType));
LDEBUG("numDimensions: " << numDimensions);
if (numDimensions > 3) {
LERROR("Error: Dimensions higher than 3 not supported!");
return;
}
itk::ImageIORegion ioRegion(numDimensions);
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
cgt::vec3 imageOffset(0.f);
cgt::vec3 voxelSize(1.f);
cgt::ivec3 size_i(1);
//we assured above that numDimensions is < 3
for (int i = 0; i < static_cast<int>(numDimensions); i++) {
size_i[i] = imageIO->GetDimensions(i);
imageOffset[i] = imageIO->GetOrigin(i);
voxelSize[i] = imageIO->GetSpacing(i);
ioStart[i] = 0;
ioSize[i] = size_i[i];
}
cgt::svec3 size(size_i);
size_t dimensionality = (size_i[2] == 1) ? ((size_i[1] == 1) ? 1 : 2) : 3;
if (dimensionality > 2) {
LERROR("Error: Cannot load image series with more than two dimensions!");
return;
}
LDEBUG("Image Size is " << size);
LDEBUG("Voxel Size is " << voxelSize);
LDEBUG("Image Offset is " << imageOffset);
LDEBUG("component size: " << imageIO->GetComponentSize());
LDEBUG("components: " << imageIO->GetNumberOfComponents());
LDEBUG("pixel type (string): " << imageIO->GetPixelTypeAsString(imageIO->GetPixelType()));
LDEBUG("pixel type: " << imageIO->GetPixelType());
switch (pixelType) {
case itk::ImageIOBase::CHAR:
wtp._baseType = WeaklyTypedPointer::INT8; break;
case itk::ImageIOBase::UCHAR:
wtp._baseType = WeaklyTypedPointer::UINT8; break;
case itk::ImageIOBase::SHORT:
wtp._baseType = WeaklyTypedPointer::INT16; break;
case itk::ImageIOBase::USHORT:
wtp._baseType = WeaklyTypedPointer::UINT16; break;
case itk::ImageIOBase::INT:
wtp._baseType = WeaklyTypedPointer::INT32; break;
case itk::ImageIOBase::UINT:
wtp._baseType = WeaklyTypedPointer::UINT32; break;
case itk::ImageIOBase::DOUBLE:
LWARNING("Pixel Type is DOUBLE. Conversion to float may result in loss of precision!");
case itk::ImageIOBase::FLOAT:
wtp._baseType = WeaklyTypedPointer::FLOAT; break;
default:
LERROR("Error while loading ITK image: unsupported type: " << pixelType);
return;
}
wtp._numChannels = imageIO->GetNumberOfComponents();
//Setup the image region to read
ioRegion.SetIndex(ioStart);
ioRegion.SetSize(ioSize);
imageIO->SetIORegion(ioRegion);
//allocate a temporary buffer if necessary
double* inputBuf = (pixelType == itk::ImageIOBase::DOUBLE) ? new double[imageIO->GetImageSizeInComponents()] : nullptr;
size_t sliceSize = (pixelType == itk::ImageIOBase::DOUBLE) ? imageIO->GetImageSizeInComponents() * sizeof(float) : imageIO->GetImageSizeInBytes();
wtp._pointer = new uint8_t[numSlices * sliceSize];
for (int idx = 0; idx < numSlices; ++idx) {
itk::ImageIOBase::Pointer fileIO = imageIO;
//itk::ImageIOFactory::CreateImageIO(imageFileNames[idx].c_str(), itk::ImageIOFactory::ReadMode);
fileIO->SetFileName(imageFileNames[idx]);
fileIO->ReadImageInformation();
fileIO->SetIORegion(ioRegion);
size_t currentSliceSize = (pixelType == itk::ImageIOBase::DOUBLE) ? imageIO->GetImageSizeInComponents() * sizeof(float) : fileIO->GetImageSizeInBytes();
if (currentSliceSize != sliceSize) {
LERROR("Image " << imageFileNames[idx] << " has different dimensionality or data type!");
delete static_cast<uint8_t*>(wtp._pointer);
delete inputBuf;
wtp._pointer = nullptr;
return;
}
uint8_t* sliceBuffer = static_cast<uint8_t*>(wtp._pointer) + idx * sliceSize;
if (pixelType != itk::ImageIOBase::DOUBLE) {
// directly read slice into buffer
fileIO->Read(sliceBuffer);
}
else {
//convert float volume to double volume
fileIO->Read(inputBuf);
double* dptr = inputBuf;
float* fptr = reinterpret_cast<float*>(sliceBuffer);
for (int i = 0, s = fileIO->GetImageSizeInComponents(); i < s; ++i) {
*fptr = static_cast<float>(*dptr);
fptr++;
dptr++;
}
}
}
delete[] inputBuf;
size[2] = numSlices;
//series adds one dimension
ImageData* image = new ImageData(dimensionality+1, size, wtp._numChannels);
ImageRepresentationLocal::create(image, wtp);
image->setMappingInformation(ImageMappingInformation(size, imageOffset/* + p_imageOffset.getValue()*/, voxelSize /** p_voxelSize.getValue()*/));
data.addData(p_targetImageID.getValue(), image);
}
else {
LWARNING("Unable to create ImageIO Instance; No suitable reader found!");
}
}
void ItkImageIO::Write()
{
const mitk::Image* image = dynamic_cast<const mitk::Image*>(this->GetInput());
if (image == NULL)
{
mitkThrow() << "Cannot write non-image data";
}
struct LocaleSwitch
{
LocaleSwitch(const std::string& newLocale)
: m_OldLocale(std::setlocale(LC_ALL, NULL))
, m_NewLocale(newLocale)
{
if (m_OldLocale == NULL)
{
m_OldLocale = "";
}
else if (m_NewLocale != m_OldLocale)
{
// set the locale
if (std::setlocale(LC_ALL, m_NewLocale.c_str()) == NULL)
{
MITK_INFO << "Could not set locale " << m_NewLocale;
m_OldLocale = NULL;
}
}
}
~LocaleSwitch()
{
if (m_OldLocale != NULL && std::setlocale(LC_ALL, m_OldLocale) == NULL)
{
MITK_INFO << "Could not reset locale " << m_OldLocale;
}
}
private:
const char* m_OldLocale;
const std::string m_NewLocale;
};
// Switch the current locale to "C"
LocaleSwitch localeSwitch("C");
// Clone the image geometry, because we might have to change it
// for writing purposes
BaseGeometry::Pointer geometry = image->GetGeometry()->Clone();
// Check if geometry information will be lost
if (image->GetDimension() == 2 &&
!geometry->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = geometry->GetSpacing();
mitk::Point3D origin = geometry->GetOrigin();
geometry->SetIndexToWorldTransform(affTrans);
geometry->SetSpacing(spacing);
geometry->SetOrigin(origin);
}
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
const unsigned int dimension = image->GetDimension();
const unsigned int* const dimensions = image->GetDimensions();
const mitk::PixelType pixelType = image->GetPixelType();
const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
const mitk::Point3D mitkOrigin = geometry->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
// though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
// Set the necessary information for imageIO
m_ImageIO->SetNumberOfDimensions(dimension);
m_ImageIO->SetPixelType(pixelType.GetPixelType());
m_ImageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
m_ImageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
itk::ImageIORegion ioRegion( dimension );
for(unsigned int i = 0; i < dimension; i++)
{
m_ImageIO->SetDimensions(i, dimensions[i]);
m_ImageIO->SetSpacing(i, spacing4D[i]);
m_ImageIO->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
{
direction4D[3] = 1; // homogenous component
}
else
{
direction4D[3] = 0;
}
vnl_vector<double> axisDirection(dimension);
for(unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
m_ImageIO->SetDirection(i, axisDirection);
ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
}
//use compression if available
m_ImageIO->UseCompressionOn();
m_ImageIO->SetIORegion(ioRegion);
m_ImageIO->SetFileName(path);
// ***** Remove const_cast after bug 17952 is fixed ****
ImageReadAccessor imageAccess(const_cast<mitk::Image*>(image));
m_ImageIO->Write(imageAccess.GetData());
}
catch (const std::exception& e)
{
mitkThrow() << e.what();
}
}
std::vector<BaseData::Pointer> ItkImageIO::Read()
{
std::vector<BaseData::Pointer> result;
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(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
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.
m_ImageIO->SetFileName( path );
m_ImageIO->ReadImageInformation();
unsigned int ndim = m_ImageIO->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 ] = m_ImageIO->GetDimensions( i );
if(i<MAXDIM)
{
dimensions[ i ] = m_ImageIO->GetDimensions( i );
spacing[ i ] = m_ImageIO->GetSpacing( i );
if(spacing[ i ] <= 0)
spacing[ i ] = 1.0f;
}
if(i<3)
{
origin[ i ] = m_ImageIO->GetOrigin( i );
}
}
ioRegion.SetSize( ioSize );
ioRegion.SetIndex( ioStart );
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
m_ImageIO->SetIORegion( ioRegion );
void* buffer = new unsigned char[m_ImageIO->GetImageSizeInBytes()];
m_ImageIO->Read( buffer );
image->Initialize( MakePixelType(m_ImageIO), 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] = m_ImageIO->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 = m_ImageIO->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));
}
}
MITK_INFO << "...finished!" << std::endl;
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
result.push_back(image.GetPointer());
return result;
}
