bool
mitk::ThreeDnTDICOMSeriesReader
::LoadMitkImageForImageBlockDescriptor(DICOMImageBlockDescriptor& block) const
{
PushLocale();
const DICOMImageFrameList& frames = block.GetImageFrameList();
const GantryTiltInformation tiltInfo = block.GetTiltInformation();
const bool hasTilt = tiltInfo.IsRegularGantryTilt();
const int numberOfTimesteps = block.GetNumberOfTimeSteps();
if (numberOfTimesteps == 1)
{
return DICOMITKSeriesGDCMReader::LoadMitkImageForImageBlockDescriptor(block);
}
const int numberOfFramesPerTimestep = block.GetNumberOfFramesPerTimeStep();
ITKDICOMSeriesReaderHelper::StringContainerList filenamesPerTimestep;
for (int timeStep = 0; timeStep<numberOfTimesteps; ++timeStep)
{
// use numberOfFramesPerTimestep frames for a new item in filenamesPerTimestep
ITKDICOMSeriesReaderHelper::StringContainer filenamesOfThisTimeStep;
auto timeStepStart = frames.cbegin() + timeStep * numberOfFramesPerTimestep;
auto timeStepEnd = frames.cbegin() + (timeStep+1) * numberOfFramesPerTimestep;
for (auto frameIter = timeStepStart;
frameIter != timeStepEnd;
++frameIter)
{
filenamesOfThisTimeStep.push_back( (*frameIter)->Filename );
}
filenamesPerTimestep.push_back( filenamesOfThisTimeStep );
}
mitk::ITKDICOMSeriesReaderHelper helper;
mitk::Image::Pointer mitkImage = helper.Load3DnT( filenamesPerTimestep, m_FixTiltByShearing && hasTilt, tiltInfo );
block.SetMitkImage( mitkImage );
PopLocale();
return true;
}
mitk::Image::Pointer
mitk::TestDICOMLoading
::DecorateVerifyCachedImage( const StringList& files, mitk::DICOMTagCache* tagCache, mitk::Image::Pointer cachedImage )
{
DICOMImageBlockDescriptor block;
DICOMImageFrameList framelist;
for (auto iter = files.begin();
iter != files.end();
++iter)
{
framelist.push_back( DICOMImageFrameInfo::New(*iter) );
}
block.SetImageFrameList( framelist );
block.SetTagCache( tagCache );
block.SetMitkImage( cachedImage ); // this should/will create a propertylist describing the image slices
return block.GetMitkImage();
}
mitk::Image::Pointer
mitk::TestDICOMLoading
::DecorateVerifyCachedImage( const StringList& files, mitk::Image::Pointer cachedImage )
{
ClassicDICOMSeriesReader::Pointer reader = this->BuildDICOMReader();
reader->SetInputFiles( files );
reader->AnalyzeInputFiles(); // This just creates a "tag cache and a nice DICOMImageBlockDescriptor.
// Both of these could also be produced in a different way. The only
// important thing is, that the DICOMImageBlockDescriptor knows a
// tag-cache object when PropertyDecorateCachedMitkImageForImageBlockDescriptor
// is called.
if ( reader->GetNumberOfOutputs() != 1 )
{
MITK_ERROR << "Reader produce " << reader->GetNumberOfOutputs() << " images instead of 1 expected..";
return nullptr;
}
DICOMImageBlockDescriptor block = reader->GetOutput(0); // creates a block copy
block.SetMitkImage( cachedImage ); // this should/will create a propertylist describing the image slices
return block.GetMitkImage();
}
bool mitk::DiffusionDICOMFileReader
::LoadSingleOutputImage( DiffusionHeaderDICOMFileReader::DICOMHeaderListType retrievedHeader,
DICOMImageBlockDescriptor& block, bool is_mosaic)
{
// prepare data reading
DiffusionDICOMFileReaderHelper helper;
DiffusionDICOMFileReaderHelper::VolumeFileNamesContainer filenames;
const DICOMImageFrameList& frames = block.GetImageFrameList();
int numberOfDWImages = block.GetIntProperty("timesteps", 1);
int numberOfFramesPerDWImage = frames.size() / numberOfDWImages;
assert( int( double((double) frames.size() / (double) numberOfDWImages)) == numberOfFramesPerDWImage );
for( int idx = 0; idx < numberOfDWImages; idx++ )
{
std::vector< std::string > FileNamesPerVolume;
auto timeStepStart = frames.begin() + idx * numberOfFramesPerDWImage;
auto timeStepEnd = frames.begin() + (idx+1) * numberOfFramesPerDWImage;
for (auto frameIter = timeStepStart;
frameIter != timeStepEnd;
++frameIter)
{
FileNamesPerVolume.push_back( (*frameIter)->Filename );
}
filenames.push_back( FileNamesPerVolume );
}
// TODO : only prototyping to test loading of diffusion images
// we need some solution for the different types
mitk::Image::Pointer output_image = mitk::Image::New();
mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer directions =
mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
double max_bvalue = 0;
for( int idx = 0; idx < numberOfDWImages; idx++ )
{
DiffusionImageDICOMHeaderInformation header = retrievedHeader.at(idx);
if( max_bvalue < header.b_value )
max_bvalue = header.b_value;
}
// normalize the retrieved gradient directions according to the set b-value (maximal one)
for( int idx = 0; idx < numberOfDWImages; idx++ )
{
DiffusionImageDICOMHeaderInformation header = retrievedHeader.at(idx);
mitk::DiffusionPropertyHelper::GradientDirectionType grad = header.g_vector;
grad.normalize();
grad *= sqrt( header.b_value / max_bvalue );
directions->push_back( grad );
}
// initialize the output image
output_image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( directions ) );
output_image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( max_bvalue ) );
if( is_mosaic && this->m_ResolveMosaic )
{
mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::Pointer mosaic_reader =
mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::New();
// retrieve the remaining meta-information needed for mosaic reconstruction
// it suffices to get it exemplatory from the first file in the file list
mosaic_reader->RetrieveMosaicInformation( filenames.at(0).at(0) );
mitk::MosaicDescriptor mdesc = mosaic_reader->GetMosaicDescriptor();
mitk::CastToMitkImage( helper.LoadMosaicToVector<short, 3>( filenames, mdesc ), output_image );
}
else
{
mitk::CastToMitkImage( helper.LoadToVector<short, 3>( filenames ), output_image );
}
mitk::DiffusionPropertyHelper propertyHelper( output_image );
propertyHelper.InitializeImage();
output_image->SetProperty("diffusion.dicom.importname", mitk::StringProperty::New( helper.GetOutputName(filenames) ) );
block.SetMitkImage( (mitk::Image::Pointer) output_image );
return block.GetMitkImage().IsNotNull();
}
mitk::DICOMITKSeriesGDCMReader::SortingBlockList
mitk::ThreeDnTDICOMSeriesReader
::Condense3DBlocks(SortingBlockList& resultOf3DGrouping)
{
if (!m_Group3DandT)
{
return resultOf3DGrouping; // don't work if nobody asks us to
}
SortingBlockList remainingBlocks = resultOf3DGrouping;
SortingBlockList non3DnTBlocks;
SortingBlockList true3DnTBlocks;
std::vector<unsigned int> true3DnTBlocksTimeStepCount;
// we should describe our need for this tag as needed via a function
// (however, we currently know that the superclass will always need this tag)
const DICOMTag tagImagePositionPatient(0x0020, 0x0032);
while (!remainingBlocks.empty())
{
// new block to fill up
const DICOMDatasetAccessingImageFrameList& firstBlock = remainingBlocks.front();
DICOMDatasetAccessingImageFrameList current3DnTBlock = firstBlock;
int current3DnTBlockNumberOfTimeSteps = 1;
// get block characteristics of first block
const unsigned int currentBlockNumberOfSlices = firstBlock.size();
const std::string currentBlockFirstOrigin = firstBlock.front()->GetTagValueAsString( tagImagePositionPatient ).value;
const std::string currentBlockLastOrigin = firstBlock.back()->GetTagValueAsString( tagImagePositionPatient ).value;
remainingBlocks.erase( remainingBlocks.begin() );
// compare all other blocks against the first one
for (auto otherBlockIter = remainingBlocks.begin();
otherBlockIter != remainingBlocks.cend();
/*++otherBlockIter*/) // <-- inside loop
{
// get block characteristics from first block
const DICOMDatasetAccessingImageFrameList otherBlock = *otherBlockIter;
const unsigned int otherBlockNumberOfSlices = otherBlock.size();
const std::string otherBlockFirstOrigin = otherBlock.front()->GetTagValueAsString( tagImagePositionPatient ).value;
const std::string otherBlockLastOrigin = otherBlock.back()->GetTagValueAsString( tagImagePositionPatient ).value;
// add matching blocks to current3DnTBlock
// keep other blocks for later
if ( otherBlockNumberOfSlices == currentBlockNumberOfSlices
&& otherBlockFirstOrigin == currentBlockFirstOrigin
&& otherBlockLastOrigin == currentBlockLastOrigin
)
{ // matching block
++current3DnTBlockNumberOfTimeSteps;
current3DnTBlock.insert( current3DnTBlock.end(), otherBlock.begin(), otherBlock.end() ); // append
// remove this block from remainingBlocks
otherBlockIter = remainingBlocks.erase(otherBlockIter); // make sure iterator otherBlockIter is valid afterwards
}
else
{
++otherBlockIter;
}
}
// in any case, we now now all about the first block of our list ...
// ... and we wither call it 3D o 3D+t
if (current3DnTBlockNumberOfTimeSteps > 1)
{
true3DnTBlocks.push_back(current3DnTBlock);
true3DnTBlocksTimeStepCount.push_back(current3DnTBlockNumberOfTimeSteps);
}
else
{
non3DnTBlocks.push_back(current3DnTBlock);
}
}
// create output for real 3D+t blocks (other outputs will be created by superclass)
// set 3D+t flag on output block
this->SetNumberOfOutputs( true3DnTBlocks.size() );
unsigned int o = 0;
for (auto blockIter = true3DnTBlocks.cbegin();
blockIter != true3DnTBlocks.cend();
++o, ++blockIter)
{
// bad copy&paste code from DICOMITKSeriesGDCMReader, should be handled in a better way
DICOMDatasetAccessingImageFrameList gdcmFrameInfoList = *blockIter;
assert(!gdcmFrameInfoList.empty());
// reverse frames if necessary
// update tilt information from absolute last sorting
const DICOMDatasetList datasetList = ConvertToDICOMDatasetList( gdcmFrameInfoList );
m_NormalDirectionConsistencySorter->SetInput( datasetList );
m_NormalDirectionConsistencySorter->Sort();
const DICOMDatasetAccessingImageFrameList sortedGdcmInfoFrameList = ConvertToDICOMDatasetAccessingImageFrameList( m_NormalDirectionConsistencySorter->GetOutput(0) );
const GantryTiltInformation& tiltInfo = m_NormalDirectionConsistencySorter->GetTiltInformation();
// set frame list for current block
const DICOMImageFrameList frameList = ConvertToDICOMImageFrameList( sortedGdcmInfoFrameList );
assert(!frameList.empty());
DICOMImageBlockDescriptor block;
block.SetTagCache( this->GetTagCache() ); // important: this must be before SetImageFrameList(), because SetImageFrameList will trigger reading of lots of interesting tags!
block.SetAdditionalTagsOfInterest(GetAdditionalTagsOfInterest());
block.SetTagLookupTableToPropertyFunctor(GetTagLookupTableToPropertyFunctor());
block.SetImageFrameList( frameList );
block.SetTiltInformation( tiltInfo );
block.SetFlag("3D+t", true);
block.SetIntProperty("timesteps", true3DnTBlocksTimeStepCount[o]);
MITK_DEBUG << "Found " << true3DnTBlocksTimeStepCount[o] << " timesteps";
this->SetOutput( o, block );
}
return non3DnTBlocks;
}
