diff --git a/Modules/DICOM/TODOs.txt b/Modules/DICOM/TODOs.txt
index b947c3ce66..16b2c2d2dd 100644
--- a/Modules/DICOM/TODOs.txt
+++ b/Modules/DICOM/TODOs.txt
@@ -1,64 +1,64 @@
Important
[x] Make sure that ..Selector does tag scanning only once
[x] Check Gantry Tilt ToDo/Bug in old reader
[x] - and in new reader, how do we WANT to handle this?
- old and new code both did not correctly check the stored value against the calculated value
- it SEEMS like tilts below 45 degrees were never checked against the tag, and bigger values are probably unrealistic(?)
- so, nothing wrong. It just seems that we calculated a DIFFERENT angle than the one recorded
- in the new reader we remove the check. We are right as far as our shearing is affected.
[x] Keep OLD DICOMTesting module, in order to test code until it is removed
- restored this module as DCMTesting module
[x] ONLY load a pre-sorted list
- Should work now by:
- get the list of images, construct FrameInfo list (order must be known from prior sorting)
- prepare a tagcache object that provides tag information (from some kind of database, or run AnalyzeInputFiles() on file reader)
- create DICOMImageBlockDescriptor with frame list and tag cache
- Call SetFixTiltByShearing() and TiltInfo object as appropriate...
- call DICOMITKSeriesGDCMReader::LoadMitkImageForImageBlockDescriptor(block)
[x] Option to just provide properties to a pre-loaded mitk::Image
- see TestDICOMLoading::DecorateVerifyCachedImage()
[x] Performance of mitkdump / DICOMReaderSelector (TagCache?)
- the note in GDCM..Reader::GetTagValue() is correct.
This piece of code is taking lots of time.
Approx. half of the time is tag scanning, the other
half is construction of block describing properties,
which accesses GetTagValue.
[x] - maybe we can evaluate these properties in a lazy way
(only when asked for).
Solution: Yes, this helps, implemented.
[x] Gantry tilt broken during implementation
- Was a wrong implementation of NormalDirectionConsistencySorter
[x] Accepted image origin error during EquiDistantBlocksSorter
must be configurable. To support legacy behavior of the reader,
the tolerance must be fixable to a constant value. For newer
readers, it should be adapted to the actual slice distance.
[x] Sorting by "Image Time" seems undeterministic (clarkson test data)
[x] - Numeric conversion of "1.2.3.4" yields 1.2 on Windows, seems to fail on Linux(?)
- need to verify that the whole string (except whitespace at the begin/end) was converted
Solution: GetTagValue as String does a right-trim plus we check after conversion! Works.
[x] Implement Configurator::GetBuiltIn3DReaders() (don't ignore "classic reader")
[x] Complete MITK properties of images: level/window and color type (MONOCHROME1/2)
-[x] Check input images fo DICOMness and non-multi-frameness
+[x] Check input images for DICOMness and non-multi-frameness
[x] Use CanHandleFile() in selection!
- implicitly now, the reader checks itself and produces no output if it cannot handle the files
[x] Check ToDo in mitkDICOMTag.cpp
- operator< for DICOMTag has been re-implemented in a readable and safer way.
[x] Configurable precision for tag value comparisons
[x] Images are upside-down in some cases
- error was hidden assumption somewhere: filenames for ImageSeriesReader need
to be in an order that goes along the image normals, not in the opposite
direction
Questionable
[ ] Fallback to filename instead of instance UID?
Nice-to-have
[ ] Multi-Frame images (DCMTK)
[ ] ...
[x] Add the tags used by DICOMImageBlockDescriptor dynamically instead of hard-coded
(look for ToDo around m_GDCMScanner.AddTag() in mitkDICOMITKSeriesGDCMReader.cpp)
[ ] Let DICOMImageBlockDescriptor describe attributes common and different for all blocks of a series
[ ] Let DICOMImageBlockDescriptor check image properties when mitk::Image is set (pre-loaded case)
diff --git a/Modules/DICOM/autoload/DICOMImageIO/include/mitkDICOMTagsOfInterestService.h b/Modules/DICOM/autoload/DICOMImageIO/include/mitkDICOMTagsOfInterestService.h
index d3eb0094d8..985d51e359 100644
--- a/Modules/DICOM/autoload/DICOMImageIO/include/mitkDICOMTagsOfInterestService.h
+++ b/Modules/DICOM/autoload/DICOMImageIO/include/mitkDICOMTagsOfInterestService.h
@@ -1,62 +1,62 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMTagsOfInterestService_h
#define mitkDICOMTagsOfInterestService_h
#include <string>
#include <mutex>
#include <vector>
#include <set>
#include <mitkIDICOMTagsOfInterest.h>
namespace mitk
{
/**
* \ingroup MicroServices_Interfaces
* \brief DICOM tags of interest service.
*
* This service allows you to manage the tags of interest (toi).
- * All registred toi will be extracted when loading dicom data and stored as properties in the corresponding
+ * All registered toi will be extracted when loading dicom data and stored as properties in the corresponding
* base data object. In addition the service can (if available) use IPropertyPersistance and IPropertyDescriptions
* to ensure that the tags of interests are also persisted and have a human readable descriptions.
*/
class DICOMTagsOfInterestService: public IDICOMTagsOfInterest
{
public:
DICOMTagsOfInterestService();
~DICOMTagsOfInterestService() override;
void AddTagOfInterest(const DICOMTagPath& tag, bool makePersistant = true) override;
DICOMTagPathMapType GetTagsOfInterest() const override;
bool HasTag(const DICOMTagPath& tag) const override;
void RemoveTag(const DICOMTagPath& tag) override;
void RemoveAllTags() override;
private:
typedef std::set<DICOMTagPath> InternalTagSetType;
typedef std::lock_guard<std::mutex> MutexHolder;
InternalTagSetType m_Tags;
mutable std::mutex m_Lock;
DICOMTagsOfInterestService(const DICOMTagsOfInterestService&);
DICOMTagsOfInterestService& operator=(const DICOMTagsOfInterestService&);
};
}
#endif
diff --git a/Modules/DICOM/include/mitkClassicDICOMSeriesReader.h b/Modules/DICOM/include/mitkClassicDICOMSeriesReader.h
index 4aa37c6118..9e970d6401 100644
--- a/Modules/DICOM/include/mitkClassicDICOMSeriesReader.h
+++ b/Modules/DICOM/include/mitkClassicDICOMSeriesReader.h
@@ -1,79 +1,79 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkClassicDICOMSeriesReader_h
#define mitkClassicDICOMSeriesReader_h
#include "mitkThreeDnTDICOMSeriesReader.h"
#include "MitkDICOMExports.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief Sorting and grouping like mitk::DicomSeriesReader until 2013.
This class implements the same functionality as the legacy class DicomSeriesReader,
- except that is is 75 lines instead of 2500 lines.
+ except that it is 75 lines instead of 2500 lines.
\warning Since the old class is known to have problems with some series,
it is advised to use a good configuration of DICOMITKSeriesGDCMReader,
which can be obtained by using DICOMFileReaderSelector.
The following text documents the actual sorting logic of this reader.
The class groups datasets that have different values in any of the following tags:
- (0028,0010) Number of Rows
- (0028,0011) Number of Columns
- (0028,0030) Pixel Spacing
- (0018,1164) Imager Pixel Spacing
- (0020,0037) %Image Orientation (Patient)
- (0018,0050) Slice Thickness
- (0028,0008) Number of Frames
- (0020,000e) Series Instance UID
Within each of the groups, datasets are sorted by the value of the following tags (primary sorting first):
- (0020,0032) %Image Position (Patient) (distance from zero along normal of (0020,0037) %Image Orientation (Patient))
- - (0020,0012) Aqcuisition Number
- - (0008,0032) Aqcuisition Time
+ - (0020,0012) Acquisition Number
+ - (0008,0032) Acquisition Time
- (0018,1060) Trigger Time
- (0008,0018) SOP Instance UID (last resort, not really meaningful but decides clearly)
If the series was acquired using a tilted gantry, this will be "fixed" by applying a shear transformation.
If multiple images occupy the same position in space, it is assumed that this indicated a 3D+t image.
*/
class MITKDICOM_EXPORT ClassicDICOMSeriesReader : public ThreeDnTDICOMSeriesReader
{
public:
mitkClassMacro( ClassicDICOMSeriesReader, DICOMITKSeriesGDCMReader );
mitkCloneMacro( ClassicDICOMSeriesReader );
itkNewMacro( ClassicDICOMSeriesReader );
bool operator==(const DICOMFileReader& other) const override;
protected:
ClassicDICOMSeriesReader();
~ClassicDICOMSeriesReader() override;
ClassicDICOMSeriesReader(const ClassicDICOMSeriesReader& other);
ClassicDICOMSeriesReader& operator=(const ClassicDICOMSeriesReader& other);
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMDCMTKTagScanner.h b/Modules/DICOM/include/mitkDICOMDCMTKTagScanner.h
index 248843d32c..953c842a37 100644
--- a/Modules/DICOM/include/mitkDICOMDCMTKTagScanner.h
+++ b/Modules/DICOM/include/mitkDICOMDCMTKTagScanner.h
@@ -1,95 +1,95 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMDCMTKTagScanner_h
#define mitkDICOMDCMTKTagScanner_h
#include <set>
#include "mitkDICOMTagScanner.h"
#include "mitkDICOMEnums.h"
#include "mitkDICOMGenericTagCache.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief Encapsulates the tag scanning process for a set of DICOM files.
For the scanning process it uses DCMTK functionality.
*/
class MITKDICOM_EXPORT DICOMDCMTKTagScanner : public DICOMTagScanner
{
public:
mitkClassMacro(DICOMDCMTKTagScanner, DICOMTagScanner);
itkFactorylessNewMacro( DICOMDCMTKTagScanner );
itkCloneMacro(Self);
/**
\brief Add this tag to the scanning process.
*/
void AddTag(const DICOMTag& tag) override;
/**
\brief Add a list of tags to the scanning process.
*/
void AddTags(const DICOMTagList& tags) override;
/**
\brief Add this tag path to the scanning process.
*/
void AddTagPath(const DICOMTagPath& tag) override;
/**
- \brief Add a list of tag pathes to the scanning process.
+ \brief Add a list of tag paths to the scanning process.
*/
void AddTagPaths(const DICOMTagPathList& tags) override;
/**
\brief Define the list of files to scan.
This does not ADD to an internal list, but it replaces the
whole list of files.
*/
void SetInputFiles(const StringList& filenames) override;
/**
\brief Start the scanning process.
Calling Scan() will invalidate previous scans, forgetting
all about files and tags from files that have been scanned
previously.
*/
void Scan() override;
/**
\brief Retrieve a result list for file-by-file tag access.
*/
DICOMDatasetAccessingImageFrameList GetFrameInfoList() const override;
/**
\brief Retrieve Pointer to the complete cache of the scan.
*/
DICOMTagCache::Pointer GetScanCache() const override;
protected:
DICOMDCMTKTagScanner();
~DICOMDCMTKTagScanner() override;
std::set<DICOMTagPath> m_ScannedTags;
StringList m_InputFilenames;
DICOMGenericTagCache::Pointer m_Cache;
private:
DICOMDCMTKTagScanner(const DICOMDCMTKTagScanner&);
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMDatasetAccess.h b/Modules/DICOM/include/mitkDICOMDatasetAccess.h
index 53b115ee5f..bd985d0d91 100644
--- a/Modules/DICOM/include/mitkDICOMDatasetAccess.h
+++ b/Modules/DICOM/include/mitkDICOMDatasetAccess.h
@@ -1,74 +1,74 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMDatasetAccess_h
#define mitkDICOMDatasetAccess_h
#include "mitkDICOMTag.h"
#include "mitkDICOMTagPath.h"
#include "MitkDICOMExports.h"
namespace mitk
{
/**
Helper class that is used for the result of DICOMDatasetAccess::GetTagValueAsString
*/
struct MITKDICOM_EXPORT DICOMDatasetFinding
{
/**Indicates if value is valid or not.*/
bool isValid;
/**The found value.*/
std::string value;
/**Tag path of the value*/
DICOMTagPath path;
DICOMDatasetFinding(bool valid = false, const std::string& aValue = "", const DICOMTagPath& aPath = DICOMTagPath()) : isValid(valid), value(aValue), path(aPath)
{};
};
/**
\ingroup DICOMModule
\brief Interface to datasets that is presented to sorting classes such as DICOMDatasetSorter.
Minimal interface to hide actual implementation, which might rely on GDCM.
*/
class MITKDICOM_EXPORT DICOMDatasetAccess
{
public:
typedef std::list<DICOMDatasetFinding> FindingsListType;
/// \brief Return a filename if possible.
/// If DICOM is not read from file but from somewhere else (network, database), we might not have files.
virtual std::string GetFilenameIfAvailable() const = 0;
/** \brief Return a DICOMDatasetFinding instance of the tag.
- The return containes (if valid) the raw value of the tag as a string.
- \param tag Tag which value should be retreived.
+ The return contains (if valid) the raw value of the tag as a string.
+ \param tag Tag which value should be retrieved.
*/
virtual DICOMDatasetFinding GetTagValueAsString(const DICOMTag& tag) const = 0;
/** \brief Return a list of DICOMDatasetFindings of the passed tag path.
- The return containes (if valid) the raw value of the tag as a string.
- \param path Tag path which value should be retreived.
+ The return contains (if valid) the raw value of the tag as a string.
+ \param path Tag path which value should be retrieved.
*/
virtual FindingsListType GetTagValueAsString(const DICOMTagPath& path) const = 0;
virtual ~DICOMDatasetAccess() {};
};
typedef std::vector<DICOMDatasetAccess*> DICOMDatasetList;
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMDatasetSorter.h b/Modules/DICOM/include/mitkDICOMDatasetSorter.h
index 98ae516a7d..c2b8ad4066 100644
--- a/Modules/DICOM/include/mitkDICOMDatasetSorter.h
+++ b/Modules/DICOM/include/mitkDICOMDatasetSorter.h
@@ -1,91 +1,91 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMDatasetSorter_h
#define mitkDICOMDatasetSorter_h
#include "itkObjectFactory.h"
#include "mitkCommon.h"
#include "mitkDICOMDatasetAccess.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief The sorting/splitting building-block of DICOMITKSeriesGDCMReader.
This class describes the interface of the sorting/splitting process
described as part of DICOMITKSeriesGDCMReader::AnalyzeInputFiles()
(see \ref DICOMITKSeriesGDCMReader_LoadingStrategy).
- The prodecure is simple:
+ The procedure is simple:
- take a list of input datasets (DICOMDatasetAccess)
- sort them (to be defined by sub-classes, based on specific tags)
- return the sorting result as outputs (the single input might be distributed into multiple outputs)
The simplest and most generic form of sorting is implemented in
sub-class DICOMTagBasedSorter.
*/
class MITKDICOM_EXPORT DICOMDatasetSorter : public itk::LightObject
{
public:
mitkClassMacroItkParent( DICOMDatasetSorter, itk::LightObject );
/**
\brief Return the tags of interest (to facilitate scanning)
*/
virtual DICOMTagList GetTagsOfInterest() = 0;
/// \brief Input for sorting
void SetInput(DICOMDatasetList filenames);
/// \brief Input for sorting
const DICOMDatasetList& GetInput() const;
/// \brief Sort input datasets into one or multiple outputs.
virtual void Sort() = 0;
/// \brief Output of the sorting process.
unsigned int GetNumberOfOutputs() const;
/// \brief Output of the sorting process.
const DICOMDatasetList& GetOutput(unsigned int index) const;
/// \brief Output of the sorting process.
DICOMDatasetList& GetOutput(unsigned int index);
/// \brief Print configuration details into stream.
virtual void PrintConfiguration(std::ostream& os, const std::string& indent = "") const = 0;
virtual bool operator==(const DICOMDatasetSorter& other) const = 0;
protected:
DICOMDatasetSorter();
~DICOMDatasetSorter() override;
DICOMDatasetSorter(const DICOMDatasetSorter& other);
DICOMDatasetSorter& operator=(const DICOMDatasetSorter& other);
void ClearOutputs();
void SetNumberOfOutputs(unsigned int numberOfOutputs);
void SetOutput(unsigned int index, const DICOMDatasetList& output);
private:
DICOMDatasetList m_Input;
std::vector< DICOMDatasetList > m_Outputs;
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMEnums.h b/Modules/DICOM/include/mitkDICOMEnums.h
index 51993a0f19..8c0890536e 100644
--- a/Modules/DICOM/include/mitkDICOMEnums.h
+++ b/Modules/DICOM/include/mitkDICOMEnums.h
@@ -1,64 +1,64 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMEnums_h
#define mitkDICOMEnums_h
#include <string>
#include <vector>
#include <utility>
namespace mitk
{
typedef std::vector<std::string> StringList;
typedef std::vector<bool> BoolList;
/**
\ingroup DICOMModule
\brief How the mitk::Image spacing should be interpreted (see mitk::DICOMFileReader).
Compare DICOM PS 3.3 10.7 (Basic Pixel Spacing Calibration Macro).
*/
typedef enum
{
SpacingInPatient, ///< distances are mm within a patient
SpacingAtDetector, ///< distances are mm at detector surface
SpacingUnknown ///< NO spacing information is present, we use (1,1) as default
} PixelSpacingInterpretation;
/**
\ingroup DICOMModule
\brief Describes how well the reader is tested for a certain file type (see mitk::DICOMFileReader).
Applications should not rely on the outcome for images which are reported
Implemented or Unsupported.
Errors to load images which are reported as Supported
are considered bugs. For PartlySupported please check the reader documentation on specifics.
*/
typedef enum
{
SOPClassSupported, ///< loader code and tests are established
- SOPClassPartlySupported, ///< loader code and tests are establised for specific parts of a SOP Class
+ SOPClassPartlySupported, ///< loader code and tests are established for specific parts of a SOP Class
SOPClassImplemented, ///< loader code is implemented but not accompanied by tests
SOPClassUnsupported, ///< loader code is not known to work with this SOP Class
SOPClassUnknown, ///< loader did not yet inspect any images, unknown fitness
} ReaderImplementationLevel;
/// Convert mitk::PixelSpacingInterpretation to a human readable string.
std::string PixelSpacingInterpretationToString(const PixelSpacingInterpretation& value);
/// Convert mitk::ReaderImplementationLevel to a human readable string.
std::string ReaderImplementationLevelToString( const ReaderImplementationLevel& enumValue );
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMFileReader.h b/Modules/DICOM/include/mitkDICOMFileReader.h
index 43f8bd7d91..1e5c48219d 100644
--- a/Modules/DICOM/include/mitkDICOMFileReader.h
+++ b/Modules/DICOM/include/mitkDICOMFileReader.h
@@ -1,169 +1,169 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMFileReader_h
#define mitkDICOMFileReader_h
#include "itkObjectFactory.h"
#include "mitkCommon.h"
#include "MitkDICOMExports.h"
#include "mitkDICOMTagCache.h"
#include "mitkDICOMImageBlockDescriptor.h"
#include <unordered_map>
namespace mitk
{
// TODO Philips3D!
// TODO http://bugs.mitk.org/show_bug.cgi?id=11572 ?
/**
\ingroup DICOMModule
\brief Interface for DICOM readers that produce mitk::Images.
As described in \ref DICOMModule, this class structures
the reader's part in the process of analyzing a set of DICOM files
and selecting the most appropriate reader.
The overall loading process is as follows:
- <b>Define input files</b>: a list of absolute filenames
- <b>Analyze the potential output</b>: see what can be made of the input files, describe with
DICOMImageBlockDescriptor%s
- <b>Load pixel data</b>: an application will usually analyze files using multiple readers and only load
with a single reader
Sub-classes are required to implement a number of methods that
reflect above structure. See mitk::DICOMITKSeriesGDCMReader for
an example.
To help applications in describing different readers to the user, each reader
brings a number of methods that describe its configuration/specifics by
means of a short label and a (longer) description.
*/
class MITKDICOM_EXPORT DICOMFileReader : public itk::Object
{
public:
mitkClassMacroItkParent( DICOMFileReader, itk::Object );
/// Test whether a file is DICOM at all
static bool IsDICOM( const std::string& filename );
/// Indicate whether this reader can handle given file
virtual bool CanHandleFile( const std::string& filename ) = 0;
/// This input files
void SetInputFiles( const StringList& filenames );
/// This input files
const StringList& GetInputFiles() const;
/// Analyze input files
virtual void AnalyzeInputFiles() = 0;
/// Number of outputs, only meaningful after calling AnalyzeInputFiles()
unsigned int GetNumberOfOutputs() const;
/// Individual outputs, only meaningful after calling AnalyzeInputFiles(). \throws std::invalid_argument
const DICOMImageBlockDescriptor& GetOutput( unsigned int index ) const;
// void AllocateOutputImages(); TODO for later implementation of slice-by-slice loading
/// Load the mitk::Image%s in our outputs, the DICOMImageBlockDescriptor. To be called only after
/// AnalyzeInputFiles(). Take care of potential exceptions!
virtual bool LoadImages() = 0;
virtual DICOMTagPathList GetTagsOfInterest() const = 0;
/// A way to provide external knowledge about files and tag values is appreciated.
virtual void SetTagCache( const DICOMTagCache::Pointer& ) = 0;
/// Short label/name to describe this reader
void SetConfigurationLabel( const std::string& );
/// Short label/name to describe this reader
std::string GetConfigurationLabel() const;
/// One-sentence description of the reader's loading "strategy"
void SetConfigurationDescription( const std::string& );
/// One-sentence description of the reader's loading "strategy"
std::string GetConfigurationDescription() const;
/// Print configuration description to given stream, for human reader
void PrintConfiguration( std::ostream& os ) const;
/// Print output description to given stream, for human reader
void PrintOutputs( std::ostream& os, bool filenameDetails = false ) const;
virtual bool operator==( const DICOMFileReader& other ) const = 0;
/** Type specifies additional tags of interest. Key is the tag path of interest.
* The value is an optional user defined name for the property that should be used to store the tag value(s).
* Empty value is default and will imply to use the found DICOMTagPath as property name.*/
typedef DICOMImageBlockDescriptor::AdditionalTagsMapType AdditionalTagsMapType;
/**
- * \brief Set a list of DICOMTagPaths that specifiy all DICOM-Tags that will be copied into the property of the mitk::Image.
+ * \brief Set a list of DICOMTagPaths that specify all DICOM-Tags that will be copied into the property of the mitk::Image.
*
* This method can be used to specify a list of DICOM-tags that shall be available after the loading.
* The value in the tagMap is an optional user defined name for the property key that should be used
* when storing the property). Empty value is default and will imply to use the found DICOMTagPath
* as property key.
* By default the content of the DICOM tags will be stored in a StringLookupTable on the mitk::Image.
* This behaviour can be changed by setting a different TagLookupTableToPropertyFunctor via
* SetTagLookupTableToPropertyFunctor().
*/
virtual void SetAdditionalTagsOfInterest(const AdditionalTagsMapType& tagList);
/**
* \brief Set a functor that defines how the slice-specific tag-values are stored in a Property.
*
* This method sets a functor that is given a StringLookupTable that contains the values of one DICOM tag
* mapped to the slice index.
* The functor is supposed to store these values in an mitk Property.
*
* By default, the StringLookupTable is stored in a StringLookupTableProperty except if all values are
* identical. In this case, the unique value is stored only once in a StringProperty.
*/
virtual void SetTagLookupTableToPropertyFunctor(
mitk::DICOMImageBlockDescriptor::TagLookupTableToPropertyFunctor functor );
protected:
DICOMFileReader();
~DICOMFileReader() override;
DICOMFileReader( const DICOMFileReader& other );
DICOMFileReader& operator=( const DICOMFileReader& other );
void ClearOutputs();
void SetNumberOfOutputs( unsigned int numberOfOutputs );
void SetOutput( unsigned int index, const DICOMImageBlockDescriptor& output );
/// non-const access to the DICOMImageBlockDescriptor
DICOMImageBlockDescriptor& InternalGetOutput( unsigned int index );
/// Configuration description for human reader, to be implemented by sub-classes
virtual void InternalPrintConfiguration( std::ostream& os ) const = 0;
virtual AdditionalTagsMapType GetAdditionalTagsOfInterest() const;
mitk::DICOMImageBlockDescriptor::TagLookupTableToPropertyFunctor GetTagLookupTableToPropertyFunctor() const;
private:
StringList m_InputFilenames;
std::vector<DICOMImageBlockDescriptor> m_Outputs;
std::string m_ConfigLabel;
std::string m_ConfigDescription;
AdditionalTagsMapType m_AdditionalTagsOfInterest;
mitk::DICOMImageBlockDescriptor::TagLookupTableToPropertyFunctor m_TagLookupTableToPropertyFunctor;
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMGDCMTagScanner.h b/Modules/DICOM/include/mitkDICOMGDCMTagScanner.h
index 4143554521..ea802ef49f 100644
--- a/Modules/DICOM/include/mitkDICOMGDCMTagScanner.h
+++ b/Modules/DICOM/include/mitkDICOMGDCMTagScanner.h
@@ -1,119 +1,119 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMGDCMTagScanner_h
#define mitkDICOMGDCMTagScanner_h
#include "mitkDICOMTagScanner.h"
#include "mitkDICOMEnums.h"
#include "mitkDICOMGDCMTagCache.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief Encapsulates the tag scanning process for a set of DICOM files.
Formerly integrated as a part of DICOMITKSeriesGDCMReader, the tag
scanning part has been factored out into this DICOMGDCMTagScanner class
in order to allow a single scan for multiple reader alternatives. This
helps much in the selection process of e.g. DICOMFileReaderSelector.
The class works similar to gdcm::Scanner, just with the MITK set of classes:
- add a number of DICOM tags that should be read
- set a list of files that should be scanned for named tags
- call Scan()
- retrieve the scan results
- via GetFrameInfoList() or
- via GetTagValue()
When used in a process where multiple classes will access the scan
results, care should be taken that all the tags and files of interest
are communicated to DICOMGDCMTagScanner before requesting the results!
@remark This scanner does only support the scanning for simple value tag.
If you need to scann for sequence items or non-top-level elements, this scanner
will not be sufficient. See i.a. DICOMDCMTKTagScanner for these cases.
*/
class MITKDICOM_EXPORT DICOMGDCMTagScanner : public DICOMTagScanner
{
public:
mitkClassMacro(DICOMGDCMTagScanner, DICOMTagScanner);
itkFactorylessNewMacro( DICOMGDCMTagScanner );
itkCloneMacro(Self);
/**
\brief Add this tag to the scanning process.
*/
void AddTag(const DICOMTag& tag) override;
/**
\brief Add a list of tags to the scanning process.
*/
void AddTags(const DICOMTagList& tags) override;
/**
\brief Add this tag path to the scanning process.
*/
void AddTagPath(const DICOMTagPath& tag) override;
/**
- \brief Add a list of tag pathes to the scanning process.
+ \brief Add a list of tag paths to the scanning process.
*/
void AddTagPaths(const DICOMTagPathList& tags) override;
/**
\brief Define the list of files to scan.
This does not ADD to an internal list, but it replaces the
whole list of files.
*/
void SetInputFiles(const StringList& filenames) override;
/**
\brief Start the scanning process.
Calling Scan() will invalidate previous scans, forgetting
all about files and tags from files that have been scanned
previously.
*/
void Scan() override;
/**
\brief Retrieve a result list for file-by-file tag access.
*/
DICOMDatasetAccessingImageFrameList GetFrameInfoList() const override;
/**
\brief Retrieve Pointer to the complete cache of the scan.
*/
DICOMTagCache::Pointer GetScanCache() const override;
/**
\brief Directly retrieve the tag value for a given frame and tag.
@pre Scan() must have been called before calling this function.
*/
virtual DICOMDatasetFinding GetTagValue(DICOMImageFrameInfo* frame, const DICOMTag& tag) const;
protected:
DICOMGDCMTagScanner();
~DICOMGDCMTagScanner() override;
std::set<DICOMTag> m_ScannedTags;
StringList m_InputFilenames;
DICOMGDCMTagCache::Pointer m_Cache;
std::shared_ptr<gdcm::Scanner> m_GDCMScanner;
private:
DICOMGDCMTagScanner(const DICOMGDCMTagScanner&);
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMITKSeriesGDCMReader.h b/Modules/DICOM/include/mitkDICOMITKSeriesGDCMReader.h
index cf01900334..62b242f8d3 100644
--- a/Modules/DICOM/include/mitkDICOMITKSeriesGDCMReader.h
+++ b/Modules/DICOM/include/mitkDICOMITKSeriesGDCMReader.h
@@ -1,377 +1,377 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMITKSeriesGDCMReader_h
#define mitkDICOMITKSeriesGDCMReader_h
#include <mutex>
#include <stack>
#include "mitkDICOMFileReader.h"
#include "mitkDICOMDatasetSorter.h"
#include "mitkDICOMGDCMImageFrameInfo.h"
#include "mitkEquiDistantBlocksSorter.h"
#include "mitkNormalDirectionConsistencySorter.h"
#include "MitkDICOMExports.h"
namespace itk
{
class TimeProbesCollectorBase;
}
namespace mitk
{
/**
\ingroup DICOMModule
\brief Flexible reader based on itk::ImageSeriesReader and GDCM, for single-slice modalities like CT, MR, PET, CR, etc.
Implements the loading processed as structured by DICOMFileReader offers configuration
of its loading strategy.
Documentation sections:
- \ref DICOMITKSeriesGDCMReader_LoadingStrategy
- \ref DICOMITKSeriesGDCMReader_ForcedConfiguration
- \ref DICOMITKSeriesGDCMReader_UserConfiguration
- \ref DICOMITKSeriesGDCMReader_GantryTilt
- \ref DICOMITKSeriesGDCMReader_Testing
- \ref DICOMITKSeriesGDCMReader_Internals
- \ref DICOMITKSeriesGDCMReader_RelatedClasses
- \ref DICOMITKSeriesGDCMReader_TiltInternals
- \ref DICOMITKSeriesGDCMReader_Condensing
\section DICOMITKSeriesGDCMReader_LoadingStrategy Loading strategy
The set of input files is processed by a number of DICOMDatasetSorter objects which may do two sort of things:
1. split a list of input frames into multiple lists, based on DICOM tags such as "Rows", "Columns", which cannot be mixed within a single mitk::Image
2. sort the frames within the input lists, based on the values of DICOM tags such as "Image Position Patient"
When the DICOMITKSeriesGDCMReader is configured with DICOMDatasetSorter%s, the list of input files is processed
as follows:
1. build an initial set of output groups, simply by grouping all input files.
2. for each configured DICOMDatasetSorter, process:
- for each output group:
1. set this group's files as input to the sorter
2. let the sorter sort (and split)
3. integrate the sorter's output groups with our own output groups
\section DICOMITKSeriesGDCMReader_ForcedConfiguration Forced Configuration
In all cases, the reader will add two DICOMDatasetSorter objects that are required to load
mitk::Images properly via itk::ImageSeriesReader:
1. As a \b first step, the input files will be split into groups that are not compatible because they differ in essential aspects:
- (0028,0010) Number of Rows
- (0028,0011) Number of Columns
- (0028,0030) Pixel Spacing
- (0018,1164) Imager Pixel Spacing
- (0020,0037) %Image Orientation (Patient)
- (0018,0050) Slice Thickness
- (0028,0008) Number of Frames
2. As are two forced \b last steps:
1. There will always be an instance of EquiDistantBlocksSorter,
which ensures that there is an equal distance between all the frames of an Image.
This is required to achieve correct geometrical positions in the mitk::Image,
i.e. it is essential to be able to make measurements in images.
- whether or not the distance is required to be orthogonal to the image planes is configured by SetFixTiltByShearing().
- during this check, we need to tolerate some minor errors in documented vs. calculated image origins.
The amount of tolerance can be adjusted by SetToleratedOriginOffset() and SetToleratedOriginOffsetToAdaptive().
Please see EquiDistantBlocksSorter for more details. The default should be good for most cases.
2. There is always an instance of NormalDirectionConsistencySorter,
which makes the order of images go along the image normals (see NormalDirectionConsistencySorter)
\section DICOMITKSeriesGDCMReader_UserConfiguration User Configuration
The user of this class can add more sorting steps (similar to the one described in above section) by calling AddSortingElement().
Usually, an application will add sorting by "Image Position Patient", by "Instance Number", and by other relevant tags here.
\section DICOMITKSeriesGDCMReader_GantryTilt Gantry tilt handling
When CT gantry tilt is used, the gantry plane (= X-Ray source and detector ring) and the vertical plane do not align
- anymore. This scanner feature is used for example to reduce metal artifacs (e.g. <i>Lee C , Evaluation of Using CT
+ anymore. This scanner feature is used for example to reduce metal artifacts (e.g. <i>Lee C , Evaluation of Using CT
Gantry Tilt Scan on Head and Neck Cancer Patients with Dental Structure: Scans Show Less Metal Artifacts. Presented
at: Radiological Society of North America 2011 Scientific Assembly and Annual Meeting; November 27- December 2,
2011 Chicago IL.</i>).
The acquired planes of such CT series do not match the expectations of a orthogonal geometry in mitk::Image: if you
stack the slices, they show a small shift along the Y axis:
\verbatim
without tilt with tilt
|||||| //////
|||||| //////
-- |||||| --------- ////// -------- table orientation
|||||| //////
|||||| //////
Stacked slices:
without tilt with tilt
-------------- --------------
-------------- --------------
-------------- --------------
-------------- --------------
-------------- --------------
\endverbatim
As such gemetries do not "work" in conjunction with mitk::Image, DICOMITKSeriesGDCMReader is able to perform a correction for such series.
Whether or not such correction should be attempted is controlled by SetFixTiltByShearing(), the default being correction.
For details, see "Internals" below.
\section DICOMITKSeriesGDCMReader_Testing Testing
A number of tests is implemented in module DICOMTesting, which is documented at \ref DICOMTesting.
\section DICOMITKSeriesGDCMReader_Internals Class internals
Internally, the class is based on GDCM and it depends heavily on the gdcm::Scanner class.
Since the sorting elements (see DICOMDatasetSorter and DICOMSortCriterion) can access tags only via the DICOMDatasetAccess interface,
BUT DICOMITKSeriesGDCMReader holds a list of more specific classes DICOMGDCMImageFrameInfo, we must convert between the two
types sometimes. This explains the methods ToDICOMDatasetList(), FromDICOMDatasetList().
The intermediate result of all the sorting efforts is held in m_SortingResultInProgress,
which is modified through InternalExecuteSortingStep().
\subsection DICOMITKSeriesGDCMReader_RelatedClasses Overview of related classes
The following diagram gives an overview of the related classes:
\image html implementeditkseriesgdcmreader.jpg
\subsection DICOMITKSeriesGDCMReader_TiltInternals Details about the tilt correction
The gantry tilt "correction" algorithm fixes two errors introduced by ITK's ImageSeriesReader:
- the plane shift that is ignored by ITK's reader is recreated by applying a shearing transformation using itk::ResampleFilter.
- the spacing is corrected (it is calculated by ITK's reader from the distance between two origins, which is NOT the slice distance in this special case)
Both errors are introduced in
itkImageSeriesReader.txx (ImageSeriesReader<TOutputImage>::GenerateOutputInformation(void)), lines 176 to 245 (as of ITK 3.20)
For the correction, we examine two consecutive slices of a series, both described as a pair (origin/orientation):
- we calculate if the first origin is on a line along the normal of the second slice
- if this is not the case, the geometry will not fit a normal mitk::Image/mitk::%Geometry3D
- we then project the second origin into the first slice's coordinate system to quantify the shift
- both is done in class GantryTiltInformation with quite some comments.
The geometry of image stacks with tilted geometries is illustrated below:
- green: the DICOM images as described by their tags: origin as a point with the line indicating the orientation
- red: the output of ITK ImageSeriesReader: wrong, larger spacing, no tilt
- blue: how much a shear must correct
\image html Modules/DICOM/doc/Doxygen/tilt-correction.jpg
\subsection DICOMITKSeriesGDCMReader_Condensing Sub-classes can condense multiple blocks into a single larger block
The sorting/splitting process described above is helpful for at least two more DICOM readers, which either try to load 3D+t images or which load diffusion data.
In both cases, a single pixel of the mitk::Image is made up of multiple values, in one case values over time, in the other case multiple measurements of a single point.
The specialized readers for these cases (e.g. ThreeDnTDICOMSeriesReader) can reuse most of the methods in DICOMITKSeriesGDCMReader,
except that they need an extra step after the usual sorting, in which they can merge already grouped 3D blocks. What blocks are merged
depends on the specialized reader's understanding of these images. To allow for such merging, a method Condense3DBlocks() is called
as an absolute last step of AnalyzeInputFiles(). Given this, a sub-class could implement only LoadImages() and Condense3DBlocks() instead
repeating most of AnalyzeInputFiles().
*/
class MITKDICOM_EXPORT DICOMITKSeriesGDCMReader : public DICOMFileReader
{
public:
mitkClassMacro( DICOMITKSeriesGDCMReader, DICOMFileReader );
mitkCloneMacro( DICOMITKSeriesGDCMReader );
itkFactorylessNewMacro( DICOMITKSeriesGDCMReader );
mitkNewMacro1Param( DICOMITKSeriesGDCMReader, unsigned int );
mitkNewMacro2Param( DICOMITKSeriesGDCMReader, unsigned int, bool );
/**
\brief Runs the sorting / splitting process described in \ref DICOMITKSeriesGDCMReader_LoadingStrategy.
Method required by DICOMFileReader.
*/
void AnalyzeInputFiles() override;
// void AllocateOutputImages();
/**
\brief Loads images using itk::ImageSeriesReader, potentially applies shearing to correct gantry tilt.
*/
bool LoadImages() override;
// re-implemented from super-class
bool CanHandleFile(const std::string& filename) override;
/**
\brief Add an element to the sorting procedure described in \ref DICOMITKSeriesGDCMReader_LoadingStrategy.
*/
virtual void AddSortingElement(DICOMDatasetSorter* sorter, bool atFront = false);
typedef const std::list<DICOMDatasetSorter::ConstPointer> ConstSorterList;
ConstSorterList GetFreelyConfiguredSortingElements() const;
/**
\brief Controls whether to "fix" tilted acquisitions by shearing the output (see \ref DICOMITKSeriesGDCMReader_GantryTilt).
*/
void SetFixTiltByShearing(bool on);
bool GetFixTiltByShearing() const;
/**
\brief Controls whether groups of only two images are accepted when ensuring consecutive slices via EquiDistantBlocksSorter.
*/
void SetAcceptTwoSlicesGroups(bool accept) const;
bool GetAcceptTwoSlicesGroups() const;
/**
\brief See \ref DICOMITKSeriesGDCMReader_ForcedConfiguration.
*/
void SetToleratedOriginOffsetToAdaptive(double fractionOfInterSliceDistanct = 0.3) const;
/**
\brief See \ref DICOMITKSeriesGDCMReader_ForcedConfiguration.
*/
void SetToleratedOriginOffset(double millimeters = 0.005) const;
/**
\brief Ignore all dicom tags that are non-essential for simple 3D volume import.
*/
void SetSimpleVolumeReading(bool read)
{
m_SimpleVolumeReading = read;
};
/**
\brief Ignore all dicom tags that are non-essential for simple 3D volume import.
*/
bool GetSimpleVolumeReading()
{
return m_SimpleVolumeReading;
};
double GetToleratedOriginError() const;
bool IsToleratedOriginOffsetAbsolute() const;
double GetDecimalPlacesForOrientation() const;
bool operator==(const DICOMFileReader& other) const override;
DICOMTagPathList GetTagsOfInterest() const override;
static int GetDefaultDecimalPlacesForOrientation()
{
return m_DefaultDecimalPlacesForOrientation;
}
static bool GetDefaultSimpleVolumeImport()
{
return m_DefaultSimpleVolumeImport;
}
static bool GetDefaultFixTiltByShearing()
{
return m_DefaultFixTiltByShearing;
}
protected:
void InternalPrintConfiguration(std::ostream& os) const override;
/// \brief Return active C locale
static std::string GetActiveLocale();
/**
\brief Remember current locale on stack, activate "C" locale.
"C" locale is required for correct parsing of numbers by itk::ImageSeriesReader
*/
void PushLocale() const;
/**
\brief Activate last remembered locale from locale stack
"C" locale is required for correct parsing of numbers by itk::ImageSeriesReader
*/
void PopLocale() const;
const static int m_DefaultDecimalPlacesForOrientation = 5;
const static bool m_DefaultSimpleVolumeImport = false;
const static bool m_DefaultFixTiltByShearing = true;
DICOMITKSeriesGDCMReader(unsigned int decimalPlacesForOrientation = m_DefaultDecimalPlacesForOrientation, bool simpleVolumeImport = m_DefaultSimpleVolumeImport);
~DICOMITKSeriesGDCMReader() override;
DICOMITKSeriesGDCMReader(const DICOMITKSeriesGDCMReader& other);
DICOMITKSeriesGDCMReader& operator=(const DICOMITKSeriesGDCMReader& other);
typedef std::vector<DICOMDatasetAccessingImageFrameList> SortingBlockList;
/**
\brief "Hook" for sub-classes, see \ref DICOMITKSeriesGDCMReader_Condensing
\return REMAINING blocks
*/
virtual SortingBlockList Condense3DBlocks(SortingBlockList& resultOf3DGrouping);
virtual DICOMTagCache::Pointer GetTagCache() const;
void SetTagCache( const DICOMTagCache::Pointer& ) override;
/// \brief Sorting step as described in \ref DICOMITKSeriesGDCMReader_LoadingStrategy
static SortingBlockList InternalExecuteSortingStep(
unsigned int sortingStepIndex,
const DICOMDatasetSorter::Pointer& sorter,
const SortingBlockList& input);
/// \brief Loads the mitk::Image by means of an itk::ImageSeriesReader
virtual bool LoadMitkImageForOutput(unsigned int o);
virtual bool LoadMitkImageForImageBlockDescriptor(DICOMImageBlockDescriptor& block) const;
/// \brief Describe this reader's confidence for given SOP class UID
static ReaderImplementationLevel GetReaderImplementationLevel(const std::string sopClassUID);
private:
/// \brief Creates the required sorting steps described in \ref DICOMITKSeriesGDCMReader_ForcedConfiguration
void EnsureMandatorySortersArePresent(unsigned int decimalPlacesForOrientation, bool simpleVolumeImport = false);
protected:
// NOT nice, made available to ThreeDnTDICOMSeriesReader due to lack of time
bool m_FixTiltByShearing; // could be removed by ITKDICOMSeriesReader NOT flagging tilt unless requested to fix it!
bool m_SimpleVolumeReading;
private:
SortingBlockList m_SortingResultInProgress;
typedef std::list<DICOMDatasetSorter::Pointer> SorterList;
SorterList m_Sorter;
protected:
// NOT nice, made available to ThreeDnTDICOMSeriesReader and ClassicDICOMSeriesReader due to lack of time
mitk::EquiDistantBlocksSorter::Pointer m_EquiDistantBlocksSorter;
mitk::NormalDirectionConsistencySorter::Pointer m_NormalDirectionConsistencySorter;
private:
static std::mutex s_LocaleMutex;
mutable std::stack<std::string> m_ReplacedCLocales;
mutable std::stack<std::locale> m_ReplacedCinLocales;
double m_DecimalPlacesForOrientation;
DICOMTagCache::Pointer m_TagCache;
bool m_ExternalCache;
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMImageBlockDescriptor.h b/Modules/DICOM/include/mitkDICOMImageBlockDescriptor.h
index 81112d3e91..db2a634911 100644
--- a/Modules/DICOM/include/mitkDICOMImageBlockDescriptor.h
+++ b/Modules/DICOM/include/mitkDICOMImageBlockDescriptor.h
@@ -1,237 +1,237 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMImageBlockDescriptor_h
#define mitkDICOMImageBlockDescriptor_h
#include "mitkDICOMEnums.h"
#include "mitkDICOMImageFrameInfo.h"
#include "mitkDICOMTag.h"
#include "mitkDICOMTagCache.h"
#include "mitkImage.h"
#include "mitkProperties.h"
#include "mitkWeakPointer.h"
#include "mitkIPropertyProvider.h"
#include "mitkGantryTiltInformation.h"
#include <unordered_map>
namespace mitk
{
struct DICOMCachedValueInfo
{
unsigned int TimePoint;
unsigned int SliceInTimePoint;
std::string Value;
};
class DICOMCachedValueLookupTable : public GenericLookupTable< DICOMCachedValueInfo >
{
public:
typedef DICOMCachedValueLookupTable Self;
typedef GenericLookupTable< DICOMCachedValueInfo > Superclass;
const char *GetNameOfClass() const override
{
return "DICOMCachedValueLookupTable";
}
DICOMCachedValueLookupTable() {}
Superclass& operator=(const Superclass& other) override { return Superclass::operator=(other); }
~DICOMCachedValueLookupTable() override {}
};
/**
\ingroup DICOMModule
\brief Output descriptor for DICOMFileReader.
As a result of analysis by a mitk::DICOMFileReader, this class
describes the properties of a single mitk::Images that could
be loaded by the file reader.
The descriptor contains the following information:
- the mitk::Image itself. This will be nullptr after analysis and only be present after actual loading.
- a list of frames (mostly: filenames) that went into composition of the mitk::Image.
- an assessment of the reader's ability to load this set of files (ReaderImplementationLevel)
- this can be used for reader selection when one reader is able to load an image with correct colors and the other is able to produce only gray values, for example
- description of aspects of the image. Mostly a key-value list implemented by means of mitk::PropertyList.
- for specific keys and possible values, see documentation of specific readers.
\note an mitk::Image may both consist of multiple files (the "old" DICOM way) or a mitk::Image may be described by a single DICOM file or even only parts of a DICOM file (the newer multi-frame DICOM classes). To reflect this DICOMImageFrameList describes a list of frames from different or a single file.
Described aspects of an image are:
- whether pixel spacing is meant to be in-patient or on-detector (mitk::PixelSpacingInterpretation)
- details about a possible gantry tilt (intended for use by file readers, may be hidden later)
*/
class MITKDICOM_EXPORT DICOMImageBlockDescriptor: public IPropertyProvider
{
public:
DICOMImageBlockDescriptor();
~DICOMImageBlockDescriptor() override;
DICOMImageBlockDescriptor(const DICOMImageBlockDescriptor& other);
DICOMImageBlockDescriptor& operator=(const DICOMImageBlockDescriptor& other);
static DICOMTagList GetTagsOfInterest();
/// List of frames that constitute the mitk::Image (DICOMImageFrame%s)
void SetImageFrameList(const DICOMImageFrameList& framelist);
/// List of frames that constitute the mitk::Image (DICOMImageFrame%s)
const DICOMImageFrameList& GetImageFrameList() const;
/// The 3D mitk::Image that is loaded from the DICOM files of a DICOMImageFrameList
void SetMitkImage(Image::Pointer image);
/// the 3D mitk::Image that is loaded from the DICOM files of a DICOMImageFrameList
Image::Pointer GetMitkImage() const;
/// Reader's capability to appropriately load this set of frames
ReaderImplementationLevel GetReaderImplementationLevel() const;
/// Reader's capability to appropriately load this set of frames
void SetReaderImplementationLevel(const ReaderImplementationLevel& level);
/// Key-value store describing aspects of the image to be loaded
void SetProperty(const std::string& key, BaseProperty* value);
/// Key-value store describing aspects of the image to be loaded
BaseProperty* GetProperty(const std::string& key) const;
/// Convenience function around GetProperty()
std::string GetPropertyAsString(const std::string&) const;
/// Convenience function around SetProperty()
void SetFlag(const std::string& key, bool value);
/// Convenience function around GetProperty()
bool GetFlag(const std::string& key, bool defaultValue) const;
/// Convenience function around SetProperty()
void SetIntProperty(const std::string& key, int value);
/// Convenience function around GetProperty()
int GetIntProperty(const std::string& key, int defaultValue) const;
BaseProperty::ConstPointer GetConstProperty(const std::string &propertyKey,
const std::string &contextName = "",
bool fallBackOnDefaultContext = true) const override;
std::vector<std::string> GetPropertyKeys(const std::string &contextName = "",
bool includeDefaultContext = false) const override;
std::vector<std::string> GetPropertyContextNames() const override;
private:
// For future implementation: load slice-by-slice, mark this using these methods
void SetSliceIsLoaded(unsigned int index, bool isLoaded);
// For future implementation: load slice-by-slice, mark this using these methods
bool IsSliceLoaded(unsigned int index) const;
// For future implementation: load slice-by-slice, mark this using these methods
bool AllSlicesAreLoaded() const;
public:
/// Describe how the mitk::Image's pixel spacing should be interpreted
PixelSpacingInterpretation GetPixelSpacingInterpretation() const;
/// Describe the correct x/y pixel spacing of the mitk::Image (which some readers might need to adjust after loading)
void GetDesiredMITKImagePixelSpacing(ScalarType& spacingXinMM, ScalarType& spacingYinMM) const;
/// Describe the gantry tilt of the acquisition
void SetTiltInformation(const GantryTiltInformation& info);
/// Describe the gantry tilt of the acquisition
const GantryTiltInformation GetTiltInformation() const;
/// SOP Class UID of this set of frames
void SetSOPClassUID(const std::string& uid);
/// SOP Class UID of this set of frames
std::string GetSOPClassUID() const;
/// SOP Class as human readable name (e.g. "CT Image Storage")
std::string GetSOPClassUIDAsName() const;
- /**Convinience method that returns the property timesteps*/
+ /**Convenience method that returns the property timesteps*/
int GetNumberOfTimeSteps() const;
/**return the number of frames that constitute one timestep.*/
int GetNumberOfFramesPerTimeStep() const;
void SetTagCache(DICOMTagCache* privateCache);
/** Type specifies additional tags of interest. Key is the tag path of interest.
* The value is an optional user defined name for the property that should be used to store the tag value(s).
* Empty value is default and will imply to use the found DICOMTagPath as property name.*/
typedef std::map<DICOMTagPath, std::string> AdditionalTagsMapType;
/**
- * \brief Set a list of DICOMTagPaths that specifiy all DICOM-Tags that will be copied into the property of the mitk::Image.
+ * \brief Set a list of DICOMTagPaths that specify all DICOM-Tags that will be copied into the property of the mitk::Image.
*
* This method can be used to specify a list of DICOM-tags that shall be available after the loading.
* The value in the tagMap is an optional user defined name for the property key that should be used
* when storing the property). Empty value is default and will imply to use the found DICOMTagPath
* as property key.
* By default the content of the DICOM tags will be stored in a StringLookupTable on the mitk::Image.
* This behaviour can be changed by setting a different TagLookupTableToPropertyFunctor via
* SetTagLookupTableToPropertyFunctor().
*/
void SetAdditionalTagsOfInterest(const AdditionalTagsMapType& tagMap);
typedef std::function<mitk::BaseProperty::Pointer(const DICOMCachedValueLookupTable&) > TagLookupTableToPropertyFunctor;
/**
* \brief Set a functor that defines how the slice-specific tag-values are stored in a Property.
*
* This method sets a functor that is given a StringLookupTable that contains the values of one DICOM tag
* mapped to the slice index.
* The functor is supposed to store these values in an mitk Property.
*
* By default, the StringLookupTable is stored in a StringLookupTableProperty except if all values are
* identical. In this case, the unique value is stored only once in a StringProperty.
*/
void SetTagLookupTableToPropertyFunctor(TagLookupTableToPropertyFunctor);
/// Print information about this image block to given stream
void Print(std::ostream& os, bool filenameDetails) const;
private:
// read values from tag cache
std::string GetPixelSpacing() const;
std::string GetImagerPixelSpacing() const;
Image::Pointer FixupSpacing(Image* mitkImage);
Image::Pointer DescribeImageWithProperties(Image* mitkImage);
void UpdateImageDescribingProperties() const;
static mitk::BaseProperty::Pointer GetPropertyForDICOMValues(const DICOMCachedValueLookupTable& cacheLookupTable);
double stringtodouble(const std::string& str) const;
DICOMImageFrameList m_ImageFrameList;
Image::Pointer m_MitkImage;
BoolList m_SliceIsLoaded;
ReaderImplementationLevel m_ReaderImplementationLevel;
GantryTiltInformation m_TiltInformation;
PropertyList::Pointer m_PropertyList;
mitk::WeakPointer<DICOMTagCache> m_TagCache;
mutable bool m_PropertiesOutOfDate;
AdditionalTagsMapType m_AdditionalTagMap;
std::set<std::string> m_FoundAdditionalTags;
TagLookupTableToPropertyFunctor m_PropertyFunctor;
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMReaderConfigurator.h b/Modules/DICOM/include/mitkDICOMReaderConfigurator.h
index 00da6131c2..2110a9fad4 100644
--- a/Modules/DICOM/include/mitkDICOMReaderConfigurator.h
+++ b/Modules/DICOM/include/mitkDICOMReaderConfigurator.h
@@ -1,145 +1,145 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMReaderConfigurator_h
#define mitkDICOMReaderConfigurator_h
#include "mitkClassicDICOMSeriesReader.h"
#include "mitkDICOMTagBasedSorter.h"
namespace tinyxml2
{
class XMLDocument;
class XMLElement;
}
namespace mitk
{
/**
\ingroup DICOMModule
\brief Too-simple factory to create DICOMFileReader%s.
This class is able to instantiate and configure (where possible) DICOMFileReader%s from XML descriptions.
\note This is a bad factory example, because the factory is not extensible and needs to know all the specific readers. A flexible implementation should be provided in a future version.
In its current version, the XML input is meant to be structured like
\verbatim
<?xml version="1.0" standalone=no>
<DICOMFileReader
label="Example Reader"
description="Sort images by example tags"
class="DICOMITKSeriesGDCMReader"
fixTiltByShearing="true">
<Distinguishing>
<Tag name="SeriesInstanceUID" group="0020" element="000e"/>
<Tag name="SeriesNumber" group="0020" element="0011"/>
</Distinguishing>
<Sorting>
<ImagePositionPatient/>
<Tag name="SOPInstanceUID" group="0x0008" element="0x0018"/>
</Sorting>
</DICOMFileReader>
\endverbatim
The root-tag \c \<DICOMFileReader\> names the class to be instantiated, currently this can be one of
- DICOMITKSeriesGDCMReader
- ThreeDnTDICOMSeriesReader
Both classes bring simple configuration flags with them and a description of how images are sorted prior to loading.
Flag for DICOMITKSeriesGDCMReader:
<pre>fixTiltByShearing="true|false"</pre>
Determines whether a potential gantry tilt should be "fixed" by shearing the output image.
Flag for ThreeDnTDICOMSeriesReader:
<pre>group3DnT="true|false"</pre>
Determines whether images at the same spatial position should be interpreted as 3D+t images.
The tags \c \<Distinguishing\> and \c \<Sorting\> describe the basic loading strategy of both
reader mentioned above: first images are divided into incompatible groups (\c \<Distinguishing\>),
and afterwards the images within each group are sorted by means of DICOMSortCriterion, which
most commonly mentions a tag.
Tag element and group are interpreted as the exadecimal numbers
found all around the DICOM standard. The numbers can be prepended by a "0x" if this is preferred
by the programmer (but they are taken as hexadecimal in all cases).
\section DICOMReaderConfigurator_AboutTheFuture About the future evolution of this class
This first version is hard coded for the current state of the implementation.
- If things should evolve in a way that needs us to splitt off readers for "old" versions,
+ If things should evolve in a way that needs us to split off readers for "old" versions,
time should be taken to refactor this class.
Basically, a serializer class should accompany each of the configurable classes. Such
serializer classes should be registered and discovered via micro-services (to support extensions).
A serializer should offer both methods to serialize a class and to desirialize it again.
A "version" attribute at the top-level tag should be used to distinguish versions.
Usually it should be enough to keep DE-serializers for all versions. Writers for the most
recent version should be enough.
*/
class MITKDICOM_EXPORT DICOMReaderConfigurator : public itk::LightObject
{
public:
mitkClassMacroItkParent( DICOMReaderConfigurator, itk::LightObject );
itkNewMacro( DICOMReaderConfigurator );
DICOMFileReader::Pointer CreateFromConfigFile(const std::string& filename) const;
DICOMFileReader::Pointer CreateFromUTF8ConfigString(const std::string& xmlContents) const;
std::string CreateConfigStringFromReader(DICOMFileReader::ConstPointer reader) const;
protected:
DICOMReaderConfigurator();
~DICOMReaderConfigurator() override;
private:
DICOMFileReader::Pointer CreateFromXMLDocument(tinyxml2::XMLDocument& doc) const;
DICOMTag tagFromXMLElement(const tinyxml2::XMLElement*) const;
std::string requiredStringAttribute(const tinyxml2::XMLElement* xmlElement, const std::string& key) const;
unsigned int hexStringToUInt(const std::string& s) const;
ThreeDnTDICOMSeriesReader::Pointer ConfigureThreeDnTDICOMSeriesReader(ThreeDnTDICOMSeriesReader::Pointer reader, const tinyxml2::XMLElement*) const;
DICOMITKSeriesGDCMReader::Pointer ConfigureDICOMITKSeriesGDCMReader(DICOMITKSeriesGDCMReader::Pointer reader, const tinyxml2::XMLElement*) const;
void ConfigureCommonPropertiesOfDICOMITKSeriesGDCMReader(DICOMITKSeriesGDCMReader::Pointer reader, const tinyxml2::XMLElement* element) const;
void ConfigureCommonPropertiesOfThreeDnTDICOMSeriesReader(ThreeDnTDICOMSeriesReader::Pointer reader, const tinyxml2::XMLElement* element) const;
DICOMSortCriterion::Pointer CreateDICOMSortByTag(const tinyxml2::XMLElement* xmlElement, DICOMSortCriterion::Pointer secondaryCriterion) const;
DICOMSortCriterion::Pointer CreateSortByImagePositionPatient(const tinyxml2::XMLElement* xmlElement, DICOMSortCriterion::Pointer secondaryCriterion) const;
mitk::DICOMTagBasedSorter::Pointer CreateDICOMTagBasedSorter(const tinyxml2::XMLElement* element) const;
tinyxml2::XMLElement* CreateConfigStringFromReader(tinyxml2::XMLDocument& doc, const DICOMITKSeriesGDCMReader* reader) const;
tinyxml2::XMLElement* CreateConfigStringFromReader(tinyxml2::XMLDocument& doc, const ThreeDnTDICOMSeriesReader* reader) const;
tinyxml2::XMLElement* CreateConfigStringFromReader(tinyxml2::XMLDocument& doc, const ClassicDICOMSeriesReader* reader) const;
tinyxml2::XMLElement* CreateConfigStringFromDICOMDatasetSorter(tinyxml2::XMLDocument& doc, const DICOMTagBasedSorter* sorter) const;
tinyxml2::XMLElement* CreateConfigStringFromDICOMTag(tinyxml2::XMLDocument& doc, const DICOMTag& tag) const;
tinyxml2::XMLElement* CreateDICOMFileReaderTag(tinyxml2::XMLDocument& doc, const DICOMFileReader* reader) const;
std::string toHexString(unsigned int i) const;
/** Helper that queries an boolean xml attribute. If the attribute does not exist, the passed default value is used.*/
bool QueryBooleanAttribute(const tinyxml2::XMLElement* element, const char* attributeName, bool defaultValue) const;
};
} // namespace
#endif // mitkDICOMReaderConfigurator_h
diff --git a/Modules/DICOM/include/mitkDICOMSortByTag.h b/Modules/DICOM/include/mitkDICOMSortByTag.h
index e84efb6435..40f4bb05cc 100644
--- a/Modules/DICOM/include/mitkDICOMSortByTag.h
+++ b/Modules/DICOM/include/mitkDICOMSortByTag.h
@@ -1,68 +1,68 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMSortByTag_h
#define mitkDICOMSortByTag_h
#include "mitkDICOMSortCriterion.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief Compare two datasets by the value of a single tag (for use in DICOMTagBasedSorter).
The class will compare the tag values by
1. numerical value if possible (i.e. both datasets have a value that is numerical)
2. alphabetical order otherwise
- If the comparison results in equalness, it is refered to the secondary criterion, see
+ If the comparison results in equalness, it is referred to the secondary criterion, see
DICOMSortByTag::NextLevelIsLeftBeforeRight().
*/
class MITKDICOM_EXPORT DICOMSortByTag : public DICOMSortCriterion
{
public:
mitkClassMacro( DICOMSortByTag, DICOMSortCriterion );
mitkNewMacro1Param( DICOMSortByTag, const DICOMTag& );
mitkNewMacro2Param( DICOMSortByTag, const DICOMTag&, DICOMSortCriterion::Pointer );
DICOMTagList GetTagsOfInterest() const override;
bool IsLeftBeforeRight(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right) const override;
double NumericDistance(const mitk::DICOMDatasetAccess* from, const mitk::DICOMDatasetAccess* to) const override;
void Print(std::ostream& os) const override;
bool operator==(const DICOMSortCriterion& other) const override;
protected:
DICOMSortByTag( const DICOMTag& tag, DICOMSortCriterion::Pointer secondaryCriterion = nullptr );
~DICOMSortByTag() override;
DICOMSortByTag(const DICOMSortByTag& other);
DICOMSortByTag& operator=(const DICOMSortByTag& other);
bool StringCompare(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, const DICOMTag& tag) const;
bool NumericCompare(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, const DICOMTag& tag) const;
private:
DICOMTag m_Tag;
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMSortCriterion.h b/Modules/DICOM/include/mitkDICOMSortCriterion.h
index 4fa2aebff1..2a35cd3447 100644
--- a/Modules/DICOM/include/mitkDICOMSortCriterion.h
+++ b/Modules/DICOM/include/mitkDICOMSortCriterion.h
@@ -1,78 +1,78 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMSortCriterion_h
#define mitkDICOMSortCriterion_h
#include "itkObjectFactory.h"
#include "mitkCommon.h"
#include "mitkDICOMDatasetAccess.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief A tag based sorting criterion for use in DICOMTagBasedSorter.
This class is used within std::sort (see DICOMTagBasedSorter::Sort())
and has to answer a simple question by implementing IsLeftBeforeRight().
Each time IsLeftBeforeRight() is called, the method should return whether
the left dataset should be sorted before the right dataset.
- Because there are identical tags values quite oftenly, a DICOMSortCriterion
+ Because there are identical tags values quite often, a DICOMSortCriterion
will always hold a secondary DICOMSortCriterion. In cases of equal tag
- values, the decision is refered to the secondary criterion.
+ values, the decision is referred to the secondary criterion.
*/
class MITKDICOM_EXPORT DICOMSortCriterion : public itk::LightObject
{
public:
mitkClassMacroItkParent( DICOMSortCriterion, itk::LightObject );
/// \brief Tags used for comparison (includes seconary criteria).
DICOMTagList GetAllTagsOfInterest() const;
/// \brief Tags used for comparison.
virtual DICOMTagList GetTagsOfInterest() const = 0;
/// \brief Answer the sorting question.
virtual bool IsLeftBeforeRight(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right) const = 0;
/// \brief Calculate a distance between two datasets.
/// This ansers the question of consecutive datasets.
virtual double NumericDistance(const mitk::DICOMDatasetAccess* from, const mitk::DICOMDatasetAccess* to) const = 0;
/// \brief The fallback criterion.
DICOMSortCriterion::ConstPointer GetSecondaryCriterion() const;
/// brief describe this class in given stream.
virtual void Print(std::ostream& os) const = 0;
virtual bool operator==(const DICOMSortCriterion& other) const = 0;
protected:
DICOMSortCriterion( DICOMSortCriterion::Pointer secondaryCriterion );
~DICOMSortCriterion() override;
bool NextLevelIsLeftBeforeRight(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right) const;
explicit DICOMSortCriterion(const DICOMSortCriterion& other);
DICOMSortCriterion& operator=(const DICOMSortCriterion& other);
DICOMSortCriterion::Pointer m_SecondaryCriterion;
};
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMTagPath.h b/Modules/DICOM/include/mitkDICOMTagPath.h
index 7c82a56fb7..f428198ed5 100644
--- a/Modules/DICOM/include/mitkDICOMTagPath.h
+++ b/Modules/DICOM/include/mitkDICOMTagPath.h
@@ -1,176 +1,176 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMTagPath_h
#define mitkDICOMTagPath_h
#include <vector>
#include <mitkDICOMTag.h>
#include <MitkDICOMExports.h>
namespace mitk
{
/** @brief Class is used to identify (nested) attributes in a DICOM dataset.
* In contrast to the class DICOMTag, which only specifies one specific tag,
* the tag path can identify nested attributes (like items in a DICOM sequence).
* In addition you may also specify wildcards for the selection index or
* complete elements of the path.
* @remark If you want to keep the DICOMTagPath compatible to the dcmtk search path
* format, you may *not* use element wild cards (this IsExplicit() or HasItemSelectionWildcardsOnly()
* must return true).
*/
class MITKDICOM_EXPORT DICOMTagPath
{
public:
typedef int ItemSelectionIndex;
struct MITKDICOM_EXPORT NodeInfo
{
enum class NodeType
{
- Invalid = 0, //*< Node is non existant or invalid.
+ Invalid = 0, //*< Node is non existent or invalid.
Element, //*< Selects an specific element given the node name.
SequenceSelection, //*< Selects an specific item in a sequence of items and has a item selector ("[n]").
AnySelection, //*< Selects all items of a specific element ("[*]").
AnyElement, //*< Selects any element/item. Node name is wildcarded ("*"); item selection as well implictily.
};
NodeType type;
DICOMTag tag;
ItemSelectionIndex selection;
NodeInfo();
NodeInfo(const DICOMTag& tag, NodeType type = NodeType::Element, ItemSelectionIndex index = 0);
bool Matches(const NodeInfo& right) const;
bool operator == (const NodeInfo& right) const;
};
typedef std::vector<NodeInfo> NodeInfoVectorType;
typedef NodeInfoVectorType::size_type PathIndexType;
/** Returns if the DICOMTagPath is empty.*/
bool IsEmpty() const;
/** Returns if the path is explicit (has no wildcards).*/
bool IsExplicit() const;
/** Returns if the path has any nodes with item selection wild cards ([*]).*/
bool HasItemSelectionWildcardsOnly() const;
/** Number of path nodes the DICOMTagPath contains.*/
PathIndexType Size() const;
/** Adds a new node to the end of the path.
\param [in] newNode Reference to the node that should be added.
\return Returns the index of the newly added node.*/
PathIndexType AddNode(const NodeInfo& newNode);
/** Function returns the node info of a path node specified by the index
* within the DICOMTagPath.
* \pre Passed index must not be out of bound.
* \param [in] index Index of the node whose info should be retrieved.
* \return Info of the specified path node. If the index is out of bound an InvalidPathNode exception will be thrown.*/
const NodeInfo& GetNode(const PathIndexType& index) const;
/** Function returns the node info of a path node specified by the index
* within the DICOMTagPath.
* \pre Passed index must not be out of bound.
* \param [in] index Index of the node whose info should be retrieved.
* \return Info of the specified path node. If the index is out of bound an InvalidPathNode exception will be thrown.*/
NodeInfo& GetNode(const PathIndexType& index);
/** Function returns the node info of the first path node within the DICOMTagPath.
* \pre DICOMTagPath must not be empty.
* \return Info of the first path node. If the path is empty, an InvalidPathNode exception will be thrown.*/
NodeInfo& GetFirstNode();
/** Function returns the node info of the first path node within the DICOMTagPath.
* \pre DICOMTagPath must not be empty.
* \return Info of the first path node. If the path is empty, an InvalidPathNode exception will be thrown.*/
const NodeInfo& GetFirstNode() const;
/** Function returns the node info of the last path node within the DICOMTagPath.
* \pre DICOMTagPath must not be empty.
* \return Info of the first path node. If the path is empty, an InvalidPathNode exception will be thrown.*/
NodeInfo& GetLastNode();
/** Function returns the node info of the last path node within the DICOMTagPath.
* \pre DICOMTagPath must not be empty.
* \return Info of the first path node. If the path is empty, an InvalidPathNode exception will be thrown.*/
const NodeInfo& GetLastNode() const;
const NodeInfoVectorType& GetNodes() const;
std::string ToStr() const;
DICOMTagPath& FromStr(const std::string& pathStr);
/**Compares two DICOMTagPaths for real equality. So its a string compare of their string conversion*/
bool operator == (const DICOMTagPath& path) const;
/**Operation equals like comparing the ToStr() results with operator <.*/
bool operator < (const DICOMTagPath& right) const;
/**Checks if to DICOMTagPathes are specify the same node. Hence all wildcards will be processed.\n
* E.G.: "item1/child1/grandChild2" == ".//item1//grandChild2" is true.
- * \remark If you want to check if to pathes are "truely" equal and not only equal in terms of
+ * \remark If you want to check if two paths are "truly" equal and not only equal in terms of
* pointing to the same node, use the member function Equals()*/
bool Equals(const DICOMTagPath& path) const;
DICOMTagPath& operator = (const DICOMTagPath& path);
DICOMTagPath& AddAnyElement();
DICOMTagPath& AddElement(unsigned int group, unsigned int element);
DICOMTagPath& AddAnySelection(unsigned int group, unsigned int element);
DICOMTagPath& AddSelection(unsigned int group, unsigned int element, ItemSelectionIndex index);
DICOMTagPath();
DICOMTagPath(const DICOMTagPath& path);
DICOMTagPath(const DICOMTag& tag);
explicit DICOMTagPath(unsigned int group, unsigned int element);
virtual ~DICOMTagPath();
virtual void Reset();
protected:
NodeInfoVectorType m_NodeInfos;
static bool DICOMTagPathesMatch(const DICOMTagPath& left, const DICOMTagPath& right);
};
typedef std::vector<DICOMTagPath> DICOMTagPathList;
MITKDICOM_EXPORT std::ostream& operator<<(std::ostream& os, const DICOMTagPath& path);
MITKDICOM_EXPORT std::string DICOMTagPathToPropertyRegEx(const DICOMTagPath& tagPath);
MITKDICOM_EXPORT std::string DICOMTagPathToPersistenceKeyRegEx(const DICOMTagPath& tagPath);
MITKDICOM_EXPORT std::string DICOMTagPathToPersistenceKeyTemplate(const DICOMTagPath& tagPath);
MITKDICOM_EXPORT std::string DICOMTagPathToPersistenceNameTemplate(const DICOMTagPath& tagPath);
/** Converts a passed path into a search string for the DCMTK DcmPathProcessor.
@pre tagPath must be an explicit (DICOMTagPath::IsExplicit()) path or
must only contain selection wild cards (DICOMTagPath::HasItemSelectionWildcardsOnly()).*/
MITKDICOM_EXPORT std::string DICOMTagPathToDCMTKSearchPath(const DICOMTagPath& tagPath);
/** Converts the passed property name into a tag path. If the property name cannot be converted
into a valid path, the returned path is empty.*/
MITKDICOM_EXPORT DICOMTagPath PropertyNameToDICOMTagPath(const std::string& propertyName);
/** returns the correct property name for a given DICOMTagPath instance. */
MITKDICOM_EXPORT std::string DICOMTagPathToPropertyName(const DICOMTagPath& tagPath);
}
#endif
diff --git a/Modules/DICOM/include/mitkDICOMTagScanner.h b/Modules/DICOM/include/mitkDICOMTagScanner.h
index 15abdbc3d0..f34f7abddc 100644
--- a/Modules/DICOM/include/mitkDICOMTagScanner.h
+++ b/Modules/DICOM/include/mitkDICOMTagScanner.h
@@ -1,118 +1,118 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMTagScanner_h
#define mitkDICOMTagScanner_h
#include <stack>
#include <mutex>
#include "mitkDICOMEnums.h"
#include "mitkDICOMTagPath.h"
#include "mitkDICOMTagCache.h"
#include "mitkDICOMDatasetAccessingImageFrameInfo.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief Abstracts the tag scanning process for a set of DICOM files.
Formerly integrated as a part of DICOMITKSeriesGDCMReader, the tag
scanning part has been factored out into DICOMTagScanner classes
in order to allow a single scan for multiple reader alternatives. This
helps much in the selection process of e.g. DICOMFileReaderSelector.
This is an abstract base class for concrete scanner implementations.
@remark When used in a process where multiple classes will access the scan
results, care should be taken that all the tags and files of interest
are communicated to DICOMTagScanner before requesting the results!
*/
class MITKDICOM_EXPORT DICOMTagScanner : public itk::Object
{
public:
mitkClassMacroItkParent(DICOMTagScanner, itk::Object);
/**
\brief Add this tag to the scanning process.
*/
virtual void AddTag(const DICOMTag& tag) = 0;
/**
\brief Add a list of tags to the scanning process.
*/
virtual void AddTags(const DICOMTagList& tags) = 0;
/**
\brief Add this tag path to the scanning process.
*/
virtual void AddTagPath(const DICOMTagPath& path) = 0;
/**
- \brief Add a list of tag pathes to the scanning process.
+ \brief Add a list of tag paths to the scanning process.
*/
virtual void AddTagPaths(const DICOMTagPathList& paths) = 0;
/**
\brief Define the list of files to scan.
This does not ADD to an internal list, but it replaces the
whole list of files.
*/
virtual void SetInputFiles(const StringList& filenames) = 0;
/**
\brief Start the scanning process.
Calling Scan() will invalidate previous scans, forgetting
all about files and tags from files that have been scanned
previously.
*/
virtual void Scan() = 0;
/**
\brief Retrieve a result list for file-by-file tag access.
*/
virtual DICOMDatasetAccessingImageFrameList GetFrameInfoList() const = 0;
/**
\brief Retrieve Pointer to the complete cache of the scan.
*/
virtual DICOMTagCache::Pointer GetScanCache() const = 0;
protected:
/** \brief Return active C locale */
static std::string GetActiveLocale();
/**
\brief Remember current locale on stack, activate "C" locale.
"C" locale is required for correct parsing of numbers by itk::ImageSeriesReader
*/
void PushLocale() const;
/**
\brief Activate last remembered locale from locale stack
"C" locale is required for correct parsing of numbers by itk::ImageSeriesReader
*/
void PopLocale() const;
DICOMTagScanner();
~DICOMTagScanner() override;
private:
static std::mutex s_LocaleMutex;
mutable std::stack<std::string> m_ReplacedCLocales;
mutable std::stack<std::locale> m_ReplacedCinLocales;
DICOMTagScanner(const DICOMTagScanner&);
};
}
#endif
diff --git a/Modules/DICOM/include/mitkEquiDistantBlocksSorter.h b/Modules/DICOM/include/mitkEquiDistantBlocksSorter.h
index 03bc4f5476..39a2ae15f8 100644
--- a/Modules/DICOM/include/mitkEquiDistantBlocksSorter.h
+++ b/Modules/DICOM/include/mitkEquiDistantBlocksSorter.h
@@ -1,211 +1,211 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkEquiDistantBlocksSorter_h
#define mitkEquiDistantBlocksSorter_h
#include "mitkDICOMDatasetSorter.h"
#include "mitkDICOMSortCriterion.h"
#include "mitkGantryTiltInformation.h"
#include "mitkVector.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief Split inputs into blocks of equidistant slices (for use in DICOMITKSeriesGDCMReader).
Since inter-slice distance is not recorded in DICOM tags, we must ensure that blocks are made up of
slices that have equal distances between neighboring slices. This is especially necessary because itk::ImageSeriesReader
is later used for the actual loading, and this class expects (and does nocht verify) equal inter-slice distance (see \ref DICOMITKSeriesGDCMReader_ForcedConfiguration).
To achieve such grouping, the inter-slice distance is calculated from the first two different slice positions of a block.
Following slices are added to a block as long as they can be added by adding the calculated inter-slice distance to the
last slice of the block. Slices that do not fit into the expected distance pattern, are set aside for further analysis.
This grouping is done until each file has been assigned to a group.
Slices that share a position in space are also sorted into separate blocks during this step.
So the result of this step is a set of blocks that contain only slices with equal z spacing
- and uniqe slices at each position.
+ and unique slices at each position.
During sorting, the origins (documented in tag image position patient) are compared
against expected origins (from former origin plus moving direction). As there will
- be minor differences in numbers (from both calculations and unprecise tag values),
+ be minor differences in numbers (from both calculations and imprecise tag values),
we must be a bit tolerant here. The default behavior is to expect that an origin is
not further away from the expected position than 30% of the inter-slice distance.
To support a legacy behavior of a former loader (DicomSeriesReader), this default can
be restricted to a constant number of millimeters by calling SetToleratedOriginOffset(mm).
Detailed implementation in AnalyzeFileForITKImageSeriesReaderSpacingAssumption().
*/
class MITKDICOM_EXPORT EquiDistantBlocksSorter : public DICOMDatasetSorter
{
public:
mitkClassMacro( EquiDistantBlocksSorter, DICOMDatasetSorter );
itkNewMacro( EquiDistantBlocksSorter );
DICOMTagList GetTagsOfInterest() override;
/**
\brief Delegates work to AnalyzeFileForITKImageSeriesReaderSpacingAssumption().
AnalyzeFileForITKImageSeriesReaderSpacingAssumption() is called until it does not
create multiple blocks anymore.
*/
void Sort() override;
/**
\brief Whether or not to accept images from a tilted acquisition in a single output group.
*/
void SetAcceptTilt(bool accept);
bool GetAcceptTilt() const;
/**
\brief See class description and SetToleratedOriginOffset().
*/
void SetToleratedOriginOffsetToAdaptive(double fractionOfInterSliceDistanct = 0.3);
/**
\brief See class description and SetToleratedOriginOffsetToAdaptive().
Default value of 0.005 is calculated so that we get a maximum of 1/10mm
error when having a measurement crosses 20 slices in z direction (too strict? we don't know better..).
*/
void SetToleratedOriginOffset(double millimeters = 0.005);
double GetToleratedOriginOffset() const;
bool IsToleratedOriginOffsetAbsolute() const;
void SetAcceptTwoSlicesGroups(bool accept);
bool GetAcceptTwoSlicesGroups() const;
void PrintConfiguration(std::ostream& os, const std::string& indent = "") const override;
bool operator==(const DICOMDatasetSorter& other) const override;
protected:
/**
\brief Return type of AnalyzeFileForITKImageSeriesReaderSpacingAssumption().
Class contains the grouping result of method AnalyzeFileForITKImageSeriesReaderSpacingAssumption(),
which takes as input a number of images, which are all equally oriented and spatially sorted along their normal direction.
The result contains of two blocks: a first one is the grouping result, all of those images can be loaded
into one image block because they have an equal origin-to-origin distance without any gaps in-between.
*/
class SliceGroupingAnalysisResult
{
public:
SliceGroupingAnalysisResult();
/**
\brief Grouping result, all same origin-to-origin distance w/o gaps.
*/
DICOMDatasetList GetBlockDatasets();
void SetFirstFilenameOfBlock(const std::string& filename);
std::string GetFirstFilenameOfBlock() const;
void SetLastFilenameOfBlock(const std::string& filename);
std::string GetLastFilenameOfBlock() const;
/**
\brief Remaining files, which could not be grouped.
*/
DICOMDatasetList GetUnsortedDatasets();
/**
- \brief Wheter or not the grouped result contain a gantry tilt.
+ \brief Whether or not the grouped result contain a gantry tilt.
*/
bool ContainsGantryTilt();
/**
\brief Detailed description of gantry tilt.
*/
const GantryTiltInformation& GetTiltInfo() const;
/**
\brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
*/
void AddFileToSortedBlock(DICOMDatasetAccess* dataset);
/**
\brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
*/
void AddFileToUnsortedBlock(DICOMDatasetAccess* dataset);
void AddFilesToUnsortedBlock(const DICOMDatasetList& datasets);
/**
\brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
\todo Could make sense to enhance this with an instance of GantryTiltInformation to store the whole result!
*/
void FlagGantryTilt(const GantryTiltInformation& tiltInfo);
/**
\brief Only meaningful for use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption.
*/
void UndoPrematureGrouping();
protected:
DICOMDatasetList m_GroupedFiles;
DICOMDatasetList m_UnsortedFiles;
GantryTiltInformation m_TiltInfo;
std::string m_FirstFilenameOfBlock;
std::string m_LastFilenameOfBlock;
};
/**
\brief Ensure an equal z-spacing for a group of files.
Takes as input a number of images, which are all equally oriented and spatially sorted along their normal direction.
Internally used by GetSeries. Returns two lists: the first one contins slices of equal inter-slice spacing.
The second list contains remaining files, which need to be run through AnalyzeFileForITKImageSeriesReaderSpacingAssumption again.
Relevant code that is matched here is in
itkImageSeriesReader.txx (ImageSeriesReader<TOutputImage>::GenerateOutputInformation(void)), lines 176 to 245 (as of ITK 3.20)
*/
SliceGroupingAnalysisResult
AnalyzeFileForITKImageSeriesReaderSpacingAssumption(const DICOMDatasetList& files, bool groupsOfSimilarImages);
/**
\brief Safely convert const char* to std::string.
*/
std::string
ConstCharStarToString(const char* s);
EquiDistantBlocksSorter();
~EquiDistantBlocksSorter() override;
EquiDistantBlocksSorter(const EquiDistantBlocksSorter& other);
EquiDistantBlocksSorter& operator=(const EquiDistantBlocksSorter& other);
bool m_AcceptTilt;
typedef std::vector<SliceGroupingAnalysisResult> ResultsList;
ResultsList m_SliceGroupingResults;
double m_ToleratedOriginOffset;
bool m_ToleratedOriginOffsetIsAbsolute;
bool m_AcceptTwoSlicesGroups;
};
}
#endif
diff --git a/Modules/DICOM/include/mitkGantryTiltInformation.h b/Modules/DICOM/include/mitkGantryTiltInformation.h
index 550e9de731..768692ff53 100644
--- a/Modules/DICOM/include/mitkGantryTiltInformation.h
+++ b/Modules/DICOM/include/mitkGantryTiltInformation.h
@@ -1,143 +1,143 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkGantryTiltInformation_h
#define mitkGantryTiltInformation_h
#include "mitkPoint.h"
#include "mitkVector.h"
#include "mitkPoint.h"
namespace mitk
{
/**
\ingroup DICOMModule
\brief Gantry tilt analysis result.
Takes geometry information for two slices of a DICOM series and
calculates whether these fit into an orthogonal block or not.
If NOT, they can either be the result of an acquisition with
- gantry tilt OR completly broken by some shearing transformation.
+ gantry tilt OR completely broken by some shearing transformation.
Most calculations are done in the constructor, results can then
be read via the remaining methods.
This class is a helper to DICOMITKSeriesGDCMReader and can
not be used outside of \ref DICOMModule
*/
class GantryTiltInformation
{
public:
// two types to avoid any rounding errors
typedef itk::Point<double,3> Point3Dd;
typedef itk::Vector<double,3> Vector3Dd;
/**
\brief Just so we can create empty instances for assigning results later.
*/
GantryTiltInformation();
void Print(std::ostream& os) const;
/**
\brief THE constructor, which does all the calculations.
Determining the amount of tilt is done by checking the distances
of origin1 from planes through origin2. Two planes are considered:
- normal vector along normal of slices (right x up): gives the slice distance
- normal vector along orientation vector "up": gives the shift parallel to the plane orientation
The tilt angle can then be calculated from these distances
\param origin1 origin of the first slice
\param origin2 origin of the second slice
\param right right/up describe the orientatation of borth slices
\param up right/up describe the orientatation of borth slices
\param numberOfSlicesApart how many slices are the given origins apart (1 for neighboring slices)
*/
GantryTiltInformation( const Point3D& origin1,
const Point3D& origin2,
const Vector3D& right,
const Vector3D& up, unsigned int numberOfSlicesApart);
/**
\brief Factory method to create GantryTiltInformation from tag values (strings).
Parameters as the regular c'tor.
*/
static
GantryTiltInformation
MakeFromTagValues( const std::string& origin1String,
const std::string& origin2String,
const std::string& orientationString,
unsigned int numberOfSlicesApart);
/**
\brief Whether the slices were sheared.
True if any of the shifts along right or up vector are non-zero.
*/
bool IsSheared() const;
/**
\brief Whether the shearing is a gantry tilt or more complicated.
Gantry tilt will only produce shifts in ONE orientation, not in both.
- Since the correction code currently only coveres one tilt direction
+ Since the correction code currently only covers one tilt direction
AND we don't know of medical images with two tilt directions, the
loading code wants to check if our assumptions are true.
*/
bool IsRegularGantryTilt() const;
/**
\brief The offset distance in Y direction for each slice in mm (describes the tilt result).
*/
double GetMatrixCoefficientForCorrectionInWorldCoordinates() const;
/**
\brief The z / inter-slice spacing. Needed to correct ImageSeriesReader's result.
*/
double GetRealZSpacing() const;
/**
\brief The shift between first and last slice in mm.
Needed to resize an orthogonal image volume.
*/
double GetTiltCorrectedAdditionalSize(unsigned int imageSizeZ) const;
/**
\brief Calculated tilt angle in degrees.
*/
double GetTiltAngleInDegrees() const;
private:
/**
\brief Projection of point p onto line through lineOrigin in direction of lineDirection.
*/
Point3D projectPointOnLine( Point3Dd p, Point3Dd lineOrigin, Vector3Dd lineDirection );
double m_ShiftUp;
double m_ShiftRight;
double m_ShiftNormal;
double m_ITKAssumedSliceSpacing;
unsigned int m_NumberOfSlicesApart;
};
} // namespace
#endif
diff --git a/Modules/DICOM/include/mitkIDICOMTagsOfInterest.h b/Modules/DICOM/include/mitkIDICOMTagsOfInterest.h
index 6b968deaee..28353218ae 100644
--- a/Modules/DICOM/include/mitkIDICOMTagsOfInterest.h
+++ b/Modules/DICOM/include/mitkIDICOMTagsOfInterest.h
@@ -1,64 +1,64 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkIDICOMTagsOfInterest_h
#define mitkIDICOMTagsOfInterest_h
#include <mitkServiceInterface.h>
#include <string>
#include <vector>
#include <mitkDICOMTagsOfInterestHelper.h>
#include <MitkDICOMExports.h>
namespace mitk
{
/**
* \ingroup MicroServices_Interfaces
* \brief Interface of DICOM tags of interest service.
*
* This service allows you to manage the tags of interest (toi).
- * All registred toi will be extracted when loading dicom data and stored as properties in the corresponding
+ * All registered toi will be extracted when loading dicom data and stored as properties in the corresponding
* base data object. In addition the service can (if available) use IPropertyPersistance and IPropertyAliases
* to ensure that the tags of interests are also persisted and have a human readable alias.
*/
class MITKDICOM_EXPORT IDICOMTagsOfInterest
{
public:
virtual ~IDICOMTagsOfInterest();
/** \brief Add an tag to the TOI.
* If the tag was already added it will be overwritten with the passed values.
* \param[in] tag Tag that should be added.
- * \param[in] makePersistant Indicates if the tag should be made persistant if possible via the IPropertyPersistence service.
+ * \param[in] makePersistant Indicates if the tag should be made persistent if possible via the IPropertyPersistence service.
*/
virtual void AddTagOfInterest(const DICOMTagPath& tag, bool makePersistant = true) = 0;
/** Returns the map of all tags of interest. Key is the property name. Value is the DICOM tag.*/
virtual DICOMTagPathMapType GetTagsOfInterest() const = 0;
/** Indicates if the given tag is already a tag of interest.*/
virtual bool HasTag(const DICOMTagPath& tag) const = 0;
/** \brief Remove specific tag. If it not exists the function will do nothing.
* \param[in] tag Tag that should be removed.
*/
virtual void RemoveTag(const DICOMTagPath& tag) = 0;
/** \brief Remove all tags.
*/
virtual void RemoveAllTags() = 0;
};
}
MITK_DECLARE_SERVICE_INTERFACE(mitk::IDICOMTagsOfInterest, "org.mitk.IDICOMTagsOfInterest")
#endif
diff --git a/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.h b/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.h
index aadf91259b..9333a1cb48 100644
--- a/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.h
+++ b/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.h
@@ -1,105 +1,105 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDICOMSeriesReaderHelper_h
#define mitkDICOMSeriesReaderHelper_h
#include "mitkImage.h"
#include "mitkGantryTiltInformation.h"
#include "mitkDICOMTag.h"
#include <itkGDCMImageIO.h>
/* Forward deceleration of an DCMTK class. Used in the txx but part of the interface.*/
class OFDateTime;
namespace mitk
{
class ITKDICOMSeriesReaderHelper
{
public:
static const DICOMTag AcquisitionDateTag;
static const DICOMTag AcquisitionTimeTag;
static const DICOMTag TriggerTimeTag;
typedef std::vector<std::string> StringContainer;
typedef std::list<StringContainer> StringContainerList;
Image::Pointer Load( const StringContainer& filenames, bool correctTilt, const GantryTiltInformation& tiltInfo );
Image::Pointer Load3DnT( const StringContainerList& filenamesLists, bool correctTilt, const GantryTiltInformation& tiltInfo );
static bool CanHandleFile(const std::string& filename);
private:
typedef std::vector<TimeBounds> TimeBoundsList;
typedef itk::FixedArray<OFDateTime,2> DateTimeBounds;
/** Scans the given files for the acquisition time and returns the lowest and
highest acquisition date time as date time bounds via bounds.
@param bounds The acquisition date time bound extracted from the files.
@param triggerBounds Time bounds for trigger information extracted from the files.
If no trigger information was found than it returns trigger == [0.0, 0.0].
@return If no acquisition date times can be found the function return will be false. Otherwise
it returns True.
*/
static bool ExtractDateTimeBoundsAndTriggerOfTimeStep( const StringContainer& filenamesOfTimeStep,
DateTimeBounds& bounds, TimeBounds& triggerBounds);
/* Determine the time bounds in ms respective to the baselineDateTime for the passed
- files. Additionaly it regards the trigger time tag if set and acquisition date time
+ files. Additionally it regards the trigger time tag if set and acquisition date time
carries not enough information.*/
static bool ExtractTimeBoundsOfTimeStep(const StringContainer& filenamesOfTimeStep,
TimeBounds& bounds,
const OFDateTime& baselineDateTime );
/** Returns the list of time bounds of all passed time step containers.
(sa ExtractTimeBoundsOfTimeStep and ExtractDateTimeBoundsOfTimeStep).
Time steps where no time bounds could be extracted
are indecated by "null" time bounds (both values "0"). The order of the returned
list equals of passed filenamesOfTimeSteps order.
@remark The function regards acquisition date time tags and trigger time tags.*/
static TimeBoundsList ExtractTimeBoundsOfTimeSteps (const StringContainerList& filenamesOfTimeSteps);
/** Helper function that generates a time geometry using the template and the passed boundslist
(which indicates the number of time steps).
*/
static TimeGeometry::Pointer GenerateTimeGeometry(const BaseGeometry* templateGeometry, const TimeBoundsList& boundsList);
template <typename ImageType>
typename ImageType::Pointer
FixUpTiltedGeometry( ImageType* input, const GantryTiltInformation& tiltInfo );
template <typename PixelType>
Image::Pointer
LoadDICOMByITK( const StringContainer& filenames,
bool correctTilt,
const GantryTiltInformation& tiltInfo,
itk::GDCMImageIO::Pointer& io);
template <typename PixelType>
Image::Pointer
LoadDICOMByITK3DnT( const StringContainerList& filenames,
bool correctTilt,
const GantryTiltInformation& tiltInfo,
itk::GDCMImageIO::Pointer& io);
};
}
#endif
diff --git a/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.txx b/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.txx
index f38cd26acb..98c86b8548 100644
--- a/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.txx
+++ b/Modules/DICOM/include/mitkITKDICOMSeriesReaderHelper.txx
@@ -1,302 +1,302 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkITKDICOMSeriesReaderHelper.h"
#include <itkImageSeriesReader.h>
#include <itkResampleImageFilter.h>
//#include <itkAffineTransform.h>
//#include <itkLinearInterpolateImageFunction.h>
//#include <itkTimeProbesCollectorBase.h>
#include "dcmtk/ofstd/ofdatime.h"
template <typename PixelType>
mitk::Image::Pointer
mitk::ITKDICOMSeriesReaderHelper
::LoadDICOMByITK(
const StringContainer& filenames,
bool correctTilt,
const GantryTiltInformation& tiltInfo,
itk::GDCMImageIO::Pointer& io)
{
/******** Normal Case, 3D (also for GDCM < 2 usable) ***************/
mitk::Image::Pointer image = mitk::Image::New();
typedef itk::Image<PixelType, 3> ImageType;
typedef itk::ImageSeriesReader<ImageType> ReaderType;
io = itk::GDCMImageIO::New();
typename ReaderType::Pointer reader = ReaderType::New();
reader->SetImageIO(io);
reader->ReverseOrderOff(); // at this point we require an order of input images so that
// the direction between the origin of the first and the last slice
// is the same direction as the image normals! Otherwise we might
// see images upside down. Unclear whether this is a bug in MITK,
// see NormalDirectionConsistencySorter.
reader->SetFileNames(filenames);
reader->Update();
typename ImageType::Pointer readVolume = reader->GetOutput();
// if we detected that the images are from a tilted gantry acquisition, we need to push some pixels into the right position
if (correctTilt)
{
readVolume = FixUpTiltedGeometry( reader->GetOutput(), tiltInfo );
}
image->InitializeByItk(readVolume.GetPointer());
image->SetImportVolume(readVolume->GetBufferPointer());
#ifdef MBILOG_ENABLE_DEBUG
MITK_DEBUG << "Volume dimension: [" << image->GetDimension(0) << ", "
<< image->GetDimension(1) << ", "
<< image->GetDimension(2) << "]";
MITK_DEBUG << "Volume spacing: [" << image->GetGeometry()->GetSpacing()[0] << ", "
<< image->GetGeometry()->GetSpacing()[1] << ", "
<< image->GetGeometry()->GetSpacing()[2] << "]";
#endif //MBILOG_ENABLE_DEBUG
return image;
}
#define MITK_DEBUG_OUTPUT_FILELIST(list)\
MITK_DEBUG << "-------------------------------------------"; \
for (StringContainer::const_iterator _iter = (list).cbegin(); _iter!=(list).cend(); ++_iter) \
{ \
MITK_DEBUG <<" file '" << *_iter<< "'"; \
} \
MITK_DEBUG << "-------------------------------------------";
template <typename PixelType>
mitk::Image::Pointer
mitk::ITKDICOMSeriesReaderHelper
::LoadDICOMByITK3DnT(
const StringContainerList& filenamesForTimeSteps,
bool correctTilt,
const GantryTiltInformation& tiltInfo,
itk::GDCMImageIO::Pointer& io)
{
unsigned int numberOfTimeSteps = filenamesForTimeSteps.size();
MITK_DEBUG << "Start extracting time bounds of time steps";
const TimeBoundsList timeBoundsList = ExtractTimeBoundsOfTimeSteps(filenamesForTimeSteps);
if (numberOfTimeSteps!=timeBoundsList.size())
{
mitkThrow() << "Error while loading 3D+t. Inconsistent size of generated time bounds list. List size: "<< timeBoundsList.size() << "; number of steps: "<<numberOfTimeSteps;
}
mitk::Image::Pointer image = mitk::Image::New();
typedef itk::Image<PixelType, 4> ImageType;
typedef itk::ImageSeriesReader<ImageType> ReaderType;
io = itk::GDCMImageIO::New();
typename ReaderType::Pointer reader = ReaderType::New();
reader->SetImageIO(io);
reader->ReverseOrderOff(); // at this point we require an order of input images so that
// the direction between the origin of the first and the last slice
// is the same direction as the image normals! Otherwise we might
// see images upside down. Unclear whether this is a bug in MITK,
// see NormalDirectionConsistencySorter.
unsigned int currentTimeStep = 0;
#ifdef MBILOG_ENABLE_DEBUG
MITK_DEBUG << "Start loading timestep " << currentTimeStep;
MITK_DEBUG_OUTPUT_FILELIST( filenamesForTimeSteps.front() )
#endif // MBILOG_ENABLE_DEBUG
reader->SetFileNames(filenamesForTimeSteps.front());
reader->Update();
typename ImageType::Pointer readVolume = reader->GetOutput();
// if we detected that the images are from a tilted gantry acquisition, we need to push some pixels into the right position
if (correctTilt)
{
readVolume = FixUpTiltedGeometry( reader->GetOutput(), tiltInfo );
}
image->InitializeByItk(readVolume.GetPointer(), 1, numberOfTimeSteps);
image->SetImportVolume(readVolume->GetBufferPointer(), currentTimeStep++); // timestep 0
// for other time-steps
for (auto timestepsIter = ++(filenamesForTimeSteps.cbegin()); // start with SECOND entry
timestepsIter != filenamesForTimeSteps.cend();
++currentTimeStep, ++timestepsIter)
{
#ifdef MBILOG_ENABLE_DEBUG
MITK_DEBUG << "Start loading timestep " << currentTimeStep;
MITK_DEBUG_OUTPUT_FILELIST( *timestepsIter )
#endif // MBILOG_ENABLE_DEBUG
reader->SetFileNames( *timestepsIter );
reader->Update();
readVolume = reader->GetOutput();
if (correctTilt)
{
readVolume = FixUpTiltedGeometry( reader->GetOutput(), tiltInfo );
}
image->SetImportVolume(readVolume->GetBufferPointer(), currentTimeStep);
}
#ifdef MBILOG_ENABLE_DEBUG
MITK_DEBUG << "Volume dimension: [" << image->GetDimension(0) << ", "
<< image->GetDimension(1) << ", "
<< image->GetDimension(2) << "]";
MITK_DEBUG << "Volume spacing: [" << image->GetGeometry()->GetSpacing()[0] << ", "
<< image->GetGeometry()->GetSpacing()[1] << ", "
<< image->GetGeometry()->GetSpacing()[2] << "]";
#endif // MBILOG_ENABLE_DEBUG
//construct timegeometry
TimeGeometry::Pointer timeGeometry = GenerateTimeGeometry(image->GetGeometry(),timeBoundsList);
image->SetTimeGeometry(timeGeometry);
return image;
}
template <typename ImageType>
typename ImageType::Pointer
mitk::ITKDICOMSeriesReaderHelper
::FixUpTiltedGeometry( ImageType* input, const GantryTiltInformation& tiltInfo )
{
typedef itk::ResampleImageFilter<ImageType,ImageType> ResampleFilterType;
typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetInput( input );
/*
Transform for a point is
- transform from actual position to index coordinates
- apply a shear that undoes the gantry tilt
- transform back into world coordinates
Anybody who does this in a simpler way: don't forget to write up how and why your solution works
*/
typedef itk::ScalableAffineTransform< double, ImageType::ImageDimension > TransformType;
typename TransformType::Pointer transformShear = TransformType::New();
/**
- apply a shear and spacing correction to the image block that corrects the ITK reader's error
- ITK ignores the shear and loads slices into an orthogonal volume
- ITK calculates the spacing from the origin distance, which is more than the actual spacing with gantry tilt images
- to undo the effect
- we have calculated some information in tiltInfo:
- the shift in Y direction that is added with each additional slice is the most important information
- the Y-shift is calculated in mm world coordinates
- we apply a shearing transformation to the ITK-read image volume
- to do this locally,
- we transform the image volume back to origin and "normal" orientation by applying the inverse of its transform
(this brings us into the image's "index coordinate" system)
- we apply a shear with the Y-shift factor put into a unit transform at row 1, col 2
- we transform the image volume back to its actual position (from index to world coordinates)
- we lastly apply modify the image spacing in z direction by replacing this number with the correctly calulcated inter-slice distance
*/
const ScalarType factor = tiltInfo.GetMatrixCoefficientForCorrectionInWorldCoordinates() / input->GetSpacing()[1];
// row 1, column 2 corrects shear in parallel to Y axis, proportional to distance in Z direction
transformShear->Shear( 1, 2, factor );
typename TransformType::Pointer imageIndexToWorld = TransformType::New();
imageIndexToWorld->SetOffset( input->GetOrigin().GetVectorFromOrigin() );
typename TransformType::MatrixType indexToWorldMatrix;
indexToWorldMatrix = input->GetDirection();
typename ImageType::DirectionType scale;
for ( unsigned int i = 0; i < ImageType::ImageDimension; i++ )
{
scale[i][i] = input->GetSpacing()[i];
}
indexToWorldMatrix *= scale;
imageIndexToWorld->SetMatrix( indexToWorldMatrix );
typename TransformType::Pointer imageWorldToIndex = TransformType::New();
imageIndexToWorld->GetInverse( imageWorldToIndex );
typename TransformType::Pointer gantryTiltCorrection = TransformType::New();
gantryTiltCorrection->Compose( imageWorldToIndex );
gantryTiltCorrection->Compose( transformShear );
gantryTiltCorrection->Compose( imageIndexToWorld );
resampler->SetTransform( gantryTiltCorrection );
typedef itk::LinearInterpolateImageFunction< ImageType, double > InterpolatorType;
typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
resampler->SetInterpolator( interpolator );
/*
This would be the right place to invent a meaningful value for positions outside of the image.
For CT, HU -1000 might be meaningful, but a general solution seems not possible. Even for CT,
-1000 would only look natural for many not all images.
*/
// TODO use (0028,0120) Pixel Padding Value if present
resampler->SetDefaultPixelValue( itk::NumericTraits< typename ImageType::PixelType >::min() );
// adjust size in Y direction! (maybe just transform the outer last pixel to see how much space we would need
resampler->SetOutputParametersFromImage( input ); // we basically need the same image again, just sheared
// if tilt positive, then we need additional pixels BELOW origin, otherwise we need pixels behind the end of the block
- // in any case we need more size to accomodate shifted slices
+ // in any case we need more size to accommodate shifted slices
typename ImageType::SizeType largerSize = resampler->GetSize(); // now the resampler already holds the input image's size.
const double imageSizeZ = largerSize[2];
//MITK_DEBUG <<"Calculate lager size = " << largerSize[1] << " + " << tiltInfo.GetTiltCorrectedAdditionalSize(imageSizeZ) << " / " << input->GetSpacing()[1] << "+ 2.0";
largerSize[1] += static_cast<typename ImageType::SizeType::SizeValueType>(tiltInfo.GetTiltCorrectedAdditionalSize(imageSizeZ) / input->GetSpacing()[1]+ 2.0);
resampler->SetSize( largerSize );
//MITK_DEBUG << "Fix Y size of image w/ spacing " << input->GetSpacing()[1] << " from " << input->GetLargestPossibleRegion().GetSize()[1] << " to " << largerSize[1];
// in SOME cases this additional size is below/behind origin
if ( tiltInfo.GetMatrixCoefficientForCorrectionInWorldCoordinates() > 0.0 )
{
typename ImageType::DirectionType imageDirection = input->GetDirection();
Vector3D yDirection;
yDirection[0] = imageDirection[0][1];
yDirection[1] = imageDirection[1][1];
yDirection[2] = imageDirection[2][1];
yDirection.Normalize();
typename ImageType::PointType shiftedOrigin;
shiftedOrigin = input->GetOrigin();
// add some pixels to make everything fit
shiftedOrigin[0] -= yDirection[0] * (tiltInfo.GetTiltCorrectedAdditionalSize(imageSizeZ) + 1.0 * input->GetSpacing()[1]);
shiftedOrigin[1] -= yDirection[1] * (tiltInfo.GetTiltCorrectedAdditionalSize(imageSizeZ) + 1.0 * input->GetSpacing()[1]);
shiftedOrigin[2] -= yDirection[2] * (tiltInfo.GetTiltCorrectedAdditionalSize(imageSizeZ) + 1.0 * input->GetSpacing()[1]);
resampler->SetOutputOrigin( shiftedOrigin );
}
resampler->Update();
typename ImageType::Pointer result = resampler->GetOutput();
// ImageSeriesReader calculates z spacing as the distance between the first two origins.
// This is not correct in case of gantry tilt, so we set our calculated spacing.
typename ImageType::SpacingType correctedSpacing = result->GetSpacing();
correctedSpacing[2] = tiltInfo.GetRealZSpacing();
result->SetSpacing( correctedSpacing );
return result;
}
diff --git a/Modules/DICOM/resource/configurations/3D/imagetime.xml b/Modules/DICOM/resource/configurations/3D/imagetime.xml
index 62e97e455f..aeda8ef23a 100644
--- a/Modules/DICOM/resource/configurations/3D/imagetime.xml
+++ b/Modules/DICOM/resource/configurations/3D/imagetime.xml
@@ -1,24 +1,24 @@
<?xml version="1.0" standalone="no"?>
<DICOMFileReader
label="Image Time"
- description="Sort images by Acqusition Time"
+ description="Sort images by Acquisition Time"
class="DICOMITKSeriesGDCMReader"
version="2"
fixTiltByShearing="true">
<DICOMDatasetSorter class="DICOMTagBasedSorter" strictSorting="true" expectDistanceOne="true">
<Distinguishing>
<Tag name="SeriesInstanceUID" group="0020" element="000e"/>
<Tag name="SeriesDescription" group="0008" element="103e"/>
<Tag name="ProtocolName" group="0018" element="1030"/>
<Tag name="SeriesNumber" group="0020" element="0011"/>
<Tag name="AcquisitionNumber" group="0x0020" element="0x0012"/>
<Tag name="Modality" group="0x0008" element="0x0060"/>
<Tag name="BodyPartExamined" group="0x0018" element="0x0015"/>
<Tag name="SequenceName" group="0x0018" element="0x0024"/>
</Distinguishing>
<Sorting>
<Tag name="AcquisitionTime" group="0x0008" element="0x0032"/>
<Tag name="SOPInstanceUID" group="0x0008" element="0x0018"/>
</Sorting>
</DICOMDatasetSorter>
</DICOMFileReader>
diff --git a/Modules/DICOM/resource/configurations/3DnT/imageposition.xml b/Modules/DICOM/resource/configurations/3DnT/imageposition.xml
index a44d46cfc9..7cd95629e8 100644
--- a/Modules/DICOM/resource/configurations/3DnT/imageposition.xml
+++ b/Modules/DICOM/resource/configurations/3DnT/imageposition.xml
@@ -1,21 +1,21 @@
<?xml version="1.0" standalone="no"?>
<DICOMFileReader
class="ThreeDnTDICOMSeriesReader"
version="2"
label="IPP 3D+t"
- description="Sort by Image Position (Patient), then group as 3D+t (till 2018/03 this configuration was wrongly stored in the file classicreader.xml (verison 1))"
+ description="Sort by Image Position (Patient), then group as 3D+t (till 2018/03 this configuration was wrongly stored in the file classicreader.xml (version 1))"
group3DnT="true"
fixTiltByShearing="true">
<DICOMDatasetSorter class="DICOMTagBasedSorter" strictSorting="true" expectDistanceOne="true">
<Distinguishing>
<Tag name="SeriesInstanceUID" group="0020," element="000e"/>
</Distinguishing>
<Sorting>
<ImagePositionPatient/>
<Tag name="AcquisitionNumber" group="0x0020," element="0x0012"/>
<Tag name="AcquisitionTime" group="0x0008," element="0x0032"/>
<Tag name="TriggerTime" group="0x0018," element="0x1060"/>
<Tag name="SOPInstanceUID" group="0x0008," element="0x0018"/>
</Sorting>
</DICOMDatasetSorter>
</DICOMFileReader>
diff --git a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp
index df1ca813e5..738a0bf028 100644
--- a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp
+++ b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.cpp
@@ -1,1860 +1,1860 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// uncomment for learning more about the internal sorting mechanisms
//#define MBILOG_ENABLE_DEBUG
#include <legacy/mitkDicomSeriesReader.h>
#include <mitkImage.h>
#include <mitkImageCast.h>
#include <mitkLocaleSwitch.h>
#include <itkGDCMSeriesFileNames.h>
#include <gdcmAttribute.h>
#include <gdcmDirectory.h>
#include <gdcmPixmapReader.h>
#include <gdcmRAWCodec.h>
#include <gdcmScanner.h>
#include <gdcmSorter.h>
#include <gdcmStringFilter.h>
#include <gdcmUIDs.h>
#include "mitkProperties.h"
namespace mitk
{
std::string DicomSeriesReader::ReaderImplementationLevelToString(const ReaderImplementationLevel &enumValue)
{
switch (enumValue)
{
case ReaderImplementationLevel_Supported:
return "Supported";
case ReaderImplementationLevel_PartlySupported:
return "PartlySupported";
case ReaderImplementationLevel_Implemented:
return "Implemented";
case ReaderImplementationLevel_Unsupported:
return "Unsupported";
default:
return "<unknown value of enum ReaderImplementationLevel>";
};
}
std::string DicomSeriesReader::PixelSpacingInterpretationToString(const PixelSpacingInterpretation &enumValue)
{
switch (enumValue)
{
case PixelSpacingInterpretation_SpacingInPatient:
return "In Patient";
case PixelSpacingInterpretation_SpacingAtDetector:
return "At Detector";
case PixelSpacingInterpretation_SpacingUnknown:
return "Unknown spacing";
default:
return "<unknown value of enum PixelSpacingInterpretation>";
};
}
const DicomSeriesReader::TagToPropertyMapType &DicomSeriesReader::GetDICOMTagsToMITKPropertyMap()
{
static bool initialized = false;
static TagToPropertyMapType dictionary;
if (!initialized)
{
/*
Selection criteria:
- no sequences because we cannot represent that
- - nothing animal related (specied, breed registration number), MITK focusses on human medical image processing.
+ - nothing animal related (specified, breed registration number), MITK focuses on human medical image processing.
- only general attributes so far
When extending this, we should make use of a real dictionary (GDCM/DCMTK and lookup the tag names there)
*/
// Patient module
dictionary["0010|0010"] = "dicom.patient.PatientsName";
dictionary["0010|0020"] = "dicom.patient.PatientID";
dictionary["0010|0030"] = "dicom.patient.PatientsBirthDate";
dictionary["0010|0040"] = "dicom.patient.PatientsSex";
dictionary["0010|0032"] = "dicom.patient.PatientsBirthTime";
dictionary["0010|1000"] = "dicom.patient.OtherPatientIDs";
dictionary["0010|1001"] = "dicom.patient.OtherPatientNames";
dictionary["0010|2160"] = "dicom.patient.EthnicGroup";
dictionary["0010|4000"] = "dicom.patient.PatientComments";
dictionary["0012|0062"] = "dicom.patient.PatientIdentityRemoved";
dictionary["0012|0063"] = "dicom.patient.DeIdentificationMethod";
// General Study module
dictionary["0020|000d"] = "dicom.study.StudyInstanceUID";
dictionary["0008|0020"] = "dicom.study.StudyDate";
dictionary["0008|0030"] = "dicom.study.StudyTime";
dictionary["0008|0090"] = "dicom.study.ReferringPhysiciansName";
dictionary["0020|0010"] = "dicom.study.StudyID";
dictionary["0008|0050"] = "dicom.study.AccessionNumber";
dictionary["0008|1030"] = "dicom.study.StudyDescription";
dictionary["0008|1048"] = "dicom.study.PhysiciansOfRecord";
dictionary["0008|1060"] = "dicom.study.NameOfPhysicianReadingStudy";
// General Series module
dictionary["0008|0060"] = "dicom.series.Modality";
dictionary["0020|000e"] = "dicom.series.SeriesInstanceUID";
dictionary["0020|0011"] = "dicom.series.SeriesNumber";
dictionary["0020|0060"] = "dicom.series.Laterality";
dictionary["0008|0021"] = "dicom.series.SeriesDate";
dictionary["0008|0031"] = "dicom.series.SeriesTime";
dictionary["0008|1050"] = "dicom.series.PerformingPhysiciansName";
dictionary["0018|1030"] = "dicom.series.ProtocolName";
dictionary["0008|103e"] = "dicom.series.SeriesDescription";
dictionary["0008|1070"] = "dicom.series.OperatorsName";
dictionary["0018|0015"] = "dicom.series.BodyPartExamined";
dictionary["0018|5100"] = "dicom.series.PatientPosition";
dictionary["0028|0108"] = "dicom.series.SmallestPixelValueInSeries";
dictionary["0028|0109"] = "dicom.series.LargestPixelValueInSeries";
// VOI LUT module
dictionary["0028|1050"] = "dicom.voilut.WindowCenter";
dictionary["0028|1051"] = "dicom.voilut.WindowWidth";
dictionary["0028|1055"] = "dicom.voilut.WindowCenterAndWidthExplanation";
// Image Pixel module
dictionary["0028|0004"] = "dicom.pixel.PhotometricInterpretation";
dictionary["0028|0010"] = "dicom.pixel.Rows";
dictionary["0028|0011"] = "dicom.pixel.Columns";
// Image Plane module
dictionary["0028|0030"] = "dicom.PixelSpacing";
dictionary["0018|1164"] = "dicom.ImagerPixelSpacing";
// Misc
dictionary["0008|0005"] = "dicom.SpecificCharacterSet";
initialized = true;
}
return dictionary;
}
DataNode::Pointer DicomSeriesReader::LoadDicomSeries(const StringContainer &filenames,
bool sort,
bool check_4d,
bool correctTilt,
UpdateCallBackMethod callback,
Image::Pointer preLoadedImageBlock)
{
DataNode::Pointer node = DataNode::New();
if (DicomSeriesReader::LoadDicomSeries(
filenames, *node, sort, check_4d, correctTilt, callback, preLoadedImageBlock))
{
if (filenames.empty())
{
return nullptr;
}
return node;
}
else
{
return nullptr;
}
}
bool DicomSeriesReader::LoadDicomSeries(const StringContainer &filenames,
DataNode &node,
bool sort,
bool check_4d,
bool correctTilt,
UpdateCallBackMethod callback,
itk::SmartPointer<Image> preLoadedImageBlock)
{
if (filenames.empty())
{
MITK_DEBUG << "Calling LoadDicomSeries with empty filename string container. Probably invalid application logic.";
node.SetData(nullptr);
return true; // this is not actually an error but the result is very simple
}
DcmIoType::Pointer io = DcmIoType::New();
try
{
if (io->CanReadFile(filenames.front().c_str()))
{
io->SetFileName(filenames.front().c_str());
io->ReadImageInformation();
if (io->GetPixelType() == itk::IOPixelEnum::SCALAR || io->GetPixelType() == itk::IOPixelEnum::RGB)
{
LoadDicom(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
}
if (node.GetData())
{
return true;
}
}
}
catch ( const itk::MemoryAllocationError &e )
{
MITK_ERROR << "Out of memory. Cannot load DICOM series: " << e.what();
}
catch ( const std::exception &e )
{
MITK_ERROR << "Error encountered when loading DICOM series:" << e.what();
}
catch (...)
{
MITK_ERROR << "Unspecified error encountered when loading DICOM series.";
}
return false;
}
bool DicomSeriesReader::IsDicom(const std::string &filename)
{
DcmIoType::Pointer io = DcmIoType::New();
return io->CanReadFile(filename.c_str());
}
bool DicomSeriesReader::IsPhilips3DDicom(const std::string &filename)
{
DcmIoType::Pointer io = DcmIoType::New();
if (io->CanReadFile(filename.c_str()))
{
// Look at header Tag 3001,0010 if it is "Philips3D"
gdcm::Reader reader;
reader.SetFileName(filename.c_str());
reader.Read();
gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
gdcm::StringFilter sf;
sf.SetFile(reader.GetFile());
if (data_set.FindDataElement(gdcm::Tag(0x3001, 0x0010)) &&
(sf.ToString(gdcm::Tag(0x3001, 0x0010)) == "Philips3D "))
{
return true;
}
}
return false;
}
bool DicomSeriesReader::ReadPhilips3DDicom(const std::string &filename, itk::SmartPointer<Image> output_image)
{
// Now get PhilipsSpecific Tags
gdcm::PixmapReader reader;
reader.SetFileName(filename.c_str());
reader.Read();
gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
gdcm::StringFilter sf;
sf.SetFile(reader.GetFile());
- gdcm::Attribute<0x0028, 0x0011> dimTagX; // coloumns || sagittal
+ gdcm::Attribute<0x0028, 0x0011> dimTagX; // columns || sagittal
gdcm::Attribute<0x3001, 0x1001, gdcm::VR::UL, gdcm::VM::VM1>
dimTagZ; // I have no idea what is VM1. // (Philips specific) // axial
gdcm::Attribute<0x0028, 0x0010> dimTagY; // rows || coronal
gdcm::Attribute<0x0028, 0x0008> dimTagT; // how many frames
gdcm::Attribute<0x0018, 0x602c> spaceTagX; // Spacing in X , unit is "physicalTagx" (usually centimeter)
gdcm::Attribute<0x0018, 0x602e> spaceTagY;
gdcm::Attribute<0x3001, 0x1003, gdcm::VR::FD, gdcm::VM::VM1> spaceTagZ; // (Philips specific)
gdcm::Attribute<0x0018, 0x6024> physicalTagX; // if 3, then spacing params are centimeter
gdcm::Attribute<0x0018, 0x6026> physicalTagY;
gdcm::Attribute<0x3001, 0x1002, gdcm::VR::US, gdcm::VM::VM1> physicalTagZ; // (Philips specific)
dimTagX.Set(data_set);
dimTagY.Set(data_set);
dimTagZ.Set(data_set);
dimTagT.Set(data_set);
spaceTagX.Set(data_set);
spaceTagY.Set(data_set);
spaceTagZ.Set(data_set);
physicalTagX.Set(data_set);
physicalTagY.Set(data_set);
physicalTagZ.Set(data_set);
unsigned int dimX = dimTagX.GetValue(), dimY = dimTagY.GetValue(), dimZ = dimTagZ.GetValue(),
dimT = dimTagT.GetValue(), physicalX = physicalTagX.GetValue(), physicalY = physicalTagY.GetValue(),
physicalZ = physicalTagZ.GetValue();
float spaceX = spaceTagX.GetValue(), spaceY = spaceTagY.GetValue(), spaceZ = spaceTagZ.GetValue();
if (physicalX == 3) // spacing parameter in cm, have to convert it to mm.
spaceX = spaceX * 10;
if (physicalY == 3) // spacing parameter in cm, have to convert it to mm.
spaceY = spaceY * 10;
if (physicalZ == 3) // spacing parameter in cm, have to convert it to mm.
spaceZ = spaceZ * 10;
// Ok, got all necessary Tags!
// Now read Pixeldata (7fe0,0010) X x Y x Z x T Elements
const gdcm::Pixmap &pixels = reader.GetPixmap();
gdcm::RAWCodec codec;
codec.SetPhotometricInterpretation(gdcm::PhotometricInterpretation::MONOCHROME2);
codec.SetPixelFormat(pixels.GetPixelFormat());
codec.SetPlanarConfiguration(0);
gdcm::DataElement out;
codec.Decode(data_set.GetDataElement(gdcm::Tag(0x7fe0, 0x0010)), out);
const gdcm::ByteValue *bv = out.GetByteValue();
const char *new_pixels = bv->GetPointer();
// Create MITK Image + Geometry
typedef itk::Image<unsigned char, 4>
ImageType; // Pixeltype might be different sometimes? Maybe read it out from header
ImageType::RegionType myRegion;
ImageType::SizeType mySize;
ImageType::IndexType myIndex;
ImageType::SpacingType mySpacing;
ImageType::Pointer imageItk = ImageType::New();
mySpacing[0] = spaceX;
mySpacing[1] = spaceY;
mySpacing[2] = spaceZ;
mySpacing[3] = 1;
myIndex[0] = 0;
myIndex[1] = 0;
myIndex[2] = 0;
myIndex[3] = 0;
mySize[0] = dimX;
mySize[1] = dimY;
mySize[2] = dimZ;
mySize[3] = dimT;
myRegion.SetSize(mySize);
myRegion.SetIndex(myIndex);
imageItk->SetSpacing(mySpacing);
imageItk->SetRegions(myRegion);
imageItk->Allocate();
imageItk->FillBuffer(0);
itk::ImageRegionIterator<ImageType> iterator(imageItk, imageItk->GetLargestPossibleRegion());
iterator.GoToBegin();
unsigned long pixCount = 0;
unsigned long planeSize = dimX * dimY;
unsigned long planeCount = 0;
unsigned long timeCount = 0;
unsigned long numberOfSlices = dimZ;
while (!iterator.IsAtEnd())
{
- unsigned long adressedPixel =
+ unsigned long addressedPixel =
pixCount +
- (numberOfSlices - 1 - planeCount) * planeSize // add offset to adress the first pixel of current plane
+ (numberOfSlices - 1 - planeCount) * planeSize // add offset to address the first pixel of current plane
+ timeCount * numberOfSlices * planeSize; // add time offset
- iterator.Set(new_pixels[adressedPixel]);
+ iterator.Set(new_pixels[addressedPixel]);
pixCount++;
++iterator;
if (pixCount == planeSize)
{
pixCount = 0;
planeCount++;
}
if (planeCount == numberOfSlices)
{
planeCount = 0;
timeCount++;
}
if (timeCount == dimT)
{
break;
}
}
mitk::CastToMitkImage(imageItk, output_image);
return true; // actually never returns false yet.. but exception possible
}
std::string DicomSeriesReader::ConstCharStarToString(const char *s) { return s ? std::string(s) : std::string(); }
bool DicomSeriesReader::DICOMStringToSpacing(const std::string &s, ScalarType &spacingX, ScalarType &spacingY)
{
bool successful = false;
std::istringstream spacingReader(s);
std::string spacing;
if (std::getline(spacingReader, spacing, '\\'))
{
spacingY = atof(spacing.c_str());
if (std::getline(spacingReader, spacing, '\\'))
{
spacingX = atof(spacing.c_str());
successful = true;
}
}
return successful;
}
Point3D DicomSeriesReader::DICOMStringToPoint3D(const std::string &s, bool &successful)
{
Point3D p;
successful = true;
std::istringstream originReader(s);
std::string coordinate;
unsigned int dim(0);
while (std::getline(originReader, coordinate, '\\') && dim < 3)
{
p[dim++] = atof(coordinate.c_str());
}
if (dim && dim != 3)
{
successful = false;
MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0032). Found " << dim
<< " instead of 3 values.";
}
else if (dim == 0)
{
successful = false;
p.Fill(0.0); // assume default (0,0,0)
}
return p;
}
void DicomSeriesReader::DICOMStringToOrientationVectors(const std::string &s,
Vector3D &right,
Vector3D &up,
bool &successful)
{
successful = true;
std::istringstream orientationReader(s);
std::string coordinate;
unsigned int dim(0);
while (std::getline(orientationReader, coordinate, '\\') && dim < 6)
{
if (dim < 3)
{
right[dim++] = atof(coordinate.c_str());
}
else
{
up[dim++ - 3] = atof(coordinate.c_str());
}
}
if (dim && dim != 6)
{
successful = false;
MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0037). Found " << dim
<< " instead of 6 values.";
}
else if (dim == 0)
{
// fill with defaults
right.Fill(0.0);
right[0] = 1.0;
up.Fill(0.0);
up[1] = 1.0;
successful = false;
}
}
DicomSeriesReader::SliceGroupingAnalysisResult DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
const StringContainer &files, bool groupImagesWithGantryTilt, const gdcm::Scanner::MappingType &tagValueMappings_)
{
// result.first = files that fit ITK's assumption
// result.second = files that do not fit, should be run through
// AnalyzeFileForITKImageSeriesReaderSpacingAssumption()
// again
SliceGroupingAnalysisResult result;
// we const_cast here, because I could not use a map.at(), which would make the code much more readable
auto &tagValueMappings = const_cast<gdcm::Scanner::MappingType &>(tagValueMappings_);
const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // Image Orientation
const gdcm::Tag tagGantryTilt(0x0018, 0x1120); // gantry tilt
Vector3D fromFirstToSecondOrigin;
fromFirstToSecondOrigin.Fill(0.0);
bool fromFirstToSecondOriginInitialized(false);
Point3D thisOrigin;
thisOrigin.Fill(0.0f);
Point3D lastOrigin;
lastOrigin.Fill(0.0f);
Point3D lastDifferentOrigin;
lastDifferentOrigin.Fill(0.0f);
bool lastOriginInitialized(false);
MITK_DEBUG << "--------------------------------------------------------------------------------";
MITK_DEBUG << "Analyzing files for z-spacing assumption of ITK's ImageSeriesReader (group tilted: "
<< groupImagesWithGantryTilt << ")";
unsigned int fileIndex(0);
for (auto fileIter = files.begin(); fileIter != files.end(); ++fileIter, ++fileIndex)
{
bool fileFitsIntoPattern(false);
std::string thisOriginString;
// Read tag value into point3D. PLEASE replace this by appropriate GDCM code if you figure out how to do that
thisOriginString = ConstCharStarToString(tagValueMappings[fileIter->c_str()][tagImagePositionPatient]);
if (thisOriginString.empty())
{
// don't let such files be in a common group. Everything without position information will be loaded as a single
// slice:
// with standard DICOM files this can happen to: CR, DX, SC
MITK_DEBUG << " ==> Sort away " << *fileIter
<< " for later analysis (no position information)"; // we already have one occupying this position
if (result.GetBlockFilenames().empty()) // nothing WITH position information yet
{
// ==> this is a group of its own, stop processing, come back later
result.AddFileToSortedBlock(*fileIter);
StringContainer remainingFiles;
remainingFiles.insert(remainingFiles.end(), fileIter + 1, files.end());
result.AddFilesToUnsortedBlock(remainingFiles);
fileFitsIntoPattern = false;
break; // no files anymore
}
else
{
// ==> this does not match, consider later
result.AddFileToUnsortedBlock(*fileIter);
fileFitsIntoPattern = false;
continue; // next file
}
}
bool ignoredConversionError(-42); // hard to get here, no graceful way to react
thisOrigin = DICOMStringToPoint3D(thisOriginString, ignoredConversionError);
MITK_DEBUG << " " << fileIndex << " " << *fileIter << " at "
/* << thisOriginString */
<< "(" << thisOrigin[0] << "," << thisOrigin[1] << "," << thisOrigin[2] << ")";
if (lastOriginInitialized && (thisOrigin == lastOrigin))
{
MITK_DEBUG << " ==> Sort away " << *fileIter
<< " for separate time step"; // we already have one occupying this position
result.AddFileToUnsortedBlock(*fileIter);
fileFitsIntoPattern = false;
}
else
{
if (!fromFirstToSecondOriginInitialized &&
lastOriginInitialized) // calculate vector as soon as possible when we get a new position
{
fromFirstToSecondOrigin = thisOrigin - lastDifferentOrigin;
fromFirstToSecondOriginInitialized = true;
// Here we calculate if this slice and the previous one are well aligned,
// i.e. we test if the previous origin is on a line through the current
// origin, directed into the normal direction of the current slice.
// If this is NOT the case, then we have a data set with a TILTED GANTRY geometry,
// which cannot be simply loaded into a single mitk::Image at the moment.
// For this case, we flag this finding in the result and DicomSeriesReader
// can correct for that later.
Vector3D right;
right.Fill(0.0);
Vector3D up;
right.Fill(0.0); // might be down as well, but it is just a name at this point
DICOMStringToOrientationVectors(
tagValueMappings[fileIter->c_str()][tagImageOrientation], right, up, ignoredConversionError);
GantryTiltInformation tiltInfo(lastDifferentOrigin, thisOrigin, right, up, 1);
if (tiltInfo.IsSheared()) // mitk::eps is too small; 1/1000 of a mm should be enough to detect tilt
{
/* optimistic approach, accepting gantry tilt: save file for later, check all further files */
// at this point we have TWO slices analyzed! if they are the only two files, we still split, because there
// is
// no third to verify our tilting assumption.
// later with a third being available, we must check if the initial tilting vector is still valid. if yes,
// continue.
// if NO, we need to split the already sorted part (result.first) and the currently analyzed file
// (*fileIter)
// tell apart gantry tilt from overall skewedness
// sort out irregularly sheared slices, that IS NOT tilting
if (groupImagesWithGantryTilt && tiltInfo.IsRegularGantryTilt())
{
// check if this is at least roughly the same angle as recorded in DICOM tags
if (tagValueMappings[fileIter->c_str()].find(tagGantryTilt) != tagValueMappings[fileIter->c_str()].end())
{
// read value, compare to calculated angle
std::string tiltStr = ConstCharStarToString(tagValueMappings[fileIter->c_str()][tagGantryTilt]);
double angle = atof(tiltStr.c_str());
MITK_DEBUG << "Comparing recorded tilt angle " << angle << " against calculated value "
<< tiltInfo.GetTiltAngleInDegrees();
// TODO we probably want the signs correct, too (that depends: this is just a rough check, nothing
// serious)
// TODO TODO TODO when angle -27 and tiltangle 63, this will never trigger the if-clause... useless
// check
// in this case! old bug..?!
if (fabs(angle) - tiltInfo.GetTiltAngleInDegrees() > 0.25)
{
result.AddFileToUnsortedBlock(*fileIter); // sort away for further analysis
fileFitsIntoPattern = false;
}
else // tilt angle from header is less than 0.25 degrees different from what we calculated, assume this
// is
// fine
{
result.FlagGantryTilt();
result.AddFileToSortedBlock(*fileIter); // this file is good for current block
fileFitsIntoPattern = true;
}
}
else // we cannot check the calculated tilt angle against the one from the dicom header (so we assume we
// are
// right)
{
result.FlagGantryTilt();
result.AddFileToSortedBlock(*fileIter); // this file is good for current block
fileFitsIntoPattern = true;
}
}
else // caller does not want tilt compensation OR shearing is more complicated than tilt
{
result.AddFileToUnsortedBlock(*fileIter); // sort away for further analysis
fileFitsIntoPattern = false;
}
}
else // not sheared
{
result.AddFileToSortedBlock(*fileIter); // this file is good for current block
fileFitsIntoPattern = true;
}
}
else if (fromFirstToSecondOriginInitialized) // we already know the offset between slices
{
Point3D assumedOrigin = lastDifferentOrigin + fromFirstToSecondOrigin;
Vector3D originError = assumedOrigin - thisOrigin;
double norm = originError.GetNorm();
double toleratedError(0.005); // max. 1/10mm error when measurement crosses 20 slices in z direction
if (norm > toleratedError)
{
MITK_DEBUG << " File does not fit into the inter-slice distance pattern (diff = " << norm << ", allowed "
<< toleratedError << ").";
MITK_DEBUG << " Expected position (" << assumedOrigin[0] << "," << assumedOrigin[1] << ","
<< assumedOrigin[2] << "), got position (" << thisOrigin[0] << "," << thisOrigin[1] << ","
<< thisOrigin[2] << ")";
MITK_DEBUG << " ==> Sort away " << *fileIter << " for later analysis";
// At this point we know we deviated from the expectation of ITK's ImageSeriesReader
// We split the input file list at this point, i.e. all files up to this one (excluding it)
// are returned as group 1, the remaining files (including the faulty one) are group 2
/* Optimistic approach: check if any of the remaining slices fits in */
result.AddFileToUnsortedBlock(*fileIter); // sort away for further analysis
fileFitsIntoPattern = false;
}
else
{
result.AddFileToSortedBlock(*fileIter); // this file is good for current block
fileFitsIntoPattern = true;
}
}
else // this should be the very first slice
{
result.AddFileToSortedBlock(*fileIter); // this file is good for current block
fileFitsIntoPattern = true;
}
}
// record current origin for reference in later iterations
if (!lastOriginInitialized || (fileFitsIntoPattern && (thisOrigin != lastOrigin)))
{
lastDifferentOrigin = thisOrigin;
}
lastOrigin = thisOrigin;
lastOriginInitialized = true;
}
if (result.ContainsGantryTilt())
{
// check here how many files were grouped.
// IF it was only two files AND we assume tiltedness (e.g. save "distance")
// THEN we would want to also split the two previous files (simple) because
// we don't have any reason to assume they belong together
if (result.GetBlockFilenames().size() == 2)
{
result.UndoPrematureGrouping();
}
}
return result;
}
DicomSeriesReader::FileNamesGrouping DicomSeriesReader::GetSeries(const StringContainer &files,
bool groupImagesWithGantryTilt,
const StringContainer &restrictions)
{
return GetSeries(files, true, groupImagesWithGantryTilt, restrictions);
}
DicomSeriesReader::FileNamesGrouping DicomSeriesReader::GetSeries(const StringContainer &files,
bool sortTo3DPlust,
bool groupImagesWithGantryTilt,
const StringContainer & /*restrictions*/)
{
/**
assumption about this method:
returns a map of uid-like-key --> list(filename)
each entry should contain filenames that have images of same
- series instance uid (automatically done by GDCMSeriesFileNames
- 0020,0037 image orientation (patient)
- 0028,0030 pixel spacing (x,y)
- 0018,0050 slice thickness
*/
// use GDCM directly, itk::GDCMSeriesFileNames does not work with GDCM 2
// PART I: scan files for sorting relevant DICOM tags,
// separate images that differ in any of those
// attributes (they cannot possibly form a 3D block)
// scan for relevant tags in dicom files
gdcm::Scanner scanner;
const gdcm::Tag tagSOPClassUID(0x0008, 0x0016); // SOP class UID
scanner.AddTag(tagSOPClassUID);
const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e); // Series Instance UID
scanner.AddTag(tagSeriesInstanceUID);
const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // image orientation
scanner.AddTag(tagImageOrientation);
const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
scanner.AddTag(tagPixelSpacing);
const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // imager pixel spacing
scanner.AddTag(tagImagerPixelSpacing);
const gdcm::Tag tagSliceThickness(0x0018, 0x0050); // slice thickness
scanner.AddTag(tagSliceThickness);
const gdcm::Tag tagNumberOfRows(0x0028, 0x0010); // number rows
scanner.AddTag(tagNumberOfRows);
const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011); // number cols
scanner.AddTag(tagNumberOfColumns);
const gdcm::Tag tagGantryTilt(0x0018, 0x1120); // gantry tilt
scanner.AddTag(tagGantryTilt);
const gdcm::Tag tagModality(0x0008, 0x0060); // modality
scanner.AddTag(tagModality);
const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
scanner.AddTag(tagNumberOfFrames);
// additional tags read in this scan to allow later analysis
// THESE tag are not used for initial separating of files
const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
scanner.AddTag(tagImagePositionPatient);
// TODO add further restrictions from arguments (when anybody asks for it)
FileNamesGrouping result;
// let GDCM scan files
if (!scanner.Scan(files))
{
MITK_ERROR << "gdcm::Scanner failed when scanning " << files.size() << " input files.";
return result;
}
// assign files IDs that will separate them for loading into image blocks
for (auto fileIter = scanner.Begin(); fileIter != scanner.End(); ++fileIter)
{
if (std::string(fileIter->first).empty())
continue; // TODO understand why Scanner has empty string entries
if (std::string(fileIter->first) == std::string("DICOMDIR"))
continue;
/* sort out multi-frame
if ( scanner.GetValue( fileIter->first , tagNumberOfFrames ) )
{
MITK_INFO << "Ignoring " << fileIter->first << " because we cannot handle multi-frame images.";
continue;
}
*/
// we const_cast here, because I could not use a map.at() function in CreateMoreUniqueSeriesIdentifier.
// doing the same thing with find would make the code less readable. Since we forget the Scanner results
// anyway after this function, we can simply tolerate empty map entries introduced by bad operator[] access
std::string moreUniqueSeriesId =
CreateMoreUniqueSeriesIdentifier(const_cast<gdcm::Scanner::TagToValue &>(fileIter->second));
result[moreUniqueSeriesId].AddFile(fileIter->first);
}
// PART II: sort slices spatially (or at least consistently if this is NOT possible, see method)
for (FileNamesGrouping::const_iterator groupIter = result.begin(); groupIter != result.end(); ++groupIter)
{
try
{
result[groupIter->first] =
ImageBlockDescriptor(SortSeriesSlices(groupIter->second.GetFilenames())); // sort each slice group spatially
}
catch (...)
{
MITK_ERROR << "Caught something.";
}
}
// PART III: analyze pre-sorted images for valid blocks (i.e. blocks of equal z-spacing),
// separate into multiple blocks if necessary.
//
// Analysis performs the following steps:
// * imitate itk::ImageSeriesReader: use the distance between the first two images as z-spacing
// * check what images actually fulfill ITK's z-spacing assumption
// * separate all images that fail the test into new blocks, re-iterate analysis for these blocks
// * this includes images which DO NOT PROVIDE spatial information, i.e. all images w/o
// ImagePositionPatient will be loaded separately
FileNamesGrouping groupsOf3DPlusTBlocks; // final result of this function
for (FileNamesGrouping::const_iterator groupIter = result.begin(); groupIter != result.end(); ++groupIter)
{
FileNamesGrouping groupsOf3DBlocks; // intermediate result for only this group(!)
StringContainer filesStillToAnalyze = groupIter->second.GetFilenames();
std::string groupUID = groupIter->first;
unsigned int subgroup(0);
MITK_DEBUG << "Analyze group " << groupUID << " of " << groupIter->second.GetFilenames().size() << " files";
while (!filesStillToAnalyze.empty()) // repeat until all files are grouped somehow
{
SliceGroupingAnalysisResult analysisResult = AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
filesStillToAnalyze, groupImagesWithGantryTilt, scanner.GetMappings());
// enhance the UID for additional groups
std::stringstream newGroupUID;
newGroupUID << groupUID << '.' << subgroup;
ImageBlockDescriptor thisBlock(analysisResult.GetBlockFilenames());
std::string firstFileInBlock = thisBlock.GetFilenames().front();
thisBlock.SetImageBlockUID(newGroupUID.str());
thisBlock.SetSeriesInstanceUID(
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagSeriesInstanceUID)));
thisBlock.SetHasGantryTiltCorrected(analysisResult.ContainsGantryTilt());
thisBlock.SetSOPClassUID(
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagSOPClassUID)));
thisBlock.SetNumberOfFrames(
ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagNumberOfFrames)));
thisBlock.SetModality(
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagModality)));
thisBlock.SetPixelSpacingInformation(
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagPixelSpacing)),
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(firstFileInBlock.c_str(), tagImagerPixelSpacing)));
thisBlock.SetHasMultipleTimePoints(false);
groupsOf3DBlocks[newGroupUID.str()] = thisBlock;
// MITK_DEBUG << "Result: sorted 3D group " << newGroupUID.str() << " with " << groupsOf3DBlocks[
// newGroupUID.str() ].GetFilenames().size() << " files";
MITK_DEBUG << "Result: sorted 3D group with " << groupsOf3DBlocks[newGroupUID.str()].GetFilenames().size()
<< " files";
StringContainer debugOutputFiles = analysisResult.GetBlockFilenames();
for (StringContainer::const_iterator siter = debugOutputFiles.begin(); siter != debugOutputFiles.end(); ++siter)
MITK_DEBUG << " IN " << *siter;
++subgroup;
filesStillToAnalyze = analysisResult.GetUnsortedFilenames(); // remember what needs further analysis
for (StringContainer::const_iterator siter = filesStillToAnalyze.begin(); siter != filesStillToAnalyze.end();
++siter)
MITK_DEBUG << " OUT " << *siter;
}
// end of grouping, now post-process groups
// PART IV: attempt to group blocks to 3D+t blocks if requested
// inspect entries of groupsOf3DBlocks
// - if number of files is identical to previous entry, collect for 3D+t block
// - as soon as number of files changes from previous entry, record collected blocks as 3D+t block,
// start
// a new one, continue
// decide whether or not to group 3D blocks into 3D+t blocks where possible
if (!sortTo3DPlust)
{
// copy 3D blocks to output
groupsOf3DPlusTBlocks.insert(groupsOf3DBlocks.begin(), groupsOf3DBlocks.end());
}
else
{
// sort 3D+t (as described in "PART IV")
MITK_DEBUG << "================================================================================";
MITK_DEBUG << "3D+t analysis:";
unsigned int numberOfFilesInPreviousBlock(0);
std::string previousBlockKey;
for (FileNamesGrouping::const_iterator block3DIter = groupsOf3DBlocks.begin();
block3DIter != groupsOf3DBlocks.end();
++block3DIter)
{
unsigned int numberOfFilesInThisBlock = block3DIter->second.GetFilenames().size();
std::string thisBlockKey = block3DIter->first;
if (numberOfFilesInPreviousBlock == 0)
{
numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
groupsOf3DPlusTBlocks[thisBlockKey] = block3DIter->second;
MITK_DEBUG << " 3D+t group " << thisBlockKey;
previousBlockKey = thisBlockKey;
}
else
{
bool identicalOrigins;
try
{
- // check whether this and the previous block share a comon origin
+ // check whether this and the previous block share a common origin
// TODO should be safe, but a little try/catch or other error handling wouldn't hurt
const char *origin_value = scanner.GetValue(groupsOf3DBlocks[thisBlockKey].GetFilenames().front().c_str(),
tagImagePositionPatient),
*previous_origin_value = scanner.GetValue(
groupsOf3DBlocks[previousBlockKey].GetFilenames().front().c_str(), tagImagePositionPatient),
*destination_value = scanner.GetValue(
groupsOf3DBlocks[thisBlockKey].GetFilenames().back().c_str(), tagImagePositionPatient),
*previous_destination_value = scanner.GetValue(
groupsOf3DBlocks[previousBlockKey].GetFilenames().back().c_str(), tagImagePositionPatient);
if (!origin_value || !previous_origin_value || !destination_value || !previous_destination_value)
{
identicalOrigins = false;
}
else
{
std::string thisOriginString = ConstCharStarToString(origin_value);
std::string previousOriginString = ConstCharStarToString(previous_origin_value);
// also compare last origin, because this might differ if z-spacing is different
std::string thisDestinationString = ConstCharStarToString(destination_value);
std::string previousDestinationString = ConstCharStarToString(previous_destination_value);
identicalOrigins =
((thisOriginString == previousOriginString) && (thisDestinationString == previousDestinationString));
}
}
catch (...)
{
identicalOrigins = false;
}
if (identicalOrigins && (numberOfFilesInPreviousBlock == numberOfFilesInThisBlock))
{
// group with previous block
groupsOf3DPlusTBlocks[previousBlockKey].AddFiles(block3DIter->second.GetFilenames());
groupsOf3DPlusTBlocks[previousBlockKey].SetHasMultipleTimePoints(true);
MITK_DEBUG << " --> group enhanced with another timestep";
}
else
{
// start a new block
groupsOf3DPlusTBlocks[thisBlockKey] = block3DIter->second;
int numberOfTimeSteps =
groupsOf3DPlusTBlocks[previousBlockKey].GetFilenames().size() / numberOfFilesInPreviousBlock;
MITK_DEBUG << " ==> group closed with " << numberOfTimeSteps << " time steps";
previousBlockKey = thisBlockKey;
MITK_DEBUG << " 3D+t group " << thisBlockKey << " started";
}
}
numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
}
}
}
MITK_DEBUG << "================================================================================";
MITK_DEBUG << "Summary: ";
for (FileNamesGrouping::const_iterator groupIter = groupsOf3DPlusTBlocks.begin();
groupIter != groupsOf3DPlusTBlocks.end();
++groupIter)
{
ImageBlockDescriptor block = groupIter->second;
MITK_DEBUG << " " << block.GetFilenames().size() << " '" << block.GetModality() << "' images ("
<< block.GetSOPClassUIDAsString() << ") in volume " << block.GetImageBlockUID();
MITK_DEBUG << " (gantry tilt : " << (block.HasGantryTiltCorrected() ? "Yes" : "No") << "; "
"pixel spacing : "
<< PixelSpacingInterpretationToString(block.GetPixelSpacingType()) << "; "
"3D+t: "
<< (block.HasMultipleTimePoints() ? "Yes" : "No") << "; "
"reader support: "
<< ReaderImplementationLevelToString(block.GetReaderImplementationLevel()) << ")";
StringContainer debugOutputFiles = block.GetFilenames();
for (StringContainer::const_iterator siter = debugOutputFiles.begin(); siter != debugOutputFiles.end(); ++siter)
MITK_DEBUG << " F " << *siter;
}
MITK_DEBUG << "================================================================================";
return groupsOf3DPlusTBlocks;
}
DicomSeriesReader::FileNamesGrouping DicomSeriesReader::GetSeries(const std::string &dir,
bool groupImagesWithGantryTilt,
const StringContainer &restrictions)
{
gdcm::Directory directoryLister;
directoryLister.Load(dir.c_str(), false); // non-recursive
return GetSeries(directoryLister.GetFilenames(), groupImagesWithGantryTilt, restrictions);
}
std::string DicomSeriesReader::CreateSeriesIdentifierPart(gdcm::Scanner::TagToValue &tagValueMap,
const gdcm::Tag &tag)
{
std::string result;
try
{
result = IDifyTagValue(tagValueMap[tag] ? tagValueMap[tag] : std::string(""));
}
catch ( const std::exception & )
{
// we are happy with even nothing, this will just group images of a series
// MITK_WARN << "Could not access tag " << tag << ": " << e.what();
}
return result;
}
std::string DicomSeriesReader::CreateMoreUniqueSeriesIdentifier(gdcm::Scanner::TagToValue &tagValueMap)
{
const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e); // Series Instance UID
const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // image orientation
const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // imager pixel spacing
const gdcm::Tag tagSliceThickness(0x0018, 0x0050); // slice thickness
const gdcm::Tag tagNumberOfRows(0x0028, 0x0010); // number rows
const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011); // number cols
const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
const char *tagSeriesInstanceUid = tagValueMap[tagSeriesInstanceUID];
if (!tagSeriesInstanceUid)
{
mitkThrow() << "CreateMoreUniqueSeriesIdentifier() could not access series instance UID. Something is seriously "
"wrong with this image, so stopping here.";
}
std::string constructedID = tagSeriesInstanceUid;
constructedID += CreateSeriesIdentifierPart(tagValueMap, tagNumberOfRows);
constructedID += CreateSeriesIdentifierPart(tagValueMap, tagNumberOfColumns);
constructedID += CreateSeriesIdentifierPart(tagValueMap, tagPixelSpacing);
constructedID += CreateSeriesIdentifierPart(tagValueMap, tagImagerPixelSpacing);
constructedID += CreateSeriesIdentifierPart(tagValueMap, tagSliceThickness);
constructedID += CreateSeriesIdentifierPart(tagValueMap, tagNumberOfFrames);
- // be a bit tolerant for orienatation, let only the first few digits matter
+ // be a bit tolerant for orientation, let only the first few digits matter
// (http://bugs.mitk.org/show_bug.cgi?id=12263)
// NOT constructedID += CreateSeriesIdentifierPart( tagValueMap, tagImageOrientation );
if (tagValueMap.find(tagImageOrientation) != tagValueMap.end())
{
bool conversionError(false);
Vector3D right;
right.Fill(0.0);
Vector3D up;
right.Fill(0.0);
DICOMStringToOrientationVectors(tagValueMap[tagImageOrientation], right, up, conversionError);
// string newstring sprintf(simplifiedOrientationString, "%.3f\\%.3f\\%.3f\\%.3f\\%.3f\\%.3f", right[0],
// right[1],
// right[2], up[0], up[1], up[2]);
std::ostringstream ss;
ss.setf(std::ios::fixed, std::ios::floatfield);
ss.precision(5);
ss << right[0] << "\\" << right[1] << "\\" << right[2] << "\\" << up[0] << "\\" << up[1] << "\\" << up[2];
std::string simplifiedOrientationString(ss.str());
constructedID += IDifyTagValue(simplifiedOrientationString);
}
constructedID.resize(constructedID.length() - 1); // cut of trailing '.'
return constructedID;
}
std::string DicomSeriesReader::IDifyTagValue(const std::string &value)
{
std::string IDifiedValue(value);
if (value.empty())
throw std::logic_error("IDifyTagValue() illegaly called with empty tag value");
// Eliminate non-alnum characters, including whitespace...
// that may have been introduced by concats.
for (std::size_t i = 0; i < IDifiedValue.size(); i++)
{
while (i < IDifiedValue.size() &&
!(IDifiedValue[i] == '.' || (IDifiedValue[i] >= 'a' && IDifiedValue[i] <= 'z') ||
(IDifiedValue[i] >= '0' && IDifiedValue[i] <= '9') ||
(IDifiedValue[i] >= 'A' && IDifiedValue[i] <= 'Z')))
{
IDifiedValue.erase(i, 1);
}
}
IDifiedValue += ".";
return IDifiedValue;
}
DicomSeriesReader::StringContainer DicomSeriesReader::GetSeries(const std::string &dir,
const std::string &series_uid,
bool groupImagesWithGantryTilt,
const StringContainer &restrictions)
{
FileNamesGrouping allSeries = GetSeries(dir, groupImagesWithGantryTilt, restrictions);
StringContainer resultingFileList;
for (FileNamesGrouping::const_iterator idIter = allSeries.begin(); idIter != allSeries.end(); ++idIter)
{
if (idIter->first.find(series_uid) == 0) // this ID starts with given series_uid
{
return idIter->second.GetFilenames();
}
}
return resultingFileList;
}
DicomSeriesReader::StringContainer DicomSeriesReader::SortSeriesSlices(const StringContainer &unsortedFilenames)
{
/* we CAN expect a group of equal
- series instance uid
- image orientation
- pixel spacing
- imager pixel spacing
- slice thickness
- number of rows/columns
(each piece of information except the rows/columns might be missing)
sorting with GdcmSortFunction tries its best by sorting by spatial position
and more hints (acquisition number, acquisition time, trigger time) but will
always produce a sorting by falling back to SOP Instance UID.
*/
gdcm::Sorter sorter;
sorter.SetSortFunction(DicomSeriesReader::GdcmSortFunction);
try
{
if (sorter.Sort(unsortedFilenames))
{
return sorter.GetFilenames();
}
else
{
MITK_WARN << "Sorting error. Leaving series unsorted.";
return unsortedFilenames;
}
}
catch ( const std::logic_error & )
{
MITK_WARN << "Sorting error. Leaving series unsorted.";
return unsortedFilenames;
}
}
bool DicomSeriesReader::GdcmSortFunction(const gdcm::DataSet &ds1, const gdcm::DataSet &ds2)
{
// This method MUST accept missing location and position information (and all else, too)
// because we cannot rely on anything
// (restriction on the sentence before: we have to provide consistent sorting, so we
// rely on the minimum information all DICOM files need to provide: SOP Instance UID)
/* we CAN expect a group of equal
- series instance uid
- image orientation
- pixel spacing
- imager pixel spacing
- slice thickness
- number of rows/columns
*/
static const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
static const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // Image Orientation
// see if we have Image Position and Orientation
if (ds1.FindDataElement(tagImagePositionPatient) && ds1.FindDataElement(tagImageOrientation) &&
ds2.FindDataElement(tagImagePositionPatient) && ds2.FindDataElement(tagImageOrientation))
{
gdcm::Attribute<0x0020, 0x0032> image_pos1; // Image Position (Patient)
gdcm::Attribute<0x0020, 0x0037> image_orientation1; // Image Orientation (Patient)
image_pos1.Set(ds1);
image_orientation1.Set(ds1);
gdcm::Attribute<0x0020, 0x0032> image_pos2;
gdcm::Attribute<0x0020, 0x0037> image_orientation2;
image_pos2.Set(ds2);
image_orientation2.Set(ds2);
/*
we tolerate very small differences in image orientation, since we got to know about
acquisitions where these values change across a single series (7th decimal digit)
(http://bugs.mitk.org/show_bug.cgi?id=12263)
still, we want to check if our assumption of 'almost equal' orientations is valid
*/
for (unsigned int dim = 0; dim < 6; ++dim)
{
if (fabs(image_orientation2[dim] - image_orientation1[dim]) > 0.0001)
{
MITK_ERROR << "Dicom images have different orientations.";
throw std::logic_error(
"Dicom images have different orientations. Call GetSeries() first to separate images.");
}
}
double normal[3];
normal[0] = image_orientation1[1] * image_orientation1[5] - image_orientation1[2] * image_orientation1[4];
normal[1] = image_orientation1[2] * image_orientation1[3] - image_orientation1[0] * image_orientation1[5];
normal[2] = image_orientation1[0] * image_orientation1[4] - image_orientation1[1] * image_orientation1[3];
double dist1 = 0.0, dist2 = 0.0;
// this computes the distance from world origin (0,0,0) ALONG THE NORMAL of the image planes
for (unsigned char i = 0u; i < 3u; ++i)
{
dist1 += normal[i] * image_pos1[i];
dist2 += normal[i] * image_pos2[i];
}
// if we can sort by just comparing the distance, we do exactly that
if (fabs(dist1 - dist2) >= mitk::eps)
{
// default: compare position
return dist1 < dist2;
}
else // we need to check more properties to distinguish slices
{
// try to sort by Acquisition Number
static const gdcm::Tag tagAcquisitionNumber(0x0020, 0x0012);
if (ds1.FindDataElement(tagAcquisitionNumber) && ds2.FindDataElement(tagAcquisitionNumber))
{
gdcm::Attribute<0x0020, 0x0012> acquisition_number1; // Acquisition number
gdcm::Attribute<0x0020, 0x0012> acquisition_number2;
acquisition_number1.Set(ds1);
acquisition_number2.Set(ds2);
if (acquisition_number1 != acquisition_number2)
{
return acquisition_number1 < acquisition_number2;
}
else // neither position nor acquisition number are good for sorting, so check more
{
// try to sort by Acquisition Time
static const gdcm::Tag tagAcquisitionTime(0x0008, 0x0032);
if (ds1.FindDataElement(tagAcquisitionTime) && ds2.FindDataElement(tagAcquisitionTime))
{
gdcm::Attribute<0x0008, 0x0032> acquisition_time1; // Acquisition time
gdcm::Attribute<0x0008, 0x0032> acquisition_time2;
acquisition_time1.Set(ds1);
acquisition_time2.Set(ds2);
if (acquisition_time1 != acquisition_time2)
{
return acquisition_time1 < acquisition_time2;
}
else // we gave up on image position, acquisition number and acquisition time now
{
// let's try trigger time
static const gdcm::Tag tagTriggerTime(0x0018, 0x1060);
if (ds1.FindDataElement(tagTriggerTime) && ds2.FindDataElement(tagTriggerTime))
{
gdcm::Attribute<0x0018, 0x1060> trigger_time1; // Trigger time
gdcm::Attribute<0x0018, 0x1060> trigger_time2;
trigger_time1.Set(ds1);
trigger_time2.Set(ds2);
if (trigger_time1 != trigger_time2)
{
return trigger_time1 < trigger_time2;
}
// ELSE!
// for this and many previous ifs we fall through if nothing lets us sort
} // .
} // .
} // .
}
}
}
} // .
// LAST RESORT: all valuable information for sorting is missing.
// Sort by some meaningless but unique identifiers to satisfy the sort function
static const gdcm::Tag tagSOPInstanceUID(0x0008, 0x0018);
if (ds1.FindDataElement(tagSOPInstanceUID) && ds2.FindDataElement(tagSOPInstanceUID))
{
MITK_DEBUG
<< "Dicom images are missing attributes for a meaningful sorting, falling back to SOP instance UID comparison.";
gdcm::Attribute<0x0008, 0x0018> SOPInstanceUID1; // SOP instance UID is mandatory and unique
gdcm::Attribute<0x0008, 0x0018> SOPInstanceUID2;
SOPInstanceUID1.Set(ds1);
SOPInstanceUID2.Set(ds2);
return SOPInstanceUID1 < SOPInstanceUID2;
}
else
{
// no DICOM file should really come down here, this should only be reached with unskillful and unlucky
// manipulation
// of files
std::string error_message("Malformed DICOM images, which do not even contain a SOP Instance UID.");
MITK_ERROR << error_message;
throw std::logic_error(error_message);
}
}
std::string DicomSeriesReader::GetConfigurationString()
{
std::stringstream configuration;
configuration << "MITK_USE_GDCMIO: ";
configuration << "true";
configuration << "\n";
configuration << "GDCM_VERSION: ";
#ifdef GDCM_MAJOR_VERSION
configuration << GDCM_VERSION;
#endif
// configuration << "\n";
return configuration.str();
}
void DicomSeriesReader::CopyMetaDataToImageProperties(StringContainer filenames,
const gdcm::Scanner::MappingType &tagValueMappings_,
DcmIoType *io,
const ImageBlockDescriptor &blockInfo,
Image *image)
{
std::list<StringContainer> imageBlock;
imageBlock.push_back(filenames);
CopyMetaDataToImageProperties(imageBlock, tagValueMappings_, io, blockInfo, image);
}
void DicomSeriesReader::CopyMetaDataToImageProperties(std::list<StringContainer> imageBlock,
const gdcm::Scanner::MappingType &tagValueMappings_,
DcmIoType *io,
const ImageBlockDescriptor &blockInfo,
Image *image)
{
if (!io || !image)
return;
StringLookupTable filesForSlices;
StringLookupTable sliceLocationForSlices;
StringLookupTable instanceNumberForSlices;
StringLookupTable SOPInstanceNumberForSlices;
auto &tagValueMappings = const_cast<gdcm::Scanner::MappingType &>(tagValueMappings_);
// DICOM tags which should be added to the image properties
const gdcm::Tag tagSliceLocation(0x0020, 0x1041); // slice location
const gdcm::Tag tagInstanceNumber(0x0020, 0x0013); // (image) instance number
const gdcm::Tag tagSOPInstanceNumber(0x0008, 0x0018); // SOP instance number
unsigned int timeStep(0);
std::string propertyKeySliceLocation = "dicom.image.0020.1041";
std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
std::string propertyKeySOPInstanceNumber = "dicom.image.0008.0018";
// tags for each image
for (auto i = imageBlock.begin(); i != imageBlock.end(); i++, timeStep++)
{
const StringContainer &files = (*i);
unsigned int slice(0);
for (auto fIter = files.begin(); fIter != files.end(); ++fIter, ++slice)
{
filesForSlices.SetTableValue(slice, *fIter);
gdcm::Scanner::TagToValue tagValueMapForFile = tagValueMappings[fIter->c_str()];
if (tagValueMapForFile.find(tagSliceLocation) != tagValueMapForFile.end())
sliceLocationForSlices.SetTableValue(slice, tagValueMapForFile[tagSliceLocation]);
if (tagValueMapForFile.find(tagInstanceNumber) != tagValueMapForFile.end())
instanceNumberForSlices.SetTableValue(slice, tagValueMapForFile[tagInstanceNumber]);
if (tagValueMapForFile.find(tagSOPInstanceNumber) != tagValueMapForFile.end())
SOPInstanceNumberForSlices.SetTableValue(slice, tagValueMapForFile[tagSOPInstanceNumber]);
}
image->SetProperty("files", StringLookupTableProperty::New(filesForSlices));
// If more than one time step add postfix ".t" + timestep
if (timeStep != 0)
{
std::ostringstream postfix;
postfix << ".t" << timeStep;
propertyKeySliceLocation.append(postfix.str());
propertyKeyInstanceNumber.append(postfix.str());
propertyKeySOPInstanceNumber.append(postfix.str());
}
image->SetProperty(propertyKeySliceLocation.c_str(), StringLookupTableProperty::New(sliceLocationForSlices));
image->SetProperty(propertyKeyInstanceNumber.c_str(), StringLookupTableProperty::New(instanceNumberForSlices));
image->SetProperty(propertyKeySOPInstanceNumber.c_str(),
StringLookupTableProperty::New(SOPInstanceNumberForSlices));
}
// Copy tags for series, study, patient level (leave interpretation to application).
// These properties will be copied to the DataNode by DicomSeriesReader.
- // tags for the series (we just use the one that ITK copied to its dictionary (proably that of the last slice)
+ // tags for the series (we just use the one that ITK copied to its dictionary (probably that of the last slice)
const itk::MetaDataDictionary &dict = io->GetMetaDataDictionary();
const TagToPropertyMapType &propertyLookup = DicomSeriesReader::GetDICOMTagsToMITKPropertyMap();
auto dictIter = dict.Begin();
while (dictIter != dict.End())
{
// MITK_DEBUG << "Key " << dictIter->first;
std::string value;
if (itk::ExposeMetaData<std::string>(dict, dictIter->first, value))
{
// MITK_DEBUG << "Value " << value;
auto valuePosition = propertyLookup.find(dictIter->first);
if (valuePosition != propertyLookup.end())
{
std::string propertyKey = valuePosition->second;
// MITK_DEBUG << "--> " << propertyKey;
image->SetProperty(propertyKey.c_str(), StringProperty::New(value));
}
}
else
{
MITK_WARN << "Tag " << dictIter->first << " not read as string as expected. Ignoring...";
}
++dictIter;
}
// copy imageblockdescriptor as properties
image->SetProperty("dicomseriesreader.SOPClass", StringProperty::New(blockInfo.GetSOPClassUIDAsString()));
image->SetProperty(
"dicomseriesreader.ReaderImplementationLevelString",
StringProperty::New(ReaderImplementationLevelToString(blockInfo.GetReaderImplementationLevel())));
image->SetProperty("dicomseriesreader.ReaderImplementationLevel",
GenericProperty<ReaderImplementationLevel>::New(blockInfo.GetReaderImplementationLevel()));
image->SetProperty("dicomseriesreader.PixelSpacingInterpretationString",
StringProperty::New(PixelSpacingInterpretationToString(blockInfo.GetPixelSpacingType())));
image->SetProperty("dicomseriesreader.PixelSpacingInterpretation",
GenericProperty<PixelSpacingInterpretation>::New(blockInfo.GetPixelSpacingType()));
image->SetProperty("dicomseriesreader.MultiFrameImage", BoolProperty::New(blockInfo.IsMultiFrameImage()));
image->SetProperty("dicomseriesreader.GantyTiltCorrected", BoolProperty::New(blockInfo.HasGantryTiltCorrected()));
image->SetProperty("dicomseriesreader.3D+t", BoolProperty::New(blockInfo.HasMultipleTimePoints()));
}
void DicomSeriesReader::FixSpacingInformation(mitk::Image *image, const ImageBlockDescriptor &imageBlockDescriptor)
{
// spacing provided by ITK/GDCM
Vector3D imageSpacing = image->GetGeometry()->GetSpacing();
ScalarType imageSpacingX = imageSpacing[0];
ScalarType imageSpacingY = imageSpacing[1];
// spacing as desired by MITK (preference for "in patient", else "on detector", or "1.0/1.0")
ScalarType desiredSpacingX = imageSpacingX;
ScalarType desiredSpacingY = imageSpacingY;
imageBlockDescriptor.GetDesiredMITKImagePixelSpacing(desiredSpacingX, desiredSpacingY);
MITK_DEBUG << "Loaded spacing: " << imageSpacingX << "/" << imageSpacingY;
MITK_DEBUG << "Corrected spacing: " << desiredSpacingX << "/" << desiredSpacingY;
imageSpacing[0] = desiredSpacingX;
imageSpacing[1] = desiredSpacingY;
image->GetGeometry()->SetSpacing(imageSpacing);
}
void DicomSeriesReader::LoadDicom(const StringContainer &filenames,
DataNode &node,
bool sort,
bool load4D,
bool correctTilt,
UpdateCallBackMethod callback,
Image::Pointer preLoadedImageBlock)
{
mitk::LocaleSwitch localeSwitch("C");
std::locale previousCppLocale(std::cin.getloc());
std::locale l("C");
std::cin.imbue(l);
ImageBlockDescriptor imageBlockDescriptor;
const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image Position (Patient)
const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // Image Orientation
const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e); // Series Instance UID
const gdcm::Tag tagSOPClassUID(0x0008, 0x0016); // SOP class UID
const gdcm::Tag tagModality(0x0008, 0x0060); // modality
const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // imager pixel spacing
const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
try
{
Image::Pointer image = preLoadedImageBlock.IsNull() ? Image::New() : preLoadedImageBlock;
CallbackCommand *command = callback ? new CallbackCommand(callback) : nullptr;
bool initialize_node = false;
/* special case for Philips 3D+t ultrasound images */
if (DicomSeriesReader::IsPhilips3DDicom(filenames.front().c_str()))
{
// TODO what about imageBlockDescriptor?
// TODO what about preLoadedImageBlock?
ReadPhilips3DDicom(filenames.front().c_str(), image);
initialize_node = true;
}
else
{
/* default case: assume "normal" image blocks, possibly 3D+t */
bool canLoadAs4D(true);
gdcm::Scanner scanner;
ScanForSliceInformation(filenames, scanner);
// need non-const access for map
auto &tagValueMappings = const_cast<gdcm::Scanner::MappingType &>(scanner.GetMappings());
std::list<StringContainer> imageBlocks =
SortIntoBlocksFor3DplusT(filenames, tagValueMappings, sort, canLoadAs4D);
unsigned int volume_count = imageBlocks.size();
imageBlockDescriptor.SetSeriesInstanceUID(
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagSeriesInstanceUID)));
imageBlockDescriptor.SetSOPClassUID(
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagSOPClassUID)));
imageBlockDescriptor.SetModality(
DicomSeriesReader::ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagModality)));
imageBlockDescriptor.SetNumberOfFrames(
ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagNumberOfFrames)));
imageBlockDescriptor.SetPixelSpacingInformation(
ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagPixelSpacing)),
ConstCharStarToString(scanner.GetValue(filenames.front().c_str(), tagImagerPixelSpacing)));
GantryTiltInformation tiltInfo;
// check possibility of a single slice with many timesteps. In this case, don't check for tilt, no second slice
// possible
if (!imageBlocks.empty() && imageBlocks.front().size() > 1 && correctTilt)
{
// check tiltedness here, potentially fixup ITK's loading result by shifting slice contents
// check first and last position slice from tags, make some calculations to detect tilt
std::string firstFilename(imageBlocks.front().front());
// calculate from first and last slice to minimize rounding errors
std::string secondFilename(imageBlocks.front().back());
std::string imagePosition1(
ConstCharStarToString(tagValueMappings[firstFilename.c_str()][tagImagePositionPatient]));
std::string imageOrientation(
ConstCharStarToString(tagValueMappings[firstFilename.c_str()][tagImageOrientation]));
std::string imagePosition2(
ConstCharStarToString(tagValueMappings[secondFilename.c_str()][tagImagePositionPatient]));
bool ignoredConversionError(-42); // hard to get here, no graceful way to react
Point3D origin1(DICOMStringToPoint3D(imagePosition1, ignoredConversionError));
Point3D origin2(DICOMStringToPoint3D(imagePosition2, ignoredConversionError));
Vector3D right;
right.Fill(0.0);
Vector3D up;
right.Fill(0.0); // might be down as well, but it is just a name at this point
DICOMStringToOrientationVectors(imageOrientation, right, up, ignoredConversionError);
tiltInfo = GantryTiltInformation(origin1, origin2, right, up, filenames.size() - 1);
correctTilt = tiltInfo.IsSheared() && tiltInfo.IsRegularGantryTilt();
}
else
{
correctTilt = false; // we CANNOT do that
}
imageBlockDescriptor.SetHasGantryTiltCorrected(correctTilt);
if (volume_count == 1 || !canLoadAs4D || !load4D)
{
DcmIoType::Pointer io;
image = MultiplexLoadDICOMByITK(
imageBlocks.front(), correctTilt, tiltInfo, io, command, preLoadedImageBlock); // load first 3D block
imageBlockDescriptor.AddFiles(imageBlocks.front()); // only the first part is loaded
imageBlockDescriptor.SetHasMultipleTimePoints(false);
FixSpacingInformation(image, imageBlockDescriptor);
CopyMetaDataToImageProperties(imageBlocks.front(), scanner.GetMappings(), io, imageBlockDescriptor, image);
initialize_node = true;
}
else if (volume_count > 1)
{
imageBlockDescriptor.AddFiles(filenames); // all is loaded
imageBlockDescriptor.SetHasMultipleTimePoints(true);
DcmIoType::Pointer io;
image = MultiplexLoadDICOMByITK4D(
imageBlocks, imageBlockDescriptor, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
initialize_node = true;
}
}
if (initialize_node)
{
// forward some image properties to node
node.GetPropertyList()->ConcatenatePropertyList(image->GetPropertyList(), true);
std::string patientName = "NoName";
if (node.GetProperty("dicom.patient.PatientsName"))
patientName = node.GetProperty("dicom.patient.PatientsName")->GetValueAsString();
node.SetData(image);
node.SetName(patientName);
std::cin.imbue(previousCppLocale);
}
MITK_DEBUG << "--------------------------------------------------------------------------------";
MITK_DEBUG << "DICOM files loaded (from series UID " << imageBlockDescriptor.GetSeriesInstanceUID() << "):";
MITK_DEBUG << " " << imageBlockDescriptor.GetFilenames().size() << " '" << imageBlockDescriptor.GetModality()
<< "' files (" << imageBlockDescriptor.GetSOPClassUIDAsString() << ") loaded into 1 mitk::Image";
MITK_DEBUG << " multi-frame: " << (imageBlockDescriptor.IsMultiFrameImage() ? "Yes" : "No");
MITK_DEBUG << " reader support: "
<< ReaderImplementationLevelToString(imageBlockDescriptor.GetReaderImplementationLevel());
MITK_DEBUG << " pixel spacing type: "
<< PixelSpacingInterpretationToString(imageBlockDescriptor.GetPixelSpacingType()) << " "
<< image->GetGeometry()->GetSpacing()[0] << "/" << image->GetGeometry()->GetSpacing()[0];
MITK_DEBUG << " gantry tilt corrected: " << (imageBlockDescriptor.HasGantryTiltCorrected() ? "Yes" : "No");
MITK_DEBUG << " 3D+t: " << (imageBlockDescriptor.HasMultipleTimePoints() ? "Yes" : "No");
MITK_DEBUG << "--------------------------------------------------------------------------------";
}
catch ( const std::exception &e )
{
// reset locale then throw up
std::cin.imbue(previousCppLocale);
MITK_DEBUG << "Caught exception in DicomSeriesReader::LoadDicom";
throw e;
}
}
void DicomSeriesReader::ScanForSliceInformation(const StringContainer &filenames, gdcm::Scanner &scanner)
{
const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image position (Patient)
scanner.AddTag(tagImagePositionPatient);
const gdcm::Tag tagSeriesInstanceUID(0x0020, 0x000e); // Series Instance UID
scanner.AddTag(tagSeriesInstanceUID);
const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // Image orientation
scanner.AddTag(tagImageOrientation);
const gdcm::Tag tagSliceLocation(0x0020, 0x1041); // slice location
scanner.AddTag(tagSliceLocation);
const gdcm::Tag tagInstanceNumber(0x0020, 0x0013); // (image) instance number
scanner.AddTag(tagInstanceNumber);
const gdcm::Tag tagSOPInstanceNumber(0x0008, 0x0018); // SOP instance number
scanner.AddTag(tagSOPInstanceNumber);
const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // Pixel Spacing
scanner.AddTag(tagPixelSpacing);
const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // Imager Pixel Spacing
scanner.AddTag(tagImagerPixelSpacing);
const gdcm::Tag tagModality(0x0008, 0x0060); // Modality
scanner.AddTag(tagModality);
const gdcm::Tag tagSOPClassUID(0x0008, 0x0016); // SOP Class UID
scanner.AddTag(tagSOPClassUID);
const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
scanner.AddTag(tagNumberOfFrames);
scanner.Scan(filenames); // make available image information for each file
}
std::list<DicomSeriesReader::StringContainer> DicomSeriesReader::SortIntoBlocksFor3DplusT(
const StringContainer &presortedFilenames,
const gdcm::Scanner::MappingType &tagValueMappings,
bool /*sort*/,
bool &canLoadAs4D)
{
std::list<StringContainer> imageBlocks;
// ignore sort request, because most likely re-sorting is now needed due to changes in GetSeries(bug #8022)
StringContainer sorted_filenames = DicomSeriesReader::SortSeriesSlices(presortedFilenames);
std::string firstPosition;
unsigned int numberOfBlocks(0); // number of 3D image blocks
static const gdcm::Tag tagImagePositionPatient(0x0020, 0x0032); // Image position (Patient)
const gdcm::Tag tagModality(0x0008, 0x0060);
// loop files to determine number of image blocks
for (StringContainer::const_iterator fileIter = sorted_filenames.begin(); fileIter != sorted_filenames.end();
++fileIter)
{
gdcm::Scanner::TagToValue tagToValueMap = tagValueMappings.find(fileIter->c_str())->second;
if (tagToValueMap.find(tagImagePositionPatient) == tagToValueMap.end())
{
const std::string &modality = tagToValueMap.find(tagModality)->second;
if (modality.compare("RTIMAGE ") == 0 || modality.compare("RTIMAGE") == 0)
{
MITK_WARN << "Modality " << modality << " is not fully supported yet.";
numberOfBlocks = 1;
break;
}
else
{
// we expect to get images w/ missing position information ONLY as separated blocks.
assert(presortedFilenames.size() == 1);
numberOfBlocks = 1;
break;
}
}
std::string position = tagToValueMap.find(tagImagePositionPatient)->second;
MITK_DEBUG << " " << *fileIter << " at " << position;
if (firstPosition.empty())
{
firstPosition = position;
}
if (position == firstPosition)
{
++numberOfBlocks;
}
else
{
break; // enough information to know the number of image blocks
}
}
MITK_DEBUG << " ==> Assuming " << numberOfBlocks << " time steps";
if (numberOfBlocks == 0)
return imageBlocks; // only possible if called with no files
// loop files to sort them into image blocks
unsigned int numberOfExpectedSlices(0);
for (unsigned int block = 0; block < numberOfBlocks; ++block)
{
StringContainer filesOfCurrentBlock;
for (StringContainer::const_iterator fileIter = sorted_filenames.begin() + block;
fileIter != sorted_filenames.end();
// fileIter += numberOfBlocks) // TODO shouldn't this work? give invalid iterators on first attempts
)
{
filesOfCurrentBlock.push_back(*fileIter);
for (unsigned int b = 0; b < numberOfBlocks; ++b)
{
if (fileIter != sorted_filenames.end())
++fileIter;
}
}
imageBlocks.push_back(filesOfCurrentBlock);
if (block == 0)
{
numberOfExpectedSlices = filesOfCurrentBlock.size();
}
else
{
if (filesOfCurrentBlock.size() != numberOfExpectedSlices)
{
MITK_WARN
<< "DicomSeriesReader expected " << numberOfBlocks << " image blocks of " << numberOfExpectedSlices
<< " images each. Block " << block << " got " << filesOfCurrentBlock.size()
<< " instead. Cannot load this as 3D+t"; // TODO implement recovery (load as many slices 3D+t as much
// as possible)
canLoadAs4D = false;
}
}
}
return imageBlocks;
}
Image::Pointer DicomSeriesReader::MultiplexLoadDICOMByITK(const StringContainer &filenames,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
Image::Pointer preLoadedImageBlock)
{
io = DcmIoType::New();
io->SetFileName(filenames.front().c_str());
io->ReadImageInformation();
if (io->GetPixelType() == itk::IOPixelEnum::SCALAR)
{
return MultiplexLoadDICOMByITKScalar(filenames, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
}
else if (io->GetPixelType() == itk::IOPixelEnum::RGB)
{
return MultiplexLoadDICOMByITKRGBPixel(filenames, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
}
else
{
return nullptr;
}
}
Image::Pointer DicomSeriesReader::MultiplexLoadDICOMByITK4D(std::list<StringContainer> &imageBlocks,
ImageBlockDescriptor imageBlockDescriptor,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
Image::Pointer preLoadedImageBlock)
{
io = DcmIoType::New();
io->SetFileName(imageBlocks.front().front().c_str());
io->ReadImageInformation();
if (io->GetPixelType() == itk::IOPixelEnum::SCALAR)
{
return MultiplexLoadDICOMByITK4DScalar(
imageBlocks, imageBlockDescriptor, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
}
else if (io->GetPixelType() == itk::IOPixelEnum::RGB)
{
return MultiplexLoadDICOMByITK4DRGBPixel(
imageBlocks, imageBlockDescriptor, correctTilt, tiltInfo, io, command, preLoadedImageBlock);
}
else
{
return nullptr;
}
}
} // end namespace mitk
diff --git a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.h b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.h
index 3a780617e0..e3faa54855 100644
--- a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.h
+++ b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.h
@@ -1,1033 +1,1033 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkDicomSeriesReader_h
#define mitkDicomSeriesReader_h
#include "mitkConfig.h"
#include "mitkDataNode.h"
#include <itkGDCMImageIO.h>
#include <itkCommand.h>
#include <itkImageSeriesReader.h>
#ifdef NOMINMAX
#define DEF_NOMINMAX
#undef NOMINMAX
#endif
#include <gdcmConfigure.h>
#ifdef DEF_NOMINMAX
#ifndef NOMINMAX
#define NOMINMAX
#endif
#undef DEF_NOMINMAX
#endif
#include <gdcmDataSet.h>
#include <gdcmScanner.h>
namespace mitk
{
/**
\brief Loading DICOM images as MITK images.
- \ref DicomSeriesReader_purpose
- \ref DicomSeriesReader_limitations
- \ref DicomSeriesReader_usage
- \ref DicomSeriesReader_sorting
- \ref DicomSeriesReader_sorting1
- \ref DicomSeriesReader_sorting2
- \ref DicomSeriesReader_sorting3
- \ref DicomSeriesReader_sorting4
- \ref DicomSeriesReader_gantrytilt
- \ref DicomSeriesReader_pixelspacing
- \ref DicomSeriesReader_nextworkitems
- \ref DicomSeriesReader_whynotinitk
- \ref DicomSeriesReader_tests
\section DicomSeriesReader_purpose Purpose
DicomSeriesReader serves as a central class for loading DICOM images as mitk::Image.
As the term "DICOM image" covers a huge variety of possible modalities and
implementations, and since MITK assumes that 3D images are made up of continuous blocks
of slices without any gaps or changes in orientation, the loading mechanism must
implement a number of decisions and compromises.
<b>The main intention of this implementation is not efficiency but correctness of generated slice positions and pixel
spacings!</b>
\section DicomSeriesReader_limitations Assumptions and limitations
The class is working only with GDCM 2.0.14 (or possibly newer). This version is the
default of an MITK super-build. Support for other versions or ITK's DicomIO was dropped
because of the associated complexity of DicomSeriesReader.
\b Assumptions
- expected to work with certain SOP Classes (mostly CT Image Storage and MR Image Storage)
- see ImageBlockDescriptor.GetReaderImplementationLevel() method for the details
- - special treatment for a certain type of Philips 3D ultrasound (recogized by tag 3001,0010 set to "Philips3D")
+ - special treatment for a certain type of Philips 3D ultrasound (recognized by tag 3001,0010 set to "Philips3D")
- loader will always attempt to read multiple single slices as a single 3D image volume (i.e. mitk::Image)
- slices will be grouped by basic properties such as orientation, rows, columns, spacing and grouped into as large
blocks as possible
- images which do NOT report a position or orientation in space (Image Position Patient, Image Orientation) will be
assigned defaults
- image position (0,0,0)
- image orientation (1,0,0), (0,1,0)
- such images will always be grouped separately since spatial grouping / sorting makes no sense for them
\b Options
- images that cover the same piece of space (i.e. position, orientation, and dimensions are equal)
can be interpreted as time-steps of the same image, i.e. a series will be loaded as 3D+t
\b Limitations
- the 3D+t assumption only works if all time-steps have an equal number of slices and if all
have the Acquisition Time attribute set to meaningful values
\section DicomSeriesReader_usage Usage
The starting point for an application is a set of DICOM files that should be loaded.
For convenience, DicomSeriesReader can also parse a whole directory for DICOM files,
but an application should better know exactly what to load.
Loading is then done in two steps:
1. <b>Group the files into spatial blocks</b> by calling GetSeries().
This method will sort all passed files into meaningful blocks that
could fit into an mitk::Image. Sorting for 3D+t loading is optional but default.
The \b return value of this function is a list of descriptors, which
describe a grouped list of files with its most basic properties:
- SOP Class (CT Image Storage, Secondary Capture Image Storage, etc.)
- Modality
- What type of pixel spacing can be read from the provided DICOM tags
- How well DicomSeriesReader is prepared to load this type of data
2. <b>Load a sorted set of files</b> by calling LoadDicomSeries().
This method expects go receive the sorting output of GetSeries().
The method will then invoke ITK methods configured with GDCM-IO
classes to actually load the files into memory and put them into
mitk::Images. Again, loading as 3D+t is optional.
Example:
\code
// only a directory is known at this point: /home/who/dicom
DicomSeriesReader::FileNamesGrouping allImageBlocks = DicomSeriesReader::GetSeries("/home/who/dicom/");
// file now divided into groups of identical image size, orientation, spacing, etc.
// each of these lists should be loadable as an mitk::Image.
DicomSeriesReader::StringContainer seriesToLoad = allImageBlocks[...]; // decide what to load
// final step: load into DataNode (can result in 3D+t image)
DataNode::Pointer node = DicomSeriesReader::LoadDicomSeries( oneBlockSorted );
itk::SmartPointer<Image> image = dynamic_cast<mitk::Image*>( node->GetData() );
\endcode
\section DicomSeriesReader_sorting Logic for sorting 2D slices from DICOM images into 3D+t blocks for mitk::Image
The general sorting mechanism (implemented in GetSeries) groups and sorts a set of DICOM files, each assumed to
contain
a single CT/MR slice.
In the following we refer to those file groups as "blocks", since this is what they are meant to become when loaded
into an mitk::Image.
\subsection DicomSeriesReader_sorting1 Step 1: Avoiding pure non-sense
A first pass separates slices that cannot possibly be loaded together because of restrictions of mitk::Image.
After this steps, each block contains only slices that match in all of the following DICOM tags:
- (0020,000e) Series Instance UID
- (0020,0037) Image Orientation
- (0028,0030) Pixel Spacing
- (0018,1164) Imager Pixel Spacing
- (0018,0050) Slice Thickness
- (0028,0010) Number Of Rows
- (0028,0011) Number Of Columns
- (0028,0008) Number Of Frames
\subsection DicomSeriesReader_sorting2 Step 2: Sort slices spatially
Before slices are further analyzed, they are sorted spatially. As implemented by GdcmSortFunction(),
slices are sorted by
1. distance from origin (calculated using (0020,0032) Image Position Patient and (0020,0037) Image Orientation)
- 2. when distance is equal, (0020,0012) Aquisition Number, (0008,0032) Acquisition Time and (0018,1060) Trigger Time
+ 2. when distance is equal, (0020,0012) Acquisition Number, (0008,0032) Acquisition Time and (0018,1060) Trigger Time
are
used as a backup criterions (necessary for meaningful 3D+t sorting)
\subsection DicomSeriesReader_sorting3 Step 3: Ensure equal z spacing
Since inter-slice distance is not recorded in DICOM tags, we must ensure that blocks are made up of
slices that have equal distances between neighboring slices. This is especially necessary because
itk::ImageSeriesReader
is later used for the actual loading, and this class expects (and does nocht verify) equal inter-slice distance (see
\ref DicomSeriesReader_whatweknowaboutitk).
To achieve such grouping, the inter-slice distance is calculated from the first two different slice positions of a
block.
Following slices are added to a block as long as they can be added by adding the calculated inter-slice distance to
the
last slice of the block. Slices that do not fit into the expected distance pattern, are set aside for further
analysis.
This grouping is done until each file has been assigned to a group.
Slices that share a position in space are also sorted into separate blocks during this step.
So the result of this step is a set of blocks that contain only slices with equal z spacing
- and uniqe slices at each position.
+ and unique slices at each position.
\subsection DicomSeriesReader_sorting4 Step 4 (optional): group 3D blocks as 3D+t when possible
This last step depends on an option of GetSeries(). When requested, image blocks from the previous step are merged
again
whenever two blocks occupy the same portion of space (i.e. same origin, number of slices and z-spacing).
\section DicomSeriesReader_gantrytilt Handling of gantry tilt
When CT gantry tilt is used, the gantry plane (= X-Ray source and detector ring) and the vertical plane do not align
- anymore. This scanner feature is used for example to reduce metal artifacs (e.g. <i>Lee C , Evaluation of Using CT
+ anymore. This scanner feature is used for example to reduce metal artifacts (e.g. <i>Lee C , Evaluation of Using CT
Gantry Tilt Scan on Head and Neck Cancer Patients with Dental Structure: Scans Show Less Metal Artifacts. Presented
at: Radiological Society of North America 2011 Scientific Assembly and Annual Meeting; November 27- December 2,
2011 Chicago IL.</i>).
The acquired planes of such CT series do not match the expectations of a orthogonal geometry in mitk::Image: if you
stack the slices, they show a small shift along the Y axis:
\verbatim
without tilt with tilt
|||||| //////
|||||| //////
-- |||||| --------- ////// -------- table orientation
|||||| //////
|||||| //////
Stacked slices:
without tilt with tilt
-------------- --------------
-------------- --------------
-------------- --------------
-------------- --------------
-------------- --------------
\endverbatim
As such gemetries do not in conjunction with mitk::Image, DicomSeriesReader performs a correction for such series
if the groupImagesWithGantryTilt or correctGantryTilt flag in GetSeries and LoadDicomSeries is set (default = on).
The correction algorithms undoes two errors introduced by ITK's ImageSeriesReader:
- the plane shift that is ignored by ITK's reader is recreated by applying a shearing transformation using
itk::ResampleFilter.
- the spacing is corrected (it is calculated by ITK's reader from the distance between two origins, which is NOT the
slice distance in this special case)
Both errors are introduced in
itkImageSeriesReader.txx (ImageSeriesReader<TOutputImage>::GenerateOutputInformation(void)), lines 176 to 245 (as of
ITK 3.20)
For the correction, we examine two consecutive slices of a series, both described as a pair (origin/orientation):
- we calculate if the first origin is on a line along the normal of the second slice
- if this is not the case, the geometry will not fit a normal mitk::Image/mitk::Geometry3D
- we then project the second origin into the first slice's coordinate system to quantify the shift
- both is done in class GantryTiltInformation with quite some comments.
The geometry of image stacks with tilted geometries is illustrated below:
- green: the DICOM images as described by their tags: origin as a point with the line indicating the orientation
- red: the output of ITK ImageSeriesReader: wrong, larger spacing, no tilt
- blue: how much a shear must correct
\image html Modules/DICOM/doc/Doxygen/tilt-correction.jpg
\section DicomSeriesReader_whatweknowaboutitk The actual image loading process
When calling LoadDicomSeries(), this method "mainly" uses an instance of itk::ImageSeriesReader,
configured with an itk::GDCMImageIO object. Because DicomSeriesReader works around some of the
behaviors of these classes, the following is a list of features that we find in the code and need to work with:
- itk::ImageSeriesReader::GenerateOutputInformation() does the z-spacing handling
+ spacing is directly determined by comparing (euclidean distance) the origins of the first two slices of a series
* this is GOOD because there is no reliable z-spacing information in DICOM images
* this is bad because it does not work with gantry tilt, in which case the slice distance is SMALLER than the
distance between two origins (see section on tilt)
- origin and spacing are calculated by GDCMImageIO and re-used in itk::ImageSeriesReader
+ the origins are read from appropriate tags, nothing special about that
+ the spacing is read by gdcm::ImageReader, gdcm::ImageHelper::GetSpacingValue() from a tag determined by
gdcm::ImageHelper::GetSpacingTagFromMediaStorage(), which basically determines ONE appropriate pixel spacing tag for
each media storage type (ct image, mr image, secondary capture image, etc.)
* this is fine for modalities such as CT/MR where the "Pixel Spacing" tag is mandatory, but for other modalities
such as CR or Secondary Capture, the tag "Imager Pixel Spacing" is taken, which is no only optional but also has a
more
complicated relation with the "Pixel Spacing" tag. For this reason we check/modify the pixel spacing reported by
itk::ImageSeriesReader after loading the image (see \ref DicomSeriesReader_pixelspacing)
AFTER loading, DicomSeriesReader marks some of its findings as mitk::Properties to the loaded Image and DataNode:
- <b>dicomseriesreader.SOPClass</b> : DICOM SOP Class as readable string (instead of a UID)
- <b>dicomseriesreader.ReaderImplementationLevelString</b> : Confidence /Support level of the reader for this image
as
readable string
- <b>dicomseriesreader.ReaderImplementationLevel</b> : Confidence /Support level of the reader for this image as
enum
value of type ReaderImplementationLevel
- <b>dicomseriesreader.PixelSpacingInterpretationString</b> : Appropriate interpreteation of pixel spacing for this
Image as readable string
- <b>dicomseriesreader.PixelSpacingInterpretation</b> : Appropriate interpreteation of pixel spacing for this Image
as
enum value of type PixelSpacingInterpretation
- <b>dicomseriesreader.MultiFrameImage</b> : bool flag to mark multi-frame images
- <b>dicomseriesreader.GantyTiltCorrected</b> : bool flag to mark images where a gantry tilt was corrected to fit
slices into an mitk::Image
- <b>dicomseriesreader.3D+t</b> : bool flag to mark images with a time dimension (multiple 3D blocks of the same
size
at the same position in space)
\section DicomSeriesReader_pixelspacing Handling of pixel spacing
- The reader implementes what is described in DICOM Part 3, chapter 10.7 (Basic Pixel Spacing Calibration Macro): Both
+ The reader implements what is described in DICOM Part 3, chapter 10.7 (Basic Pixel Spacing Calibration Macro): Both
tags
- (0028,0030) Pixel Spacing and
- (0018,1164) Imager Pixel Spacing
are evaluated and the pixel spacing is set to the spacing within the patient when tags allow that.
The result of pixel spacing interpretation can be read from a property
"dicomseriesreader.PixelSpacingInterpretation",
which refers to one of the enumerated values of type PixelSpacingInterpretation;
\section DicomSeriesReader_supportedmodalities Limitations for specific modalities
- <b>Enhanced Computed Tomography / Magnetic Resonance Images</b> are currently NOT supported at all, because we
lack
general support for multi-frame images.
- <b>Nuclear Medicine Images</b> are not supported fully supported, only the single-frame variants are loaded
properly.
\section DicomSeriesReader_nextworkitems Possible enhancements
This is a short list of ideas for enhancement:
- Class has historically grown and should be reviewed again. There is probably too many duplicated scanning code
- - Multi-frame images don't mix well with the curent assumption of "one file - one slice", which is assumed by our
+ - Multi-frame images don't mix well with the current assumption of "one file - one slice", which is assumed by our
code
- It should be checked how well GDCM and ITK support these files (some load, some don't)
- Specializations such as the Philips 3D code should be handled in a more generic way. The current handling of
Philips 3D images is not nice at all
\section DicomSeriesReader_whynotinitk Why is this not in ITK?
Some of this code would probably be better located in ITK. It is just a matter of resources that this is not the
case yet. Any attempts into this direction are welcome and can be supported. At least the gantry tilt correction
should be a simple addition to itk::ImageSeriesReader.
\section DicomSeriesReader_tests Tests regarding DICOM loading
A number of tests have been implemented to check our assumptions regarding DICOM loading. Please see \ref
DICOMTesting
\todo refactor all the protected helper objects/methods into a separate header so we compile faster
*/
class Image;
class DicomSeriesReader
{
public:
/**
\brief Lists of filenames.
*/
typedef std::vector<std::string> StringContainer;
/**
\brief Interface for the progress callback.
*/
typedef void (*UpdateCallBackMethod)(float);
/**
\brief Describes how well the reader is tested for a certain file type.
Applications should not rely on the outcome for images which are reported
ReaderImplementationLevel_Implemented or ReaderImplementationLevel_Unsupported.
Errors to load images which are reported as ReaderImplementationLevel_Supported
are considered bugs. For ReaderImplementationLevel_PartlySupported please check the appropriate paragraph in \ref
DicomSeriesReader_supportedmodalities
*/
typedef enum {
ReaderImplementationLevel_Supported, /// loader code and tests are established
- ReaderImplementationLevel_PartlySupported, /// loader code and tests are establised for specific parts of a SOP
+ ReaderImplementationLevel_PartlySupported, /// loader code and tests are established for specific parts of a SOP
/// Class
ReaderImplementationLevel_Implemented, /// loader code is implemented but not accompanied by tests
ReaderImplementationLevel_Unsupported, /// loader code is not working with this SOP Class
} ReaderImplementationLevel;
/**
\brief How the mitk::Image spacing should be interpreted.
Compare DICOM PS 3.3 10.7 (Basic Pixel Spacing Calibration Macro).
*/
typedef enum {
PixelSpacingInterpretation_SpacingInPatient, /// distances are mm within a patient
PixelSpacingInterpretation_SpacingAtDetector, /// distances are mm at detector surface
PixelSpacingInterpretation_SpacingUnknown /// NO spacing information is present, we use (1,1) as default
} PixelSpacingInterpretation;
/**
\brief Return type of GetSeries, describes a logical group of files.
Files grouped into a single 3D or 3D+t block are described by an instance
of this class. Relevant descriptive properties can be used to provide
the application user with meaningful choices.
*/
class ImageBlockDescriptor
{
public:
/// List of files in this group
StringContainer GetFilenames() const;
/// A unique ID describing this bloc (enhanced Series Instance UID).
std::string GetImageBlockUID() const;
/// The Series Instance UID.
std::string GetSeriesInstanceUID() const;
/// Series Modality (CT, MR, etc.)
std::string GetModality() const;
/// SOP Class UID as readable string (Computed Tomography Image Storage, Secondary Capture Image Storage, etc.)
std::string GetSOPClassUIDAsString() const;
/// SOP Class UID as DICOM UID
std::string GetSOPClassUID() const;
/// Confidence of the reader that this block can be read successfully.
ReaderImplementationLevel GetReaderImplementationLevel() const;
/// Whether or not the block contains a gantry tilt which will be "corrected" during loading
bool HasGantryTiltCorrected() const;
/// Whether or not mitk::Image spacing relates to the patient
bool PixelSpacingRelatesToPatient() const;
/// Whether or not mitk::Image spacing relates to the detector surface
bool PixelSpacingRelatesToDetector() const;
/// Whether or not mitk::Image spacing is of unknown origin
bool PixelSpacingIsUnknown() const;
/// How the mitk::Image spacing can meaningfully be interpreted.
PixelSpacingInterpretation GetPixelSpacingType() const;
/// 3D+t or not
bool HasMultipleTimePoints() const;
/// Multi-frame image(s) or not
bool IsMultiFrameImage() const;
ImageBlockDescriptor();
~ImageBlockDescriptor();
private:
friend class DicomSeriesReader;
ImageBlockDescriptor(const StringContainer &files);
void AddFile(const std::string &file);
void AddFiles(const StringContainer &files);
void SetImageBlockUID(const std::string &uid);
void SetSeriesInstanceUID(const std::string &uid);
void SetModality(const std::string &modality);
void SetNumberOfFrames(const std::string &);
void SetSOPClassUID(const std::string &mediaStorageSOPClassUID);
void SetHasGantryTiltCorrected(bool);
void SetPixelSpacingInformation(const std::string &pixelSpacing, const std::string &imagerPixelSpacing);
void SetHasMultipleTimePoints(bool);
void GetDesiredMITKImagePixelSpacing(ScalarType &spacingX, ScalarType &spacingY) const;
StringContainer m_Filenames;
std::string m_ImageBlockUID;
std::string m_SeriesInstanceUID;
std::string m_Modality;
std::string m_SOPClassUID;
bool m_HasGantryTiltCorrected;
std::string m_PixelSpacing;
std::string m_ImagerPixelSpacing;
bool m_HasMultipleTimePoints;
bool m_IsMultiFrameImage;
};
typedef std::map<std::string, ImageBlockDescriptor> FileNamesGrouping;
/**
\brief Provide combination of preprocessor defines that was active during compilation.
Since this class is a combination of several possible implementations, separated only
by ifdef's, calling instances might want to know which flags were active at compile time.
*/
static std::string GetConfigurationString();
/**
\brief Checks if a specific file contains DICOM data.
*/
static bool IsDicom(const std::string &filename);
/**
\brief see other GetSeries().
Find all series (and sub-series -- see details) in a particular directory.
*/
static FileNamesGrouping GetSeries(const std::string &dir,
bool groupImagesWithGantryTilt,
const StringContainer &restrictions = StringContainer());
/**
\brief see other GetSeries().
\warning Untested, could or could not work.
This differs only by having an additional restriction to a single known DICOM series.
Internally, it uses the other GetSeries() method.
*/
static StringContainer GetSeries(const std::string &dir,
const std::string &series_uid,
bool groupImagesWithGantryTilt,
const StringContainer &restrictions = StringContainer());
/**
\brief PREFERRED version of this method - scan and sort DICOM files.
Parse a list of files for images of DICOM series.
For each series, an enumeration of the files contained in it is created.
\return The resulting maps UID-like keys (based on Series Instance UID and slice properties) to sorted lists of
file
names.
SeriesInstanceUID will be enhanced to be unique for each set of file names
that is later loadable as a single mitk::Image. This implies that
Image orientation, slice thickness, pixel spacing, rows, and columns
must be the same for each file (i.e. the image slice contained in the file).
If this separation logic requires that a SeriesInstanceUID must be made more specialized,
it will follow the same logic as itk::GDCMSeriesFileNames to enhance the UID with
more digits and dots.
Optionally, more tags can be used to separate files into different logical series by setting
the restrictions parameter.
\warning Adding restrictions is not yet implemented!
*/
static FileNamesGrouping GetSeries(const StringContainer &files,
bool sortTo3DPlust,
bool groupImagesWithGantryTilt,
const StringContainer &restrictions = StringContainer());
/**
\brief See other GetSeries().
Use GetSeries(const StringContainer& files, bool sortTo3DPlust, const StringContainer &restrictions) instead.
*/
static FileNamesGrouping GetSeries(const StringContainer &files,
bool groupImagesWithGantryTilt,
const StringContainer &restrictions = StringContainer());
/**
Loads a DICOM series composed by the file names enumerated in the file names container.
If a callback method is supplied, it will be called after every progress update with a progress value in [0,1].
\param filenames The filenames to load.
\param sort Whether files should be sorted spatially (true) or not (false - maybe useful if presorted)
\param load4D Whether to load the files as 3D+t (if possible)
\param correctGantryTilt
\param callback
\param preLoadedImageBlock
*/
static DataNode::Pointer LoadDicomSeries(const StringContainer &filenames,
bool sort = true,
bool load4D = true,
bool correctGantryTilt = true,
UpdateCallBackMethod callback = nullptr,
itk::SmartPointer<Image> preLoadedImageBlock = nullptr);
/**
\brief See LoadDicomSeries! Just a slightly different interface.
If \p preLoadedImageBlock is provided, the reader will only "fake" loading and create appropriate mitk::Properties.
\param filenames
\param node
\param sort
\param load4D
\param correctGantryTilt
\param callback
\param preLoadedImageBlock
*/
static bool LoadDicomSeries(const StringContainer &filenames,
DataNode &node,
bool sort = true,
bool load4D = true,
bool correctGantryTilt = true,
UpdateCallBackMethod callback = nullptr,
itk::SmartPointer<Image> preLoadedImageBlock = nullptr);
protected:
/**
\brief Return type of DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption.
Class contains the grouping result of method
DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption,
which takes as input a number of images, which are all equally oriented and spatially sorted along their normal
direction.
The result contains of two blocks: a first one is the grouping result, all of those images can be loaded
into one image block because they have an equal origin-to-origin distance without any gaps in-between.
*/
class SliceGroupingAnalysisResult
{
public:
SliceGroupingAnalysisResult();
/**
\brief Grouping result, all same origin-to-origin distance w/o gaps.
*/
StringContainer GetBlockFilenames();
/**
\brief Remaining files, which could not be grouped.
*/
StringContainer GetUnsortedFilenames();
/**
- \brief Wheter or not the grouped result contain a gantry tilt.
+ \brief Whether or not the grouped result contain a gantry tilt.
*/
bool ContainsGantryTilt();
/**
\brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
*/
void AddFileToSortedBlock(const std::string &filename);
/**
\brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
*/
void AddFileToUnsortedBlock(const std::string &filename);
void AddFilesToUnsortedBlock(const StringContainer &filenames);
/**
\brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
\todo Could make sense to enhance this with an instance of GantryTiltInformation to store the whole result!
*/
void FlagGantryTilt();
/**
\brief Only meaningful for use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption.
*/
void UndoPrematureGrouping();
protected:
StringContainer m_GroupedFiles;
StringContainer m_UnsortedFiles;
bool m_GantryTilt;
};
/**
\brief Gantry tilt analysis result.
Takes geometry information for two slices of a DICOM series and
calculates whether these fit into an orthogonal block or not.
If NOT, they can either be the result of an acquisition with
- gantry tilt OR completly broken by some shearing transformation.
+ gantry tilt OR completely broken by some shearing transformation.
Most calculations are done in the constructor, results can then
be read via the remaining methods.
*/
class GantryTiltInformation
{
public:
// two types to avoid any rounding errors
typedef itk::Point<double, 3> Point3Dd;
typedef itk::Vector<double, 3> Vector3Dd;
/**
\brief Just so we can create empty instances for assigning results later.
*/
GantryTiltInformation();
/**
\brief THE constructor, which does all the calculations.
Determining the amount of tilt is done by checking the distances
of origin1 from planes through origin2. Two planes are considered:
- normal vector along normal of slices (right x up): gives the slice distance
- normal vector along orientation vector "up": gives the shift parallel to the plane orientation
The tilt angle can then be calculated from these distances
\param origin1 origin of the first slice
\param origin2 origin of the second slice
\param right right/up describe the orientatation of borth slices
\param up right/up describe the orientatation of borth slices
\param numberOfSlicesApart how many slices are the given origins apart (1 for neighboring slices)
*/
GantryTiltInformation(const Point3D &origin1,
const Point3D &origin2,
const Vector3D &right,
const Vector3D &up,
unsigned int numberOfSlicesApart);
/**
\brief Whether the slices were sheared.
True if any of the shifts along right or up vector are non-zero.
*/
bool IsSheared() const;
/**
\brief Whether the shearing is a gantry tilt or more complicated.
Gantry tilt will only produce shifts in ONE orientation, not in both.
- Since the correction code currently only coveres one tilt direction
+ Since the correction code currently only covers one tilt direction
AND we don't know of medical images with two tilt directions, the
loading code wants to check if our assumptions are true.
*/
bool IsRegularGantryTilt() const;
/**
\brief The offset distance in Y direction for each slice in mm (describes the tilt result).
*/
double GetMatrixCoefficientForCorrectionInWorldCoordinates() const;
/**
\brief The z / inter-slice spacing. Needed to correct ImageSeriesReader's result.
*/
double GetRealZSpacing() const;
/**
\brief The shift between first and last slice in mm.
Needed to resize an orthogonal image volume.
*/
double GetTiltCorrectedAdditionalSize() const;
/**
\brief Calculated tilt angle in degrees.
*/
double GetTiltAngleInDegrees() const;
protected:
/**
\brief Projection of point p onto line through lineOrigin in direction of lineDirection.
*/
Point3D projectPointOnLine(Point3Dd p, Point3Dd lineOrigin, Vector3Dd lineDirection);
double m_ShiftUp;
double m_ShiftRight;
double m_ShiftNormal;
double m_ITKAssumedSliceSpacing;
unsigned int m_NumberOfSlicesApart;
};
/**
\brief for internal sorting.
*/
typedef std::pair<StringContainer, StringContainer> TwoStringContainers;
/**
\brief Maps DICOM tags to MITK properties.
*/
typedef std::map<std::string, std::string> TagToPropertyMapType;
/**
\brief Ensure an equal z-spacing for a group of files.
Takes as input a number of images, which are all equally oriented and spatially sorted along their normal
direction.
Internally used by GetSeries. Returns two lists: the first one contins slices of equal inter-slice spacing.
The second list contains remaining files, which need to be run through
AnalyzeFileForITKImageSeriesReaderSpacingAssumption again.
Relevant code that is matched here is in
itkImageSeriesReader.txx (ImageSeriesReader<TOutputImage>::GenerateOutputInformation(void)), lines 176 to 245 (as
of
ITK 3.20)
*/
static SliceGroupingAnalysisResult AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
const StringContainer &files, bool groupsOfSimilarImages, const gdcm::Scanner::MappingType &tagValueMappings_);
/**
\brief Safely convert const char* to std::string.
*/
static std::string ConstCharStarToString(const char *s);
/**
\brief Safely convert a string into pixel spacing x and y.
*/
static bool DICOMStringToSpacing(const std::string &s, ScalarType &spacingX, ScalarType &spacingY);
/**
\brief Convert DICOM string describing a point to Point3D.
DICOM tags like ImagePositionPatient contain a position as float numbers separated by backslashes:
\verbatim
42.7131\13.77\0.7
\endverbatim
*/
static Point3D DICOMStringToPoint3D(const std::string &s, bool &successful);
/**
\brief Convert DICOM string describing a point two Vector3D.
DICOM tags like ImageOrientationPatient contain two vectors as float numbers separated by backslashes:
\verbatim
42.7131\13.77\0.7\137.76\0.3
\endverbatim
*/
static void DICOMStringToOrientationVectors(const std::string &s, Vector3D &right, Vector3D &up, bool &successful);
template <typename ImageType>
static typename ImageType::Pointer
// TODO this is NOT inplace!
InPlaceFixUpTiltedGeometry(ImageType *input, const GantryTiltInformation &tiltInfo);
/**
\brief Sort a set of file names in an order that is meaningful for loading them into an mitk::Image.
\warning This method assumes that input files are similar in basic properties such as
- slice thicknes, image orientation, pixel spacing, rows, columns.
+ slice thickness, image orientation, pixel spacing, rows, columns.
It should always be ok to put the result of a call to GetSeries(..) into this method.
Sorting order is determined by
1. image position along its normal (distance from world origin)
2. acquisition time
If P<n> denotes a position and T<n> denotes a time step, this method will order slices from three timesteps like
this:
\verbatim
P1T1 P1T2 P1T3 P2T1 P2T2 P2T3 P3T1 P3T2 P3T3
\endverbatim
*/
static StringContainer SortSeriesSlices(const StringContainer &unsortedFilenames);
public:
/**
\brief Checks if a specific file is a Philips3D ultrasound DICOM file.
*/
static bool IsPhilips3DDicom(const std::string &filename);
static std::string ReaderImplementationLevelToString(const ReaderImplementationLevel &enumValue);
static std::string PixelSpacingInterpretationToString(const PixelSpacingInterpretation &enumValue);
protected:
/**
\brief Read a Philips3D ultrasound DICOM file and put into an mitk::Image.
*/
static bool ReadPhilips3DDicom(const std::string &filename, itk::SmartPointer<Image> output_image);
/**
\brief Construct a UID that takes into account sorting criteria from GetSeries().
*/
static std::string CreateMoreUniqueSeriesIdentifier(gdcm::Scanner::TagToValue &tagValueMap);
/**
\brief Helper for CreateMoreUniqueSeriesIdentifier
*/
static std::string CreateSeriesIdentifierPart(gdcm::Scanner::TagToValue &tagValueMap, const gdcm::Tag &tag);
/**
\brief Helper for CreateMoreUniqueSeriesIdentifier
*/
static std::string IDifyTagValue(const std::string &value);
typedef itk::GDCMImageIO DcmIoType;
/**
\brief Progress callback for DicomSeriesReader.
*/
class CallbackCommand : public itk::Command
{
public:
CallbackCommand(UpdateCallBackMethod callback) : m_Callback(callback) {}
void Execute(const itk::Object *caller, const itk::EventObject &) override
{
(*this->m_Callback)(static_cast<const itk::ProcessObject *>(caller)->GetProgress());
}
void Execute(itk::Object *caller, const itk::EventObject &) override
{
(*this->m_Callback)(static_cast<itk::ProcessObject *>(caller)->GetProgress());
}
protected:
UpdateCallBackMethod m_Callback;
};
static void FixSpacingInformation(Image *image, const ImageBlockDescriptor &imageBlockDescriptor);
/**
\brief Scan for slice image information
*/
static void ScanForSliceInformation(const StringContainer &filenames, gdcm::Scanner &scanner);
/**
\brief Performs actual loading of a series and creates an image having the specified pixel type.
*/
static void LoadDicom(const StringContainer &filenames,
DataNode &node,
bool sort,
bool check_4d,
bool correctTilt,
UpdateCallBackMethod callback,
itk::SmartPointer<Image> preLoadedImageBlock);
/**
\brief Feed files into itk::ImageSeriesReader and retrieve a 3D MITK image.
\param correctTilt
\param tiltInfo
\param io
\param command can be used for progress reporting
\param preLoadedImageBlock
*/
template <typename PixelType>
static itk::SmartPointer<Image> LoadDICOMByITK(const StringContainer &,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
static itk::SmartPointer<Image> MultiplexLoadDICOMByITK(const StringContainer &,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
static itk::SmartPointer<Image> MultiplexLoadDICOMByITKScalar(const StringContainer &,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
static itk::SmartPointer<Image> MultiplexLoadDICOMByITKRGBPixel(const StringContainer &,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
template <typename PixelType>
static itk::SmartPointer<Image> LoadDICOMByITK4D(std::list<StringContainer> &imageBlocks,
ImageBlockDescriptor imageBlockDescriptor,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
static itk::SmartPointer<Image> MultiplexLoadDICOMByITK4D(std::list<StringContainer> &imageBlocks,
ImageBlockDescriptor imageBlockDescriptor,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
static itk::SmartPointer<Image> MultiplexLoadDICOMByITK4DScalar(std::list<StringContainer> &imageBlocks,
ImageBlockDescriptor imageBlockDescriptor,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
static itk::SmartPointer<Image> MultiplexLoadDICOMByITK4DRGBPixel(std::list<StringContainer> &imageBlocks,
ImageBlockDescriptor imageBlockDescriptor,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
itk::SmartPointer<Image> preLoadedImageBlock);
/**
\brief Sort files into time step blocks of a 3D+t image.
Called by LoadDicom. Expects to be fed a single list of filenames that have been sorted by
GetSeries previously (one map entry). This method will check how many timestep can be filled
with given files.
Assumption is that the number of time steps is determined by how often the first position in
space repeats. I.e. if the first three files in the input parameter all describe the same
location in space, we'll construct three lists of files. and sort the remaining files into them.
\todo We can probably remove this method if we somehow transfer 3D+t information from GetSeries to
LoadDicomSeries.
*/
static std::list<StringContainer> SortIntoBlocksFor3DplusT(const StringContainer &presortedFilenames,
const gdcm::Scanner::MappingType &tagValueMappings_,
bool sort,
bool &canLoadAs4D);
/**
\brief Defines spatial sorting for sorting by GDCM 2.
Sorts by image position along image normal (distance from world origin).
In cases of conflict, acquisition time is used as a secondary sort criterium.
*/
static bool GdcmSortFunction(const gdcm::DataSet &ds1, const gdcm::DataSet &ds2);
/**
\brief Copy information about files and DICOM tags from ITK's MetaDataDictionary
and from the list of input files to the PropertyList of mitk::Image.
\todo Tag copy must follow; image level will cause some additional files parsing, probably.
*/
static void CopyMetaDataToImageProperties(StringContainer filenames,
const gdcm::Scanner::MappingType &tagValueMappings_,
DcmIoType *io,
const ImageBlockDescriptor &blockInfo,
Image *image);
static void CopyMetaDataToImageProperties(std::list<StringContainer> imageBlock,
const gdcm::Scanner::MappingType &tagValueMappings_,
DcmIoType *io,
const ImageBlockDescriptor &blockInfo,
Image *image);
/**
\brief Map between DICOM tags and MITK properties.
Uses as a positive list for copying specified DICOM tags (from ITK's ImageIO)
to MITK properties. ITK provides MetaDataDictionary entries of form
"gggg|eeee" (g = group, e = element), e.g. "0028,0109" (Largest Pixel in Series),
which we want to sort as dicom.series.largest_pixel_in_series".
*/
static const TagToPropertyMapType &GetDICOMTagsToMITKPropertyMap();
};
}
#endif /* mitkDicomSeriesReader_h */
diff --git a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.txx b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.txx
index 0056269ecc..6708976ff7 100644
--- a/Modules/DICOM/src/legacy/mitkDicomSeriesReader.txx
+++ b/Modules/DICOM/src/legacy/mitkDicomSeriesReader.txx
@@ -1,304 +1,304 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKDICOMSERIESREADER_TXX_
#define MITKDICOMSERIESREADER_TXX_
#include <legacy/mitkDicomSeriesReader.h>
#include <itkImageSeriesReader.h>
#include <mitkProperties.h>
#include <itkAffineTransform.h>
#include <itkLinearInterpolateImageFunction.h>
#include <itkResampleImageFilter.h>
#include <itkTimeProbesCollectorBase.h>
#include <limits>
#include <mitkImage.h>
namespace mitk
{
template <typename PixelType>
Image::Pointer DicomSeriesReader::LoadDICOMByITK4D(std::list<StringContainer> &imageBlocks,
ImageBlockDescriptor imageBlockDescriptor,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
Image::Pointer preLoadedImageBlock)
{
mitk::Image::Pointer image = mitk::Image::New();
// It is 3D+t! Read it and store into mitk image
typedef itk::Image<PixelType, 4> ImageType;
typedef itk::ImageSeriesReader<ImageType> ReaderType;
typename ReaderType::Pointer reader = ReaderType::New();
reader->SetImageIO(io);
reader->ReverseOrderOff();
if (command)
{
reader->AddObserver(itk::ProgressEvent(), command);
}
if (preLoadedImageBlock.IsNull())
{
reader->SetFileNames(imageBlocks.front());
reader->Update();
typename ImageType::Pointer readVolume = reader->GetOutput();
// if we detected that the images are from a tilted gantry acquisition, we need to push some pixels into the right
// position
if (correctTilt)
{
readVolume = InPlaceFixUpTiltedGeometry(reader->GetOutput(), tiltInfo);
}
unsigned int volume_count = imageBlocks.size();
image->InitializeByItk(readVolume.GetPointer(), 1, volume_count);
image->SetImportVolume(readVolume->GetBufferPointer(), 0u);
FixSpacingInformation(image, imageBlockDescriptor);
}
else
{
StringContainer fakeList;
fakeList.push_back(imageBlocks.front().front());
reader->SetFileNames(fakeList); // only ONE first filename to get MetaDataDictionary
image = preLoadedImageBlock;
}
gdcm::Scanner scanner;
ScanForSliceInformation(imageBlockDescriptor.GetFilenames(), scanner);
CopyMetaDataToImageProperties(imageBlocks, scanner.GetMappings(), io, imageBlockDescriptor, image);
MITK_DEBUG << "Volume dimension: [" << image->GetDimension(0) << ", " << image->GetDimension(1) << ", "
<< image->GetDimension(2) << ", " << image->GetDimension(3) << "]";
MITK_DEBUG << "Volume spacing: [" << image->GetGeometry()->GetSpacing()[0] << ", "
<< image->GetGeometry()->GetSpacing()[1] << ", " << image->GetGeometry()->GetSpacing()[2] << "]";
if (preLoadedImageBlock.IsNull())
{
unsigned int act_volume = 1u;
for (auto df_it = ++imageBlocks.begin(); df_it != imageBlocks.end(); ++df_it)
{
reader->SetFileNames(*df_it);
reader->Update();
typename ImageType::Pointer readVolume = reader->GetOutput();
if (correctTilt)
{
readVolume = InPlaceFixUpTiltedGeometry(reader->GetOutput(), tiltInfo);
}
image->SetImportVolume(readVolume->GetBufferPointer(), act_volume++);
}
}
return image;
}
template <typename PixelType>
Image::Pointer DicomSeriesReader::LoadDICOMByITK(const StringContainer &filenames,
bool correctTilt,
const GantryTiltInformation &tiltInfo,
DcmIoType::Pointer &io,
CallbackCommand *command,
Image::Pointer preLoadedImageBlock)
{
/******** Normal Case, 3D (also for GDCM < 2 usable) ***************/
mitk::Image::Pointer image = mitk::Image::New();
typedef itk::Image<PixelType, 3> ImageType;
typedef itk::ImageSeriesReader<ImageType> ReaderType;
io = DcmIoType::New();
typename ReaderType::Pointer reader = ReaderType::New();
reader->SetImageIO(io);
reader->ReverseOrderOff();
if (command)
{
reader->AddObserver(itk::ProgressEvent(), command);
}
if (preLoadedImageBlock.IsNull())
{
reader->SetFileNames(filenames);
reader->Update();
typename ImageType::Pointer readVolume = reader->GetOutput();
// if we detected that the images are from a tilted gantry acquisition, we need to push some pixels into the right
// position
if (correctTilt)
{
readVolume = InPlaceFixUpTiltedGeometry(reader->GetOutput(), tiltInfo);
}
image->InitializeByItk(readVolume.GetPointer());
image->SetImportVolume(readVolume->GetBufferPointer());
}
else
{
image = preLoadedImageBlock;
StringContainer fakeList;
fakeList.push_back(filenames.front());
reader->SetFileNames(fakeList); // we always need to load at least one file to get the MetaDataDictionary
reader->Update();
}
MITK_DEBUG << "Volume dimension: [" << image->GetDimension(0) << ", " << image->GetDimension(1) << ", "
<< image->GetDimension(2) << "]";
MITK_DEBUG << "Volume spacing: [" << image->GetGeometry()->GetSpacing()[0] << ", "
<< image->GetGeometry()->GetSpacing()[1] << ", " << image->GetGeometry()->GetSpacing()[2] << "]";
return image;
}
template <typename ImageType>
typename ImageType::Pointer DicomSeriesReader::InPlaceFixUpTiltedGeometry(ImageType *input,
const GantryTiltInformation &tiltInfo)
{
typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilterType;
typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetInput(input);
/*
Transform for a point is
- transform from actual position to index coordinates
- apply a shear that undoes the gantry tilt
- transform back into world coordinates
Anybody who does this in a simpler way: don't forget to write up how and why your solution works
*/
typedef itk::ScalableAffineTransform<double, ImageType::ImageDimension> TransformType;
typename TransformType::Pointer transformShear = TransformType::New();
/**
- apply a shear and spacing correction to the image block that corrects the ITK reader's error
- ITK ignores the shear and loads slices into an orthogonal volume
- ITK calculates the spacing from the origin distance, which is more than the actual spacing with gantry tilt
images
- to undo the effect
- we have calculated some information in tiltInfo:
- the shift in Y direction that is added with each additional slice is the most important information
- the Y-shift is calculated in mm world coordinates
- we apply a shearing transformation to the ITK-read image volume
- to do this locally,
- we transform the image volume back to origin and "normal" orientation by applying the inverse of its
transform
(this brings us into the image's "index coordinate" system)
- we apply a shear with the Y-shift factor put into a unit transform at row 1, col 2
- we transform the image volume back to its actual position (from index to world coordinates)
- we lastly apply modify the image spacing in z direction by replacing this number with the correctly calulcated
inter-slice distance
*/
ScalarType factor = tiltInfo.GetMatrixCoefficientForCorrectionInWorldCoordinates() / input->GetSpacing()[1];
// row 1, column 2 corrects shear in parallel to Y axis, proportional to distance in Z direction
transformShear->Shear(1, 2, factor);
typename TransformType::Pointer imageIndexToWorld = TransformType::New();
imageIndexToWorld->SetOffset(input->GetOrigin().GetVectorFromOrigin());
typename TransformType::MatrixType indexToWorldMatrix;
indexToWorldMatrix = input->GetDirection();
typename ImageType::DirectionType scale;
for (unsigned int i = 0; i < ImageType::ImageDimension; i++)
{
scale[i][i] = input->GetSpacing()[i];
}
indexToWorldMatrix *= scale;
imageIndexToWorld->SetMatrix(indexToWorldMatrix);
typename TransformType::Pointer imageWorldToIndex = TransformType::New();
imageIndexToWorld->GetInverse(imageWorldToIndex);
typename TransformType::Pointer gantryTiltCorrection = TransformType::New();
gantryTiltCorrection->Compose(imageWorldToIndex);
gantryTiltCorrection->Compose(transformShear);
gantryTiltCorrection->Compose(imageIndexToWorld);
resampler->SetTransform(gantryTiltCorrection);
typedef itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
resampler->SetInterpolator(interpolator);
/*
This would be the right place to invent a meaningful value for positions outside of the image.
For CT, HU -1000 might be meaningful, but a general solution seems not possible. Even for CT,
-1000 would only look natural for many not all images.
*/
// TODO use (0028,0120) Pixel Padding Value if present
resampler->SetDefaultPixelValue(itk::NumericTraits<typename ImageType::PixelType>::min());
// adjust size in Y direction! (maybe just transform the outer last pixel to see how much space we would need
resampler->SetOutputParametersFromImage(input); // we basically need the same image again, just sheared
// if tilt positive, then we need additional pixels BELOW origin, otherwise we need pixels behind the end of the
// block
- // in any case we need more size to accomodate shifted slices
+ // in any case we need more size to accommodate shifted slices
typename ImageType::SizeType largerSize =
resampler->GetSize(); // now the resampler already holds the input image's size.
largerSize[1] += static_cast<typename ImageType::SizeType::SizeValueType>(
tiltInfo.GetTiltCorrectedAdditionalSize() / input->GetSpacing()[1] + 2.0);
resampler->SetSize(largerSize);
// in SOME cases this additional size is below/behind origin
if (tiltInfo.GetMatrixCoefficientForCorrectionInWorldCoordinates() > 0.0)
{
typename ImageType::DirectionType imageDirection = input->GetDirection();
Vector3D yDirection;
yDirection[0] = imageDirection[0][1];
yDirection[1] = imageDirection[1][1];
yDirection[2] = imageDirection[2][1];
yDirection.Normalize();
typename ImageType::PointType shiftedOrigin;
shiftedOrigin = input->GetOrigin();
// add some pixels to make everything fit
shiftedOrigin[0] -= yDirection[0] * (tiltInfo.GetTiltCorrectedAdditionalSize() + 1.0 * input->GetSpacing()[1]);
shiftedOrigin[1] -= yDirection[1] * (tiltInfo.GetTiltCorrectedAdditionalSize() + 1.0 * input->GetSpacing()[1]);
shiftedOrigin[2] -= yDirection[2] * (tiltInfo.GetTiltCorrectedAdditionalSize() + 1.0 * input->GetSpacing()[1]);
resampler->SetOutputOrigin(shiftedOrigin);
}
resampler->Update();
typename ImageType::Pointer result = resampler->GetOutput();
// ImageSeriesReader calculates z spacing as the distance between the first two origins.
// This is not correct in case of gantry tilt, so we set our calculated spacing.
typename ImageType::SpacingType correctedSpacing = result->GetSpacing();
correctedSpacing[2] = tiltInfo.GetRealZSpacing();
result->SetSpacing(correctedSpacing);
return result;
}
}
#endif
diff --git a/Modules/DICOM/src/mitkBaseDICOMReaderService.cpp b/Modules/DICOM/src/mitkBaseDICOMReaderService.cpp
index 2163a64b75..2f32e13c27 100644
--- a/Modules/DICOM/src/mitkBaseDICOMReaderService.cpp
+++ b/Modules/DICOM/src/mitkBaseDICOMReaderService.cpp
@@ -1,225 +1,225 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkBaseDICOMReaderService.h"
#include <mitkCustomMimeType.h>
#include <mitkIOMimeTypes.h>
#include <mitkDICOMFileReaderSelector.h>
#include <mitkImage.h>
#include <mitkDICOMFilesHelper.h>
#include <mitkDICOMTagsOfInterestHelper.h>
#include <mitkDICOMProperty.h>
#include "legacy/mitkDicomSeriesReader.h"
#include <mitkDICOMDCMTKTagScanner.h>
#include <mitkLocaleSwitch.h>
#include "mitkIPropertyProvider.h"
#include "mitkPropertyNameHelper.h"
#include "mitkPropertyKeyPath.h"
#include "mitkDICOMIOMetaInformationPropertyConstants.h"
#include <iostream>
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
namespace mitk
{
BaseDICOMReaderService::BaseDICOMReaderService(const std::string& description)
: AbstractFileReader(CustomMimeType(IOMimeTypes::DICOM_MIMETYPE()), description)
{
}
BaseDICOMReaderService::BaseDICOMReaderService(const mitk::CustomMimeType& customType, const std::string& description)
: AbstractFileReader(customType, description)
{
}
void BaseDICOMReaderService::SetOnlyRegardOwnSeries(bool regard)
{
m_OnlyRegardOwnSeries = regard;
}
bool BaseDICOMReaderService::GetOnlyRegardOwnSeries() const
{
return m_OnlyRegardOwnSeries;
}
std::vector<itk::SmartPointer<BaseData> > BaseDICOMReaderService::DoRead()
{
std::vector<BaseData::Pointer> result;
const std::string fileName = this->GetLocalFileName();
//special handling of Philips 3D US DICOM.
//Copied from DICOMSeriesReaderService
if (DicomSeriesReader::IsPhilips3DDicom(fileName))
{
MITK_INFO << "it is a Philips3D US Dicom file" << std::endl;
mitk::LocaleSwitch localeSwitch("C");
std::locale previousCppLocale(std::cin.getloc());
std::locale l("C");
std::cin.imbue(l);
DataNode::Pointer node = DataNode::New();
mitk::DicomSeriesReader::StringContainer stringvec;
stringvec.push_back(fileName);
if (DicomSeriesReader::LoadDicomSeries(stringvec, *node))
{
BaseData::Pointer data = node->GetData();
StringProperty::Pointer nameProp = StringProperty::New(itksys::SystemTools::GetFilenameName(fileName));
data->GetPropertyList()->SetProperty("name", nameProp);
result.push_back(data);
}
std::cin.imbue(previousCppLocale);
return result;
}
//Normal DICOM handling (It wasn't a Philips 3D US)
mitk::StringList relevantFiles = this->GetDICOMFilesInSameDirectory();
if (relevantFiles.empty())
{
MITK_INFO << "DICOMReader service found no relevant files in specified location. No data is loaded. Location: "<<fileName;
}
else
{
bool pathIsDirectory = itksys::SystemTools::FileIsDirectory(fileName);
if (!pathIsDirectory && m_OnlyRegardOwnSeries)
{
relevantFiles = mitk::FilterDICOMFilesForSameSeries(fileName, relevantFiles);
}
mitk::DICOMFileReader::Pointer reader = this->GetReader(relevantFiles);
if(reader.IsNull())
{
MITK_INFO << "DICOMReader service found no suitable reader configuration for relevant files.";
}
else
{
if (!pathIsDirectory)
{ //we ensure that we only load the relevant image block files
const auto nrOfOutputs = reader->GetNumberOfOutputs();
for (unsigned int outputIndex = 0; outputIndex < nrOfOutputs; ++outputIndex)
{
const auto frameList = reader->GetOutput(outputIndex).GetImageFrameList();
auto finding = std::find_if(frameList.begin(), frameList.end(), [&](const DICOMImageFrameInfo::Pointer& frame) { return frame->Filename == fileName; });
if (finding != frameList.end())
- { //we have the block containing the fileName -> these are the realy relevant files.
+ { //we have the block containing the fileName -> these are the really relevant files.
relevantFiles.resize(frameList.size());
std::transform(frameList.begin(), frameList.end(), relevantFiles.begin(), [](const DICOMImageFrameInfo::Pointer& frame) { return frame->Filename; });
break;
}
}
}
const unsigned int ntotalfiles = relevantFiles.size();
for( unsigned int i=0; i< ntotalfiles; i++)
{
m_ReadFiles.push_back( relevantFiles.at(i) );
}
reader->SetAdditionalTagsOfInterest(mitk::GetCurrentDICOMTagsOfInterest());
reader->SetTagLookupTableToPropertyFunctor(mitk::GetDICOMPropertyForDICOMValuesFunctor);
reader->SetInputFiles(relevantFiles);
mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
scanner->AddTagPaths(reader->GetTagsOfInterest());
scanner->SetInputFiles(relevantFiles);
scanner->Scan();
reader->SetTagCache(scanner->GetScanCache());
reader->AnalyzeInputFiles();
reader->LoadImages();
for (unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i)
{
const mitk::DICOMImageBlockDescriptor& desc = reader->GetOutput(i);
mitk::BaseData::Pointer data = desc.GetMitkImage().GetPointer();
std::string nodeName = GenerateNameFromDICOMProperties(&desc);
StringProperty::Pointer nameProp = StringProperty::New(nodeName);
data->SetProperty("name", nameProp);
data->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_CONFIGURATION()), StringProperty::New(reader->GetConfigurationLabel()));
result.push_back(data);
}
}
}
return result;
}
StringList BaseDICOMReaderService::GetDICOMFilesInSameDirectory() const
{
std::string fileName = this->GetLocalFileName();
mitk::StringList relevantFiles = mitk::GetDICOMFilesInSameDirectory(fileName);
return relevantFiles;
}
IFileReader::ConfidenceLevel BaseDICOMReaderService::GetConfidenceLevel() const
{
IFileReader::ConfidenceLevel abstractConfidence = AbstractFileReader::GetConfidenceLevel();
if (Unsupported == abstractConfidence)
{
if (itksys::SystemTools::FileIsDirectory(this->GetInputLocation().c_str()))
{
// In principle we support dicom directories
return Supported;
}
}
return abstractConfidence;
}
std::string GenerateNameFromDICOMProperties(const mitk::IPropertyProvider* provider)
{
std::string nodeName = mitk::DataNode::NO_NAME_VALUE();
auto studyProp = provider->GetConstProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x1030).c_str());
if (studyProp.IsNotNull())
{
nodeName = studyProp->GetValueAsString();
}
auto seriesProp = provider->GetConstProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x103E).c_str());
if (seriesProp.IsNotNull())
{
if (studyProp.IsNotNull())
{
nodeName += " / ";
}
else
{
nodeName = "";
}
nodeName += seriesProp->GetValueAsString();
}
return nodeName;
};
}
diff --git a/Modules/DICOM/src/mitkClassicDICOMSeriesReader.cpp b/Modules/DICOM/src/mitkClassicDICOMSeriesReader.cpp
index 46636f17ef..99e03026a6 100644
--- a/Modules/DICOM/src/mitkClassicDICOMSeriesReader.cpp
+++ b/Modules/DICOM/src/mitkClassicDICOMSeriesReader.cpp
@@ -1,95 +1,95 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkClassicDICOMSeriesReader.h"
#include "mitkDICOMTagBasedSorter.h"
#include "mitkDICOMSortByTag.h"
#include "mitkSortByImagePositionPatient.h"
mitk::ClassicDICOMSeriesReader
::ClassicDICOMSeriesReader()
:ThreeDnTDICOMSeriesReader()
{
mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
// all the things that split by tag in mitk::DicomSeriesReader
tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x000e) ); // Series Instance UID
//tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
// a sorter...
mitk::DICOMSortCriterion::ConstPointer sorting =
mitk::SortByImagePositionPatient::New( // image position patient and image orientation
- mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0012), // aqcuisition number
- mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0032), // aqcuisition time
+ mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0012), // acquisition number
+ mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0032), // acquisition time
mitk::DICOMSortByTag::New( DICOMTag(0x0018, 0x1060), // trigger time
mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
).GetPointer()
).GetPointer()
).GetPointer()
).GetPointer()
).GetPointer();
tagSorter->SetSortCriterion( sorting );
tagSorter->SetStrictSorting(false); // nothing did enforce constant distances before, there was just the EquiDistantBlocksSorter logic
// define above sorting for this class
this->AddSortingElement( tagSorter );
this->SetFixTiltByShearing(true); // that was configurable, default was true
this->SetToleratedOriginOffset(0.005); // was hard-coded
this->SetGroup3DandT(true); // that was configurable, default was true
this->OnlyCondenseSameSeriesOff();
m_EquiDistantBlocksSorter->SetAcceptTwoSlicesGroups(false); // old reader did not accept that
this->SetConfigurationLabel("2013 sorting logic");
this->SetConfigurationDescription("Sort by Image Position, then Acquisition Number, Time, Trigger time, group by 3D+t, group tilted images, condense blocks even if series does not match");
}
mitk::ClassicDICOMSeriesReader
::ClassicDICOMSeriesReader(const ClassicDICOMSeriesReader& other )
:ThreeDnTDICOMSeriesReader(other)
{
}
mitk::ClassicDICOMSeriesReader
::~ClassicDICOMSeriesReader()
{
}
mitk::ClassicDICOMSeriesReader&
mitk::ClassicDICOMSeriesReader
::operator=(const ClassicDICOMSeriesReader& other)
{
if (this != &other)
{
ThreeDnTDICOMSeriesReader::operator=(other);
}
return *this;
}
bool
mitk::ClassicDICOMSeriesReader
::operator==(const DICOMFileReader& other) const
{
if (dynamic_cast<const Self*>(&other))
{
return true;
}
else
{
return false;
}
}
diff --git a/Modules/DICOM/src/mitkDICOMGDCMTagScanner.cpp b/Modules/DICOM/src/mitkDICOMGDCMTagScanner.cpp
index 5d2eaee7aa..0dfbcd87f9 100644
--- a/Modules/DICOM/src/mitkDICOMGDCMTagScanner.cpp
+++ b/Modules/DICOM/src/mitkDICOMGDCMTagScanner.cpp
@@ -1,118 +1,118 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMGDCMTagScanner.h"
#include "mitkDICOMGDCMTagCache.h"
#include "mitkDICOMGDCMImageFrameInfo.h"
#include <gdcmScanner.h>
mitk::DICOMGDCMTagScanner::DICOMGDCMTagScanner()
{
m_GDCMScanner = std::make_shared<gdcm::Scanner>();
}
mitk::DICOMGDCMTagScanner::~DICOMGDCMTagScanner()
{
}
mitk::DICOMDatasetFinding mitk::DICOMGDCMTagScanner::GetTagValue( DICOMImageFrameInfo* frame, const DICOMTag& tag ) const
{
assert( frame );
assert(m_Cache.IsNotNull());
if (m_Cache.IsNull())
{
mitkThrow() << "Wrong usage of DICOMGDCMScanner- Called GetTagValue() before scanned at least once. No scanner cache available.";
}
return m_Cache->GetTagValue(frame, tag);
}
void mitk::DICOMGDCMTagScanner::AddTag( const DICOMTag& tag )
{
m_ScannedTags.insert( tag );
m_GDCMScanner->AddTag(
gdcm::Tag( tag.GetGroup(), tag.GetElement() ) ); // also a set, duplicate calls to AddTag don't hurt
}
void mitk::DICOMGDCMTagScanner::AddTags( const DICOMTagList& tags )
{
for ( auto tagIter = tags.cbegin(); tagIter != tags.cend(); ++tagIter )
{
this->AddTag( *tagIter );
}
}
void mitk::DICOMGDCMTagScanner::AddTagPath(const DICOMTagPath& path)
{
if (path.Size() != 1 || !path.IsExplicit())
{
std::stringstream errorstring;
errorstring << "Invalid call to DICOMGDCMTagScanner::AddTagPath(). "
- << "Scanner does only support pathes that are explicitly specify one tag. "
+ << "Scanner does only support paths that are explicitly specify one tag. "
<< "Invalid path: "<<path.ToStr();
MITK_ERROR << errorstring.str();
throw std::invalid_argument(errorstring.str());
}
this->AddTag(path.GetFirstNode().tag);
}
void mitk::DICOMGDCMTagScanner::AddTagPaths(const DICOMTagPathList& paths)
{
for (const auto& path : paths)
{
if (path.Size() != 1 || !path.IsExplicit())
{
std::stringstream errorstring;
errorstring << "Invalid call to DICOMGDCMTagScanner::AddTagPaths(). "
- << "Scanner does only support pathes that are explicitly specify one tag. "
+ << "Scanner does only support paths that are explicitly specify one tag. "
<< "Invalid path: " << path.ToStr();
MITK_ERROR << errorstring.str();
throw std::invalid_argument(errorstring.str());
}
this->AddTag(path.GetFirstNode().tag);
}
}
void mitk::DICOMGDCMTagScanner::SetInputFiles( const StringList& filenames )
{
m_InputFilenames = filenames;
}
void mitk::DICOMGDCMTagScanner::Scan()
{
// TODO integrate push/pop locale??
m_GDCMScanner->Scan( m_InputFilenames );
DICOMGDCMTagCache::Pointer newCache = DICOMGDCMTagCache::New();
newCache->InitCache(m_ScannedTags, m_GDCMScanner, m_InputFilenames);
m_Cache = newCache;
}
mitk::DICOMTagCache::Pointer
mitk::DICOMGDCMTagScanner::GetScanCache() const
{
return m_Cache.GetPointer();
}
mitk::DICOMDatasetAccessingImageFrameList mitk::DICOMGDCMTagScanner::GetFrameInfoList() const
{
mitk::DICOMDatasetAccessingImageFrameList result;
if (m_Cache.IsNotNull())
{
result = m_Cache->GetFrameInfoList();
}
return result;
}
diff --git a/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp b/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
index 5bac64360b..334d8da6fb 100644
--- a/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
+++ b/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
@@ -1,912 +1,912 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMImageBlockDescriptor.h"
#include "mitkStringProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkPropertyKeyPath.h"
#include "mitkDICOMIOMetaInformationPropertyConstants.h"
#include <gdcmUIDs.h>
#include <vector>
#include <gdcmVersion.h>
#include <dcmtk/config/osconfig.h>
mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor()
: m_ReaderImplementationLevel( SOPClassUnknown )
, m_PropertyList( PropertyList::New() )
, m_TagCache( nullptr )
, m_PropertiesOutOfDate( true )
{
m_PropertyFunctor = &mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues;
}
mitk::DICOMImageBlockDescriptor::~DICOMImageBlockDescriptor()
{
}
mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor( const DICOMImageBlockDescriptor& other )
: m_ImageFrameList( other.m_ImageFrameList )
, m_MitkImage( other.m_MitkImage )
, m_SliceIsLoaded( other.m_SliceIsLoaded )
, m_ReaderImplementationLevel( other.m_ReaderImplementationLevel )
, m_TiltInformation( other.m_TiltInformation )
, m_PropertyList( other.m_PropertyList->Clone() )
, m_TagCache( other.m_TagCache )
, m_PropertiesOutOfDate( other.m_PropertiesOutOfDate )
, m_AdditionalTagMap(other.m_AdditionalTagMap)
, m_FoundAdditionalTags(other.m_FoundAdditionalTags)
, m_PropertyFunctor(other.m_PropertyFunctor)
{
if ( m_MitkImage )
{
m_MitkImage = m_MitkImage->Clone();
}
}
mitk::DICOMImageBlockDescriptor& mitk::DICOMImageBlockDescriptor::
operator=( const DICOMImageBlockDescriptor& other )
{
if ( this != &other )
{
m_ImageFrameList = other.m_ImageFrameList;
m_MitkImage = other.m_MitkImage;
m_SliceIsLoaded = other.m_SliceIsLoaded;
m_ReaderImplementationLevel = other.m_ReaderImplementationLevel;
m_TiltInformation = other.m_TiltInformation;
m_AdditionalTagMap = other.m_AdditionalTagMap;
m_FoundAdditionalTags = other.m_FoundAdditionalTags;
m_PropertyFunctor = other.m_PropertyFunctor;
if ( other.m_PropertyList )
{
m_PropertyList = other.m_PropertyList->Clone();
}
if ( other.m_MitkImage )
{
m_MitkImage = other.m_MitkImage->Clone();
}
m_TagCache = other.m_TagCache;
m_PropertiesOutOfDate = other.m_PropertiesOutOfDate;
}
return *this;
}
mitk::DICOMTagList mitk::DICOMImageBlockDescriptor::GetTagsOfInterest()
{
DICOMTagList completeList;
completeList.push_back( DICOMTag( 0x0018, 0x1164 ) ); // pixel spacing
completeList.push_back( DICOMTag( 0x0028, 0x0030 ) ); // imager pixel spacing
completeList.push_back( DICOMTag( 0x0008, 0x0018 ) ); // sop instance UID
completeList.push_back( DICOMTag( 0x0008, 0x0016 ) ); // sop class UID
completeList.push_back( DICOMTag( 0x0020, 0x0011 ) ); // series number
completeList.push_back( DICOMTag( 0x0008, 0x1030 ) ); // study description
completeList.push_back( DICOMTag( 0x0008, 0x103e ) ); // series description
completeList.push_back( DICOMTag( 0x0008, 0x0060 ) ); // modality
completeList.push_back( DICOMTag( 0x0018, 0x0024 ) ); // sequence name
completeList.push_back( DICOMTag( 0x0020, 0x0037 ) ); // image orientation
completeList.push_back( DICOMTag( 0x0020, 0x1041 ) ); // slice location
completeList.push_back( DICOMTag( 0x0020, 0x0012 ) ); // acquisition number
completeList.push_back( DICOMTag( 0x0020, 0x0013 ) ); // instance number
completeList.push_back( DICOMTag( 0x0020, 0x0032 ) ); // image position patient
completeList.push_back( DICOMTag( 0x0028, 0x1050 ) ); // window center
completeList.push_back( DICOMTag( 0x0028, 0x1051 ) ); // window width
completeList.push_back( DICOMTag( 0x0008, 0x0008 ) ); // image type
completeList.push_back( DICOMTag( 0x0028, 0x0004 ) ); // photometric interpretation
return completeList;
}
void mitk::DICOMImageBlockDescriptor::SetAdditionalTagsOfInterest(
const AdditionalTagsMapType& tagMap)
{
m_AdditionalTagMap = tagMap;
}
void mitk::DICOMImageBlockDescriptor::SetTiltInformation( const GantryTiltInformation& info )
{
m_TiltInformation = info;
}
const mitk::GantryTiltInformation mitk::DICOMImageBlockDescriptor::GetTiltInformation() const
{
return m_TiltInformation;
}
void mitk::DICOMImageBlockDescriptor::SetImageFrameList( const DICOMImageFrameList& framelist )
{
m_ImageFrameList = framelist;
m_SliceIsLoaded.resize( framelist.size() );
m_SliceIsLoaded.assign( framelist.size(), false );
m_PropertiesOutOfDate = true;
}
const mitk::DICOMImageFrameList& mitk::DICOMImageBlockDescriptor::GetImageFrameList() const
{
return m_ImageFrameList;
}
void mitk::DICOMImageBlockDescriptor::SetMitkImage( Image::Pointer image )
{
if ( m_MitkImage != image )
{
if ( m_TagCache.IsExpired() )
{
MITK_ERROR << "Unable to describe MITK image with properties without a tag-cache object!";
m_MitkImage = nullptr;
return;
}
if ( m_ImageFrameList.empty() )
{
MITK_ERROR << "Unable to describe MITK image with properties without a frame list!";
m_MitkImage = nullptr;
return;
}
// Should verify that the image matches m_ImageFrameList and m_TagCache
// however, this is hard to do without re-analyzing all
// TODO we should at least make sure that the number of frames is identical (plus rows/columns,
// orientation)
// without gantry tilt correction, we can also check image origin
m_MitkImage = this->DescribeImageWithProperties( this->FixupSpacing( image ) );
}
}
mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::GetMitkImage() const
{
return m_MitkImage;
}
mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::FixupSpacing( Image* mitkImage )
{
if ( mitkImage )
{
Vector3D imageSpacing = mitkImage->GetGeometry()->GetSpacing();
ScalarType desiredSpacingX = imageSpacing[0];
ScalarType desiredSpacingY = imageSpacing[1];
this->GetDesiredMITKImagePixelSpacing(
desiredSpacingX, desiredSpacingY ); // prefer pixel spacing over imager pixel spacing
if ( desiredSpacingX <= 0 || desiredSpacingY <= 0 )
{
return mitkImage;
}
MITK_DEBUG << "Loaded image with spacing " << imageSpacing[0] << ", " << imageSpacing[1];
MITK_DEBUG << "Found correct spacing info " << desiredSpacingX << ", " << desiredSpacingY;
imageSpacing[0] = desiredSpacingX;
imageSpacing[1] = desiredSpacingY;
mitkImage->GetGeometry()->SetSpacing( imageSpacing );
}
return mitkImage;
}
void mitk::DICOMImageBlockDescriptor::SetSliceIsLoaded( unsigned int index, bool isLoaded )
{
if ( index < m_SliceIsLoaded.size() )
{
m_SliceIsLoaded[index] = isLoaded;
}
else
{
std::stringstream ss;
ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
throw std::invalid_argument( ss.str() );
}
}
bool mitk::DICOMImageBlockDescriptor::IsSliceLoaded( unsigned int index ) const
{
if ( index < m_SliceIsLoaded.size() )
{
return m_SliceIsLoaded[index];
}
else
{
std::stringstream ss;
ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
throw std::invalid_argument( ss.str() );
}
}
bool mitk::DICOMImageBlockDescriptor::AllSlicesAreLoaded() const
{
bool allLoaded = true;
for ( auto iter = m_SliceIsLoaded.cbegin(); iter != m_SliceIsLoaded.cend(); ++iter )
{
allLoaded &= *iter;
}
return allLoaded;
}
/*
PS defined IPS defined PS==IPS
0 0 --> UNKNOWN spacing, loader will invent
0 1 --> spacing as at detector surface
1 0 --> spacing as in patient
1 1 0 --> detector surface spacing CORRECTED for geometrical
magnifications: spacing as in patient
1 1 1 --> detector surface spacing NOT corrected for geometrical
magnifications: spacing as at detector
*/
mitk::PixelSpacingInterpretation mitk::DICOMImageBlockDescriptor::GetPixelSpacingInterpretation() const
{
if ( m_ImageFrameList.empty() || m_TagCache.IsExpired() )
{
MITK_ERROR << "Invalid call to GetPixelSpacingInterpretation. Need to have initialized tag-cache!";
return SpacingUnknown;
}
const std::string pixelSpacing = this->GetPixelSpacing();
const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
if ( pixelSpacing.empty() )
{
if ( imagerPixelSpacing.empty() )
{
return SpacingUnknown;
}
else
{
return SpacingAtDetector;
}
}
else // Pixel Spacing defined
{
if ( imagerPixelSpacing.empty() )
{
return SpacingInPatient;
}
else if ( pixelSpacing != imagerPixelSpacing )
{
return SpacingInPatient;
}
else
{
return SpacingAtDetector;
}
}
}
std::string mitk::DICOMImageBlockDescriptor::GetPixelSpacing() const
{
auto tagCache = m_TagCache.Lock();
if ( m_ImageFrameList.empty() || tagCache.IsNull() )
{
MITK_ERROR << "Invalid call to GetPixelSpacing. Need to have initialized tag-cache!";
return std::string( "" );
}
static const DICOMTag tagPixelSpacing( 0x0028, 0x0030 );
return tagCache->GetTagValue( m_ImageFrameList.front(), tagPixelSpacing ).value;
}
std::string mitk::DICOMImageBlockDescriptor::GetImagerPixelSpacing() const
{
auto tagCache = m_TagCache.Lock();
if ( m_ImageFrameList.empty() || tagCache.IsNull() )
{
MITK_ERROR << "Invalid call to GetImagerPixelSpacing. Need to have initialized tag-cache!";
return std::string( "" );
}
static const DICOMTag tagImagerPixelSpacing( 0x0018, 0x1164 );
return tagCache->GetTagValue( m_ImageFrameList.front(), tagImagerPixelSpacing ).value;
}
void mitk::DICOMImageBlockDescriptor::GetDesiredMITKImagePixelSpacing( ScalarType& spacingX,
ScalarType& spacingY ) const
{
const std::string pixelSpacing = this->GetPixelSpacing();
// preference for "in patient" pixel spacing
if ( !DICOMStringToSpacing( pixelSpacing, spacingX, spacingY ) )
{
const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
// fallback to "on detector" spacing
if ( !DICOMStringToSpacing( imagerPixelSpacing, spacingX, spacingY ) )
{
// at this point we have no hints whether the spacing is correct
// do a quick sanity check and either trust in the input or set both to 1
// We assume neither spacing to be negative, zero or unexpectedly large for
// medical images
if (spacingX < mitk::eps || spacingX > 1000 || spacingY < mitk::eps || spacingY > 1000)
{
spacingX = spacingY = 1.0;
}
}
}
}
void mitk::DICOMImageBlockDescriptor::SetProperty( const std::string& key, BaseProperty* value )
{
m_PropertyList->SetProperty( key, value );
}
mitk::BaseProperty* mitk::DICOMImageBlockDescriptor::GetProperty( const std::string& key ) const
{
this->UpdateImageDescribingProperties();
return m_PropertyList->GetProperty( key );
}
std::string mitk::DICOMImageBlockDescriptor::GetPropertyAsString( const std::string& key ) const
{
this->UpdateImageDescribingProperties();
const mitk::BaseProperty::Pointer property = m_PropertyList->GetProperty( key );
if ( property.IsNotNull() )
{
return property->GetValueAsString();
}
else
{
return std::string( "" );
}
}
void mitk::DICOMImageBlockDescriptor::SetFlag( const std::string& key, bool value )
{
m_PropertyList->ReplaceProperty( key, BoolProperty::New( value ) );
}
bool mitk::DICOMImageBlockDescriptor::GetFlag( const std::string& key, bool defaultValue ) const
{
this->UpdateImageDescribingProperties();
BoolProperty::ConstPointer boolProp = dynamic_cast<BoolProperty*>( this->GetProperty( key ) );
if ( boolProp.IsNotNull() )
{
return boolProp->GetValue();
}
else
{
return defaultValue;
}
}
void mitk::DICOMImageBlockDescriptor::SetIntProperty( const std::string& key, int value )
{
m_PropertyList->ReplaceProperty( key, IntProperty::New( value ) );
}
int mitk::DICOMImageBlockDescriptor::GetIntProperty( const std::string& key, int defaultValue ) const
{
this->UpdateImageDescribingProperties();
IntProperty::ConstPointer intProp = dynamic_cast<IntProperty*>( this->GetProperty( key ) );
if ( intProp.IsNotNull() )
{
return intProp->GetValue();
}
else
{
return defaultValue;
}
}
double mitk::DICOMImageBlockDescriptor::stringtodouble( const std::string& str ) const
{
double d;
std::string trimmedstring( str );
try
{
trimmedstring = trimmedstring.erase( trimmedstring.find_last_not_of( " \n\r\t" ) + 1 );
}
catch ( ... )
{
// no last not of
}
std::string firstcomponent( trimmedstring );
try
{
firstcomponent = trimmedstring.erase( trimmedstring.find_first_of( "\\" ) );
}
catch ( ... )
{
// no last not of
}
std::istringstream converter( firstcomponent );
if ( !firstcomponent.empty() && ( converter >> d ) && converter.eof() )
{
return d;
}
else
{
- throw std::invalid_argument( "Argument is not a convertable number" );
+ throw std::invalid_argument( "Argument is not a convertible number" );
}
}
mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::DescribeImageWithProperties( Image* mitkImage )
{
// TODO: this is a collection of properties that have been provided by the
// legacy DicomSeriesReader.
// We should at some point clean up this collection and name them in a more
// consistent way!
if ( !mitkImage )
return mitkImage;
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_FILES()), this->GetProperty("filenamesForSlices"));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION_STRING()),
StringProperty::New(PixelSpacingInterpretationToString(this->GetPixelSpacingInterpretation())));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION()),
GenericProperty<PixelSpacingInterpretation>::New(this->GetPixelSpacingInterpretation()));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL_STRING()),
StringProperty::New(ReaderImplementationLevelToString(m_ReaderImplementationLevel)));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL()),
GenericProperty<ReaderImplementationLevel>::New(m_ReaderImplementationLevel));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_GANTRY_TILT_CORRECTED()),
BoolProperty::New(this->GetTiltInformation().IsRegularGantryTilt()));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_3D_plus_t()), BoolProperty::New(this->GetFlag("3D+t", false)));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_GDCM()), StringProperty::New(gdcm::Version::GetVersion()));
mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_DCMTK()), StringProperty::New(PACKAGE_VERSION));
// get all found additional tags of interest
for (const auto &tag : m_FoundAdditionalTags)
{
BaseProperty* prop = this->GetProperty(tag);
if (prop)
{
mitkImage->SetProperty(tag.c_str(), prop);
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//// Deprecated properties should be removed sooner then later (see above)
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// first part: add some tags that describe individual slices
- // these propeties are defined at analysis time (see UpdateImageDescribingProperties())
+ // these properties are defined at analysis time (see UpdateImageDescribingProperties())
const char* propertyKeySliceLocation = "dicom.image.0020.1041";
const char* propertyKeyInstanceNumber = "dicom.image.0020.0013";
const char* propertyKeySOPInstanceUID = "dicom.image.0008.0018";
mitkImage->SetProperty( propertyKeySliceLocation, this->GetProperty( "sliceLocationForSlices" ) );
mitkImage->SetProperty( propertyKeyInstanceNumber, this->GetProperty( "instanceNumberForSlices" ) );
mitkImage->SetProperty( propertyKeySOPInstanceUID, this->GetProperty( "SOPInstanceUIDForSlices" ) );
mitkImage->SetProperty( "files", this->GetProperty( "filenamesForSlices_deprecated" ) );
// second part: add properties that describe the whole image block
mitkImage->SetProperty( "dicomseriesreader.SOPClassUID", StringProperty::New( this->GetSOPClassUID() ) );
mitkImage->SetProperty( "dicomseriesreader.SOPClass", StringProperty::New( this->GetSOPClassUIDAsName() ) );
mitkImage->SetProperty(
"dicomseriesreader.PixelSpacingInterpretationString",
StringProperty::New( PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) ) );
mitkImage->SetProperty(
"dicomseriesreader.PixelSpacingInterpretation",
GenericProperty<PixelSpacingInterpretation>::New( this->GetPixelSpacingInterpretation() ) );
mitkImage->SetProperty(
"dicomseriesreader.ReaderImplementationLevelString",
StringProperty::New( ReaderImplementationLevelToString( m_ReaderImplementationLevel ) ) );
mitkImage->SetProperty( "dicomseriesreader.ReaderImplementationLevel",
GenericProperty<ReaderImplementationLevel>::New( m_ReaderImplementationLevel ) );
mitkImage->SetProperty( "dicomseriesreader.GantyTiltCorrected",
BoolProperty::New( this->GetTiltInformation().IsRegularGantryTilt() ) );
mitkImage->SetProperty( "dicomseriesreader.3D+t", BoolProperty::New( this->GetFlag( "3D+t", false ) ) );
// level window
const std::string windowCenter = this->GetPropertyAsString( "windowCenter" );
const std::string windowWidth = this->GetPropertyAsString( "windowWidth" );
try
{
const double level = stringtodouble( windowCenter );
const double window = stringtodouble( windowWidth );
mitkImage->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow( level, window ) ) );
}
catch ( ... )
{
// nothing, no levelwindow to be predicted...
}
const std::string modality = this->GetPropertyAsString( "modality" );
mitkImage->SetProperty( "modality", StringProperty::New( modality ) );
mitkImage->SetProperty( "dicom.pixel.PhotometricInterpretation",
this->GetProperty( "photometricInterpretation" ) );
mitkImage->SetProperty( "dicom.image.imagetype", this->GetProperty( "imagetype" ) );
mitkImage->SetProperty( "dicom.study.StudyDescription", this->GetProperty( "studyDescription" ) );
mitkImage->SetProperty( "dicom.series.SeriesDescription", this->GetProperty( "seriesDescription" ) );
mitkImage->SetProperty( "dicom.pixel.Rows", this->GetProperty( "rows" ) );
mitkImage->SetProperty( "dicom.pixel.Columns", this->GetProperty( "columns" ) );
// fourth part: get something from ImageIO. BUT this needs to be created elsewhere. or not at all!
return mitkImage;
}
void mitk::DICOMImageBlockDescriptor::SetReaderImplementationLevel( const ReaderImplementationLevel& level )
{
m_ReaderImplementationLevel = level;
}
mitk::ReaderImplementationLevel mitk::DICOMImageBlockDescriptor::GetReaderImplementationLevel() const
{
return m_ReaderImplementationLevel;
}
std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUID() const
{
auto tagCache = m_TagCache.Lock();
if ( !m_ImageFrameList.empty() && tagCache.IsNotNull() )
{
static const DICOMTag tagSOPClassUID( 0x0008, 0x0016 );
return tagCache->GetTagValue( m_ImageFrameList.front(), tagSOPClassUID ).value;
}
else
{
MITK_ERROR
<< "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUID(). Need to have initialized tag-cache!";
return std::string( "" );
}
}
std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUIDAsName() const
{
if ( !m_ImageFrameList.empty() && !m_TagCache.IsExpired() )
{
gdcm::UIDs uidKnowledge;
uidKnowledge.SetFromUID( this->GetSOPClassUID().c_str() );
const char* name = uidKnowledge.GetName();
if ( name )
{
return std::string( name );
}
else
{
return std::string( "" );
}
}
else
{
MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUIDAsName(). Need to have "
"initialized tag-cache!";
return std::string( "" );
}
}
int mitk::DICOMImageBlockDescriptor::GetNumberOfTimeSteps() const
{
int result = 1;
this->m_PropertyList->GetIntProperty("timesteps", result);
return result;
};
int mitk::DICOMImageBlockDescriptor::GetNumberOfFramesPerTimeStep() const
{
const int numberOfTimesteps = this->GetNumberOfTimeSteps();
int numberOfFramesPerTimestep = this->m_ImageFrameList.size() / numberOfTimesteps;
assert(int(double((double)this->m_ImageFrameList.size() / (double)numberOfTimesteps))
== numberOfFramesPerTimestep); // this should hold
return numberOfFramesPerTimestep;
};
void mitk::DICOMImageBlockDescriptor::SetTagCache( DICOMTagCache* privateCache )
{
// this must only be used during loading and never afterwards
m_TagCache = privateCache;
}
#define printPropertyRange( label, property_name ) \
\
{ \
const std::string first = this->GetPropertyAsString( #property_name "First" ); \
const std::string last = this->GetPropertyAsString( #property_name "Last" ); \
if ( !first.empty() || !last.empty() ) \
{ \
if ( first == last ) \
{ \
os << " " label ": '" << first << "'" << std::endl; \
} \
else \
{ \
os << " " label ": '" << first << "' - '" << last << "'" << std::endl; \
} \
} \
\
}
#define printProperty( label, property_name ) \
\
{ \
const std::string first = this->GetPropertyAsString( #property_name ); \
if ( !first.empty() ) \
{ \
os << " " label ": '" << first << "'" << std::endl; \
} \
\
}
#define printBool( label, commands ) \
\
{ \
os << " " label ": '" << ( commands ? "yes" : "no" ) << "'" << std::endl; \
\
}
void mitk::DICOMImageBlockDescriptor::Print(std::ostream& os, bool filenameDetails) const
{
os << " Number of Frames: '" << m_ImageFrameList.size() << "'" << std::endl;
os << " SOP class: '" << this->GetSOPClassUIDAsName() << "'" << std::endl;
printProperty( "Series Number", seriesNumber );
printProperty( "Study Description", studyDescription );
printProperty( "Series Description", seriesDescription );
printProperty( "Modality", modality );
printProperty( "Sequence Name", sequenceName );
printPropertyRange( "Slice Location", sliceLocation );
printPropertyRange( "Acquisition Number", acquisitionNumber );
printPropertyRange( "Instance Number", instanceNumber );
printPropertyRange( "Image Position", imagePositionPatient );
printProperty( "Image Orientation", orientation );
os << " Pixel spacing interpretation: '"
<< PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) << "'" << std::endl;
printBool( "Gantry Tilt", this->GetTiltInformation().IsRegularGantryTilt() )
// printBool("3D+t", this->GetFlag("3D+t",false))
// os << " MITK image loaded: '" << (this->GetMitkImage().IsNotNull() ? "yes" : "no") << "'" <<
// std::endl;
if ( filenameDetails )
{
os << " Files in this image block:" << std::endl;
for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end(); ++frameIter )
{
os << " " << ( *frameIter )->Filename;
if ( ( *frameIter )->FrameNo > 0 )
{
os << ", " << ( *frameIter )->FrameNo;
}
os << std::endl;
}
}
}
#define storeTagValueToProperty( tag_name, tag_g, tag_e ) \
\
{ \
const DICOMTag t( tag_g, tag_e ); \
const std::string tagValue = tagCache->GetTagValue( firstFrame, t ).value; \
const_cast<DICOMImageBlockDescriptor*>( this ) \
->SetProperty( #tag_name, StringProperty::New( tagValue ) ); \
\
}
#define storeTagValueRangeToProperty( tag_name, tag_g, tag_e ) \
\
{ \
const DICOMTag t( tag_g, tag_e ); \
const std::string tagValueFirst = tagCache->GetTagValue( firstFrame, t ).value; \
const std::string tagValueLast = tagCache->GetTagValue( lastFrame, t ).value; \
const_cast<DICOMImageBlockDescriptor*>( this ) \
->SetProperty( #tag_name "First", StringProperty::New( tagValueFirst ) ); \
const_cast<DICOMImageBlockDescriptor*>( this ) \
->SetProperty( #tag_name "Last", StringProperty::New( tagValueLast ) ); \
\
}
void mitk::DICOMImageBlockDescriptor::UpdateImageDescribingProperties() const
{
if ( !m_PropertiesOutOfDate )
return;
if ( !m_ImageFrameList.empty() )
{
auto tagCache = m_TagCache.Lock();
if (tagCache.IsNull())
{
MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::UpdateImageDescribingProperties(). Need to "
"have initialized tag-cache!";
return;
}
const DICOMImageFrameInfo::Pointer firstFrame = m_ImageFrameList.front();
const DICOMImageFrameInfo::Pointer lastFrame = m_ImageFrameList.back();
// see macros above
storeTagValueToProperty( seriesNumber, 0x0020, 0x0011 );
storeTagValueToProperty( studyDescription, 0x0008, 0x1030 );
storeTagValueToProperty( seriesDescription, 0x0008, 0x103e );
storeTagValueToProperty( modality, 0x0008, 0x0060 );
storeTagValueToProperty( sequenceName, 0x0018, 0x0024 );
storeTagValueToProperty( orientation, 0x0020, 0x0037 );
storeTagValueToProperty( rows, 0x0028, 0x0010 );
storeTagValueToProperty( columns, 0x0028, 0x0011 );
storeTagValueRangeToProperty( sliceLocation, 0x0020, 0x1041 );
storeTagValueRangeToProperty( acquisitionNumber, 0x0020, 0x0012 );
storeTagValueRangeToProperty( instanceNumber, 0x0020, 0x0013 );
storeTagValueRangeToProperty( imagePositionPatient, 0x0020, 0x0032 );
storeTagValueToProperty( windowCenter, 0x0028, 0x1050 );
storeTagValueToProperty( windowWidth, 0x0028, 0x1051 );
storeTagValueToProperty( imageType, 0x0008, 0x0008 );
storeTagValueToProperty( photometricInterpretation, 0x0028, 0x0004 );
// some per-image attributes
// frames are just numbered starting from 0. timestep 1 (the second time-step) has frames starting at
// (number-of-frames-per-timestep)
// std::string propertyKeySliceLocation = "dicom.image.0020.1041";
// std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
// std::string propertyKeySOPInstanceNumber = "dicom.image.0008.0018";
StringLookupTable sliceLocationForSlices;
StringLookupTable instanceNumberForSlices;
StringLookupTable SOPInstanceUIDForSlices;
StringLookupTable filenamesForSlices_deprecated;
DICOMCachedValueLookupTable filenamesForSlices;
const DICOMTag tagSliceLocation( 0x0020, 0x1041 );
const DICOMTag tagInstanceNumber( 0x0020, 0x0013 );
const DICOMTag tagSOPInstanceNumber( 0x0008, 0x0018 );
std::unordered_map<std::string, DICOMCachedValueLookupTable> additionalTagResultList;
unsigned int slice(0);
int timePoint(-1);
const int framesPerTimeStep = this->GetNumberOfFramesPerTimeStep();
for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end();
++slice, ++frameIter )
{
unsigned int zSlice = slice%framesPerTimeStep;
if ( zSlice == 0)
{
timePoint++;
}
const std::string sliceLocation = tagCache->GetTagValue( *frameIter, tagSliceLocation ).value;
sliceLocationForSlices.SetTableValue( slice, sliceLocation );
const std::string instanceNumber = tagCache->GetTagValue( *frameIter, tagInstanceNumber ).value;
instanceNumberForSlices.SetTableValue( slice, instanceNumber );
const std::string sopInstanceUID = tagCache->GetTagValue( *frameIter, tagSOPInstanceNumber ).value;
SOPInstanceUIDForSlices.SetTableValue( slice, sopInstanceUID );
const std::string filename = ( *frameIter )->Filename;
filenamesForSlices_deprecated.SetTableValue( slice, filename );
filenamesForSlices.SetTableValue(slice, { static_cast<unsigned int>(timePoint), zSlice, filename });
MITK_DEBUG << "Tag info for slice " << slice << ": SL '" << sliceLocation << "' IN '" << instanceNumber
<< "' SOP instance UID '" << sopInstanceUID << "'";
for (const auto& tag : m_AdditionalTagMap)
{
const DICOMTagCache::FindingsListType findings = tagCache->GetTagValue( *frameIter, tag.first );
for (const auto& finding : findings)
{
if (finding.isValid)
{
std::string propKey = (tag.second.empty()) ? DICOMTagPathToPropertyName(finding.path) : tag.second;
DICOMCachedValueInfo info{ static_cast<unsigned int>(timePoint), zSlice, finding.value };
additionalTagResultList[propKey].SetTableValue(slice, info);
}
}
}
}
// add property or properties with proper names
auto* thisInstance = const_cast<DICOMImageBlockDescriptor*>( this );
thisInstance->SetProperty( "sliceLocationForSlices",
StringLookupTableProperty::New( sliceLocationForSlices ) );
thisInstance->SetProperty( "instanceNumberForSlices",
StringLookupTableProperty::New( instanceNumberForSlices ) );
thisInstance->SetProperty( "SOPInstanceUIDForSlices",
StringLookupTableProperty::New( SOPInstanceUIDForSlices ) );
thisInstance->SetProperty( "filenamesForSlices_deprecated", StringLookupTableProperty::New( filenamesForSlices_deprecated ) );
thisInstance->SetProperty("filenamesForSlices", m_PropertyFunctor(filenamesForSlices));
//add properties for additional tags of interest
for ( auto iter = additionalTagResultList.cbegin(); iter != additionalTagResultList.cend(); ++iter )
{
thisInstance->SetProperty( iter->first, m_PropertyFunctor( iter->second ) );
thisInstance->m_FoundAdditionalTags.insert(m_FoundAdditionalTags.cend(),iter->first);
}
m_PropertiesOutOfDate = false;
}
}
mitk::BaseProperty::Pointer
mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues(const DICOMCachedValueLookupTable& cacheLookupTable)
{
const auto& lookupTable = cacheLookupTable.GetLookupTable();
typedef std::pair<int, DICOMCachedValueInfo> PairType;
if ( std::adjacent_find(
lookupTable.cbegin(),
lookupTable.cend(),
[]( const PairType& lhs, const PairType& rhs ) { return lhs.second.Value != rhs.second.Value; } )
== lookupTable.cend() )
{
return static_cast<mitk::BaseProperty::Pointer>(
mitk::StringProperty::New(cacheLookupTable.GetTableValue(0).Value).GetPointer());
}
StringLookupTable stringTable;
for (const auto &element : lookupTable)
{
stringTable.SetTableValue(element.first, element.second.Value);
}
return static_cast<mitk::BaseProperty::Pointer>(
mitk::StringLookupTableProperty::New(stringTable).GetPointer());
}
void mitk::DICOMImageBlockDescriptor::SetTagLookupTableToPropertyFunctor( TagLookupTableToPropertyFunctor functor )
{
if ( functor != nullptr )
{
m_PropertyFunctor = functor;
}
}
mitk::BaseProperty::ConstPointer mitk::DICOMImageBlockDescriptor::GetConstProperty(const std::string &propertyKey,
const std::string &/*contextName*/, bool /*fallBackOnDefaultContext*/) const
{
this->UpdateImageDescribingProperties();
return m_PropertyList->GetConstProperty(propertyKey);
};
std::vector<std::string> mitk::DICOMImageBlockDescriptor::GetPropertyKeys(const std::string &/*contextName*/, bool /*includeDefaultContext*/) const
{
this->UpdateImageDescribingProperties();
return m_PropertyList->GetPropertyKeys();
};
std::vector<std::string> mitk::DICOMImageBlockDescriptor::GetPropertyContextNames() const
{
return std::vector<std::string>();
};
diff --git a/Modules/DICOM/src/mitkDICOMSortByTag.cpp b/Modules/DICOM/src/mitkDICOMSortByTag.cpp
index fcfd09e354..2e55fbc6c9 100644
--- a/Modules/DICOM/src/mitkDICOMSortByTag.cpp
+++ b/Modules/DICOM/src/mitkDICOMSortByTag.cpp
@@ -1,177 +1,177 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMSortByTag.h"
#include "dcmtk/ofstd/ofstd.h"
mitk::DICOMSortByTag
::DICOMSortByTag(const DICOMTag& tag, DICOMSortCriterion::Pointer secondaryCriterion)
:DICOMSortCriterion(secondaryCriterion)
,m_Tag(tag)
{
}
mitk::DICOMSortByTag
::~DICOMSortByTag()
{
}
mitk::DICOMSortByTag
::DICOMSortByTag(const DICOMSortByTag& other )
:DICOMSortCriterion(other)
,m_Tag(other.m_Tag)
{
}
mitk::DICOMSortByTag&
mitk::DICOMSortByTag
::operator=(const DICOMSortByTag& other)
{
if (this != &other)
{
DICOMSortCriterion::operator=(other);
m_Tag = other.m_Tag;
}
return *this;
}
bool
mitk::DICOMSortByTag
::operator==(const DICOMSortCriterion& other) const
{
if (const auto* otherSelf = dynamic_cast<const DICOMSortByTag*>(&other))
{
if (!(this->m_Tag == otherSelf->m_Tag)) return false;
if (this->m_SecondaryCriterion.IsNull() && otherSelf->m_SecondaryCriterion.IsNull()) return true;
if (this->m_SecondaryCriterion.IsNull() || otherSelf->m_SecondaryCriterion.IsNull()) return false;
return *(this->m_SecondaryCriterion) == *(otherSelf->m_SecondaryCriterion);
}
else
{
return false;
}
}
void
mitk::DICOMSortByTag
::Print(std::ostream& os) const
{
m_Tag.Print(os);
}
mitk::DICOMTagList
mitk::DICOMSortByTag
::GetTagsOfInterest() const
{
DICOMTagList list;
list.push_back(m_Tag);
return list;
}
bool
mitk::DICOMSortByTag
::IsLeftBeforeRight(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right) const
{
return this->NumericCompare(left, right, m_Tag);
}
bool
mitk::DICOMSortByTag
::StringCompare(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, const DICOMTag& tag) const
{
assert(left);
assert(right);
DICOMDatasetFinding leftFinding = left->GetTagValueAsString(tag);
DICOMDatasetFinding rightFinding = right->GetTagValueAsString(tag);
//Doesn't care if findings are valid or not. If they are not valid,
- //value is empty, thats enough.
+ //value is empty, that's enough.
if (leftFinding.value != rightFinding.value)
{
return leftFinding.value.compare(rightFinding.value) < 0;
}
else
{
return this->NextLevelIsLeftBeforeRight(left, right);
}
}
bool
mitk::DICOMSortByTag
::NumericCompare(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, const DICOMTag& tag) const
{
assert(left);
assert(right);
const DICOMDatasetFinding leftFinding = left->GetTagValueAsString(tag);
const DICOMDatasetFinding rightFinding = right->GetTagValueAsString(tag);
//Doesn't care if findings are valid or not. If they are not valid,
- //value is empty, thats enough.
+ //value is empty, that's enough.
double leftDouble( 0 );
double rightDouble( 0 );
try
{
leftDouble = OFStandard::atof( leftFinding.value.c_str() );
rightDouble = OFStandard::atof(rightFinding.value.c_str());
}
catch ( const std::exception& /*e*/ )
{
return this->StringCompare(left,right, tag); // fallback to string compare
}
if ( leftDouble != rightDouble ) // can we decide?
{
return leftDouble < rightDouble;
}
else // ask secondary criterion
{
return this->NextLevelIsLeftBeforeRight( left, right );
}
}
double
mitk::DICOMSortByTag
::NumericDistance(const mitk::DICOMDatasetAccess* from, const mitk::DICOMDatasetAccess* to) const
{
assert(from);
assert(to);
const DICOMDatasetFinding fromFinding = from->GetTagValueAsString(m_Tag);
const DICOMDatasetFinding toFinding = to->GetTagValueAsString(m_Tag);
//Doesn't care if findings are valid or not. If they are not valid,
- //value is empty, thats enough.
+ //value is empty, that's enough.
double fromDouble(0);
double toDouble(0);
try
{
fromDouble = OFStandard::atof(fromFinding.value.c_str());
toDouble = OFStandard::atof(toFinding.value.c_str());
}
catch ( const std::exception& /*e*/ )
{
MITK_WARN << "NO NUMERIC DISTANCE between '" << fromFinding.value << "' and '" << toFinding.value << "'";
return 0;
}
return toDouble - fromDouble;
// TODO second-level compare?
}
diff --git a/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp b/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp
index 87c455a4d3..534da7c29b 100644
--- a/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp
+++ b/Modules/DICOM/src/mitkDICOMTagBasedSorter.cpp
@@ -1,596 +1,596 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMTagBasedSorter.h"
#include <algorithm>
#include <iomanip>
mitk::DICOMTagBasedSorter::CutDecimalPlaces
::CutDecimalPlaces(unsigned int precision)
:m_Precision(precision)
{
}
mitk::DICOMTagBasedSorter::CutDecimalPlaces
::CutDecimalPlaces(const CutDecimalPlaces& other)
:m_Precision(other.m_Precision)
{
}
std::string
mitk::DICOMTagBasedSorter::CutDecimalPlaces
::operator()(const std::string& input) const
{
- // be a bit tolerant for tags such as image orientation orienatation, let only the first few digits matter (http://bugs.mitk.org/show_bug.cgi?id=12263)
+ // be a bit tolerant for tags such as image orientation orientation, let only the first few digits matter (http://bugs.mitk.org/show_bug.cgi?id=12263)
// iterate all fields, convert each to a number, cut this number as configured, then return a concatenated string with all cut-off numbers
std::ostringstream resultString;
resultString.str(std::string());
resultString.clear();
resultString.setf(std::ios::fixed, std::ios::floatfield);
resultString.precision(m_Precision);
std::stringstream ss(input);
ss.str(input);
ss.clear();
std::string item;
double number(0);
std::istringstream converter(item);
while (std::getline(ss, item, '\\'))
{
converter.str(item);
converter.clear();
if (converter >> number && converter.eof())
{
// converted to double
resultString << number;
}
else
{
// did not convert to double
resultString << item; // just paste the unmodified string
}
if (!ss.eof())
{
resultString << "\\";
}
}
return resultString.str();
}
mitk::DICOMTagBasedSorter::TagValueProcessor*
mitk::DICOMTagBasedSorter::CutDecimalPlaces
::Clone() const
{
return new CutDecimalPlaces(*this);
}
unsigned int
mitk::DICOMTagBasedSorter::CutDecimalPlaces
::GetPrecision() const
{
return m_Precision;
}
mitk::DICOMTagBasedSorter
::DICOMTagBasedSorter()
:DICOMDatasetSorter()
,m_StrictSorting(m_DefaultStrictSorting)
,m_ExpectDistanceOne(m_DefaultExpectDistanceOne)
{
}
mitk::DICOMTagBasedSorter
::~DICOMTagBasedSorter()
{
for(auto ti = m_TagValueProcessor.cbegin();
ti != m_TagValueProcessor.cend();
++ti)
{
delete ti->second;
}
}
mitk::DICOMTagBasedSorter
::DICOMTagBasedSorter(const DICOMTagBasedSorter& other )
:DICOMDatasetSorter(other)
,m_DistinguishingTags( other.m_DistinguishingTags )
,m_SortCriterion( other.m_SortCriterion )
,m_StrictSorting( other.m_StrictSorting )
,m_ExpectDistanceOne( other.m_ExpectDistanceOne )
{
for(auto ti = other.m_TagValueProcessor.cbegin();
ti != other.m_TagValueProcessor.cend();
++ti)
{
m_TagValueProcessor[ti->first] = ti->second->Clone();
}
}
mitk::DICOMTagBasedSorter&
mitk::DICOMTagBasedSorter
::operator=(const DICOMTagBasedSorter& other)
{
if (this != &other)
{
DICOMDatasetSorter::operator=(other);
m_DistinguishingTags = other.m_DistinguishingTags;
m_SortCriterion = other.m_SortCriterion;
m_StrictSorting = other.m_StrictSorting;
m_ExpectDistanceOne = other.m_ExpectDistanceOne;
for(auto ti = other.m_TagValueProcessor.cbegin();
ti != other.m_TagValueProcessor.cend();
++ti)
{
m_TagValueProcessor[ti->first] = ti->second->Clone();
}
}
return *this;
}
bool
mitk::DICOMTagBasedSorter
::operator==(const DICOMDatasetSorter& other) const
{
if (const auto* otherSelf = dynamic_cast<const DICOMTagBasedSorter*>(&other))
{
if (this->m_StrictSorting != otherSelf->m_StrictSorting) return false;
if (this->m_ExpectDistanceOne != otherSelf->m_ExpectDistanceOne) return false;
bool allTagsPresentAndEqual(true);
if (this->m_DistinguishingTags.size() != otherSelf->m_DistinguishingTags.size())
return false;
for (auto myTag = this->m_DistinguishingTags.cbegin();
myTag != this->m_DistinguishingTags.cend();
++myTag)
{
allTagsPresentAndEqual &= (std::find( otherSelf->m_DistinguishingTags.cbegin(), otherSelf->m_DistinguishingTags.cend(), *myTag )
!= otherSelf->m_DistinguishingTags.cend()); // other contains this tags
// since size is equal, we don't need to check the inverse
}
if (!allTagsPresentAndEqual) return false;
if (this->m_SortCriterion.IsNotNull() && otherSelf->m_SortCriterion.IsNotNull())
{
return *(this->m_SortCriterion) == *(otherSelf->m_SortCriterion);
}
else
{
return this->m_SortCriterion.IsNull() && otherSelf->m_SortCriterion.IsNull();
}
}
else
{
return false;
}
}
void
mitk::DICOMTagBasedSorter
::PrintConfiguration(std::ostream& os, const std::string& indent) const
{
os << indent << "Tag based sorting "
<< "(strict=" << (m_StrictSorting?"true":"false")
<< ", expectDistanceOne=" << (m_ExpectDistanceOne?"true":"false") << "):"
<< std::endl;
for (auto tagIter = m_DistinguishingTags.begin();
tagIter != m_DistinguishingTags.end();
++tagIter)
{
os << indent << " Split on ";
tagIter->Print(os);
os << std::endl;
}
DICOMSortCriterion::ConstPointer crit = m_SortCriterion.GetPointer();
while (crit.IsNotNull())
{
os << indent << " Sort by ";
crit->Print(os);
os << std::endl;
crit = crit->GetSecondaryCriterion();
}
}
void
mitk::DICOMTagBasedSorter
::SetStrictSorting(bool strict)
{
m_StrictSorting = strict;
}
bool
mitk::DICOMTagBasedSorter
::GetStrictSorting() const
{
return m_StrictSorting;
}
void
mitk::DICOMTagBasedSorter
::SetExpectDistanceOne(bool strict)
{
m_ExpectDistanceOne = strict;
}
bool
mitk::DICOMTagBasedSorter
::GetExpectDistanceOne() const
{
return m_ExpectDistanceOne;
}
mitk::DICOMTagList
mitk::DICOMTagBasedSorter
::GetTagsOfInterest()
{
DICOMTagList allTags = m_DistinguishingTags;
if (m_SortCriterion.IsNotNull())
{
const DICOMTagList sortingRelevantTags = m_SortCriterion->GetAllTagsOfInterest();
allTags.insert( allTags.end(), sortingRelevantTags.cbegin(), sortingRelevantTags.cend() ); // append
}
return allTags;
}
mitk::DICOMTagList
mitk::DICOMTagBasedSorter
::GetDistinguishingTags() const
{
return m_DistinguishingTags;
}
const mitk::DICOMTagBasedSorter::TagValueProcessor*
mitk::DICOMTagBasedSorter
::GetTagValueProcessorForDistinguishingTag(const DICOMTag& tag) const
{
auto loc = m_TagValueProcessor.find(tag);
if (loc != m_TagValueProcessor.cend())
{
return loc->second;
}
else
{
return nullptr;
}
}
void
mitk::DICOMTagBasedSorter
::AddDistinguishingTag( const DICOMTag& tag, TagValueProcessor* tagValueProcessor )
{
m_DistinguishingTags.push_back(tag);
m_TagValueProcessor[tag] = tagValueProcessor;
}
void
mitk::DICOMTagBasedSorter
::SetSortCriterion( DICOMSortCriterion::ConstPointer criterion )
{
m_SortCriterion = criterion;
}
mitk::DICOMSortCriterion::ConstPointer
mitk::DICOMTagBasedSorter
::GetSortCriterion() const
{
return m_SortCriterion;
}
void
mitk::DICOMTagBasedSorter
::Sort()
{
// 1. split
// 2. sort each group
GroupIDToListType groups = this->SplitInputGroups();
GroupIDToListType& sortedGroups = this->SortGroups( groups );
// 3. define output
this->SetNumberOfOutputs(sortedGroups.size());
unsigned int outputIndex(0);
for (auto groupIter = sortedGroups.cbegin();
groupIter != sortedGroups.cend();
++outputIndex, ++groupIter)
{
this->SetOutput(outputIndex, groupIter->second);
}
}
std::string
mitk::DICOMTagBasedSorter
::BuildGroupID( DICOMDatasetAccess* dataset )
{
// just concatenate all tag values
assert(dataset);
std::stringstream groupID;
groupID << "g";
for (auto tagIter = m_DistinguishingTags.cbegin();
tagIter != m_DistinguishingTags.cend();
++tagIter)
{
groupID << tagIter->GetGroup() << tagIter->GetElement(); // make group/element part of the id to cover empty tags
DICOMDatasetFinding rawTagValue = dataset->GetTagValueAsString(*tagIter);
std::string processedTagValue;
if ( m_TagValueProcessor[*tagIter] != nullptr && rawTagValue.isValid)
{
processedTagValue = (*m_TagValueProcessor[*tagIter])(rawTagValue.value);
}
else
{
processedTagValue = rawTagValue.value;
}
groupID << processedTagValue;
}
// shorten ID?
return groupID.str();
}
mitk::DICOMTagBasedSorter::GroupIDToListType
mitk::DICOMTagBasedSorter
::SplitInputGroups()
{
DICOMDatasetList input = GetInput(); // copy
GroupIDToListType listForGroupID;
for (auto dsIter = input.cbegin();
dsIter != input.cend();
++dsIter)
{
DICOMDatasetAccess* dataset = *dsIter;
assert(dataset);
std::string groupID = this->BuildGroupID( dataset );
MITK_DEBUG << "Group ID for for " << dataset->GetFilenameIfAvailable() << ": " << groupID;
listForGroupID[groupID].push_back(dataset);
}
MITK_DEBUG << "After tag based splitting: " << listForGroupID.size() << " groups";
return listForGroupID;
}
mitk::DICOMTagBasedSorter::GroupIDToListType&
mitk::DICOMTagBasedSorter
::SortGroups(GroupIDToListType& groups)
{
if (m_SortCriterion.IsNotNull())
{
/*
Three steps here:
1. sort within each group
- this may result in orders such as 1 2 3 4 6 7 8 10 12 13 14
2. create new groups by enforcing consecutive order within each group
- resorts above example like 1 2 3 4 ; 6 7 8 ; 10 ; 12 13 14
3. sort all of the groups (not WITHIN each group) by their first frame
- if earlier "distinguish" steps created groups like 6 7 8 ; 1 2 3 4 ; 10,
then this step would sort them like 1 2 3 4 ; 6 7 8 ; 10
*/
// Step 1: sort within the groups
// for each output
// sort by all configured tags, use secondary tags when equal or empty
// make configurable:
// - sorting order (ascending, descending)
// - sort numerically
// - ... ?
unsigned int groupIndex(0);
for (auto gIter = groups.begin();
gIter != groups.end();
++groupIndex, ++gIter)
{
DICOMDatasetList& dsList = gIter->second;
#ifdef MBILOG_ENABLE_DEBUG
MITK_DEBUG << " --------------------------------------------------------------------------------";
MITK_DEBUG << " DICOMTagBasedSorter before sorting group : " << groupIndex;
for (auto oi = dsList.begin();
oi != dsList.cend();
++oi)
{
MITK_DEBUG << " INPUT : " << (*oi)->GetFilenameIfAvailable();
}
#endif // #ifdef MBILOG_ENABLE_DEBUG
std::sort( dsList.begin(), dsList.end(), ParameterizedDatasetSort( m_SortCriterion ) );
#ifdef MBILOG_ENABLE_DEBUG
MITK_DEBUG << " --------------------------------------------------------------------------------";
MITK_DEBUG << " DICOMTagBasedSorter after sorting group : " << groupIndex;
for (auto oi = dsList.cbegin();
oi != dsList.cend();
++oi)
{
MITK_DEBUG << " OUTPUT : " << (*oi)->GetFilenameIfAvailable();
}
MITK_DEBUG << " --------------------------------------------------------------------------------";
#endif // MBILOG_ENABLE_DEBUG
}
GroupIDToListType consecutiveGroups;
if (m_StrictSorting)
{
// Step 2: create new groups by enforcing consecutive order within each group
unsigned int groupIndex(0);
for (auto gIter = groups.begin();
gIter != groups.end();
++gIter)
{
std::stringstream groupKey;
groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
DICOMDatasetList& dsList = gIter->second;
DICOMDatasetAccess* previousDS(nullptr);
unsigned int dsIndex(0);
double constantDistance(0.0);
bool constantDistanceInitialized(false);
for (auto dataset = dsList.cbegin();
dataset != dsList.cend();
++dsIndex, ++dataset)
{
if (dsIndex >0) // ignore the first dataset, we cannot check any distances yet..
{
// for the second and every following dataset:
// let the sorting criterion calculate a "distance"
// if the distance is not 1, split off a new group!
const double currentDistance = m_SortCriterion->NumericDistance(previousDS, *dataset);
if (constantDistanceInitialized)
{
if (fabs(currentDistance - constantDistance) < fabs(constantDistance * 0.01)) // ok, deviation of up to 1% of distance is tolerated
{
// nothing to do, just ok
MITK_DEBUG << "Checking currentDistance==" << currentDistance << ": small enough";
}
//else if (currentDistance < mitk::eps) // close enough to 0
else
{
MITK_DEBUG << "Split consecutive group at index " << dsIndex << " (current distance " << currentDistance << ", constant distance " << constantDistance << ")";
// split! this is done by simply creating a new group (key)
groupKey.str(std::string());
groupKey.clear();
groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
}
}
else
{
// second slice: learn about the expected distance!
// heuristic: if distance is an integer, we check for a special case:
// if the distance is integer and not 1/-1, then we assume
// a missing slice right after the first slice
// ==> split off slices
// in all other cases: second dataset at this position, no need to split already, we are still learning about the images
// addition to the above: when sorting by imagepositions, a distance other than 1 between the first two slices is
// not unusual, actually expected... then we should not split
if (m_ExpectDistanceOne)
{
if ((currentDistance - (int)currentDistance == 0.0) && fabs(currentDistance) != 1.0)
// exact comparison. An integer should not be expressed as 1.000000000000000000000000001!
{
MITK_DEBUG << "Split consecutive group at index " << dsIndex << " (special case: expected distance 1 exactly)";
groupKey.str(std::string());
groupKey.clear();
groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
}
}
MITK_DEBUG << "Initialize strict distance to currentDistance=" << currentDistance;
constantDistance = currentDistance;
constantDistanceInitialized = true;
}
}
consecutiveGroups[groupKey.str()].push_back(*dataset);
previousDS = *dataset;
}
}
}
else
{
consecutiveGroups = groups;
}
// Step 3: sort all of the groups (not WITHIN each group) by their first frame
/*
build a list-1 of datasets with the first dataset one of each group
sort this list-1
build a new result list-2:
- iterate list-1, for each dataset
- find the group that contains this dataset
- add this group as the next element to list-2
return list-2 as the sorted output
*/
DICOMDatasetList firstSlices;
for (auto gIter = consecutiveGroups.cbegin();
gIter != consecutiveGroups.cend();
++gIter)
{
assert(!gIter->second.empty());
firstSlices.push_back(gIter->second.front());
}
std::sort( firstSlices.begin(), firstSlices.end(), ParameterizedDatasetSort( m_SortCriterion ) );
GroupIDToListType sortedResultBlocks;
unsigned int groupKeyValue(0);
for (auto firstSlice = firstSlices.cbegin();
firstSlice != firstSlices.cend();
++firstSlice)
{
for (auto gIter = consecutiveGroups.cbegin();
gIter != consecutiveGroups.cend();
++groupKeyValue, ++gIter)
{
if (gIter->second.front() == *firstSlice)
{
std::stringstream groupKey;
groupKey << std::setfill('0') << std::setw(6) << groupKeyValue; // try more than 999,999 groups and you are doomed (your application already is)
sortedResultBlocks[groupKey.str()] = gIter->second;
}
}
}
groups = sortedResultBlocks;
}
#ifdef MBILOG_ENABLE_DEBUG
unsigned int groupIndex( 0 );
for ( auto gIter = groups.begin(); gIter != groups.end(); ++groupIndex, ++gIter )
{
DICOMDatasetList& dsList = gIter->second;
MITK_DEBUG << " --------------------------------------------------------------------------------";
MITK_DEBUG << " DICOMTagBasedSorter after sorting group : " << groupIndex;
for ( auto oi = dsList.begin(); oi != dsList.end(); ++oi )
{
MITK_DEBUG << " OUTPUT : " << ( *oi )->GetFilenameIfAvailable();
}
MITK_DEBUG << " --------------------------------------------------------------------------------";
}
#endif // MBILOG_ENABLE_DEBUG
return groups;
}
mitk::DICOMTagBasedSorter::ParameterizedDatasetSort
::ParameterizedDatasetSort(DICOMSortCriterion::ConstPointer criterion)
:m_SortCriterion(criterion)
{
}
bool
mitk::DICOMTagBasedSorter::ParameterizedDatasetSort
::operator() (const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right)
{
assert(left);
assert(right);
assert(m_SortCriterion.IsNotNull());
return m_SortCriterion->IsLeftBeforeRight(left, right);
}
diff --git a/Modules/DICOM/src/mitkDICOMTagsOfInterestAddHelper.cpp b/Modules/DICOM/src/mitkDICOMTagsOfInterestAddHelper.cpp
index 2f6f84d733..affdad8038 100644
--- a/Modules/DICOM/src/mitkDICOMTagsOfInterestAddHelper.cpp
+++ b/Modules/DICOM/src/mitkDICOMTagsOfInterestAddHelper.cpp
@@ -1,118 +1,118 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMTagsOfInterestAddHelper.h"
#include <mitkIDICOMTagsOfInterest.h>
#include "usModuleContext.h"
#include "usGetModuleContext.h"
void mitk::DICOMTagsOfInterestAddHelper::Activate(us::ModuleContext* context, TagsOfInterestVector tags)
{
if (!m_Active && nullptr != context)
{
std::lock_guard<std::mutex> lock(m_Mutex);
m_Active = true;
m_Context = context;
m_TagsOfInterest = tags;
// Listen for events pertaining to dictionary services.
m_Context->AddServiceListener(this, &DICOMTagsOfInterestAddHelper::DICOMTagsOfInterestServiceChanged,
std::string("(&(") + us::ServiceConstants::OBJECTCLASS() + "=" +
us_service_interface_iid<IDICOMTagsOfInterest>() + "))");
// Query for any service references matching any language.
std::vector<us::ServiceReference<IDICOMTagsOfInterest> > refs =
m_Context->GetServiceReferences<IDICOMTagsOfInterest>();
if (!refs.empty())
{
for (const auto& ref : refs)
{
this->RegisterTagsOfInterest(context->GetService(ref));
context->UngetService(ref);
}
}
}
}
void mitk::DICOMTagsOfInterestAddHelper::Deactivate()
{
if (m_Active)
{
std::lock_guard<std::mutex> lock(m_Mutex);
m_Active = false;
if (nullptr != m_Context)
{
try
{
m_Context->RemoveServiceListener(this, &DICOMTagsOfInterestAddHelper::DICOMTagsOfInterestServiceChanged);
}
catch (...)
{
MITK_WARN << "Was not able to remove service listener from module context.";
}
}
}
}
mitk::DICOMTagsOfInterestAddHelper::~DICOMTagsOfInterestAddHelper()
{
if (m_Active)
{
- MITK_ERROR << "DICOMTagsOfInterestAddHelper was not deactivated correctly befor its destructor was called.";
+ MITK_ERROR << "DICOMTagsOfInterestAddHelper was not deactivated correctly before its destructor was called.";
auto context = us::GetModuleContext();
//we cannot trust m_Context at this point anymore and have no means to validate it. So try to get the own module context
//and to remove the listener via this context.
if (nullptr != context)
{
try
{
context->RemoveServiceListener(this, &DICOMTagsOfInterestAddHelper::DICOMTagsOfInterestServiceChanged);
}
catch (...)
{
MITK_WARN << "Was not able to remove service listener from module context.";
}
}
}
}
void mitk::DICOMTagsOfInterestAddHelper::RegisterTagsOfInterest(IDICOMTagsOfInterest* toiService) const
{
if (nullptr != toiService)
{
for (const auto& tag : m_TagsOfInterest)
{
toiService->AddTagOfInterest(tag);
}
}
}
void mitk::DICOMTagsOfInterestAddHelper::DICOMTagsOfInterestServiceChanged(const us::ServiceEvent event)
{
// If a DICOMTagsOfInterestService was registered, register all tags of interest.
if (event.GetType() == us::ServiceEvent::REGISTERED)
{
if (nullptr != m_Context)
{
std::lock_guard<std::mutex> lock(m_Mutex);
// Get a reference to the service object.
us::ServiceReference<IDICOMTagsOfInterest> ref = event.GetServiceReference();
this->RegisterTagsOfInterest(m_Context->GetService(ref));
m_Context->UngetService(ref);
}
else
{
MITK_ERROR << "New DICOMTagsOfInterestService was registered, but no module context exists. Thus, no DICOM tags of interest where added.";
}
}
}
diff --git a/Modules/DICOM/src/mitkEquiDistantBlocksSorter.cpp b/Modules/DICOM/src/mitkEquiDistantBlocksSorter.cpp
index c487257ce0..28f9ab9a7e 100644
--- a/Modules/DICOM/src/mitkEquiDistantBlocksSorter.cpp
+++ b/Modules/DICOM/src/mitkEquiDistantBlocksSorter.cpp
@@ -1,570 +1,570 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
//#define MBILOG_ENABLE_DEBUG
#include "mitkEquiDistantBlocksSorter.h"
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::SliceGroupingAnalysisResult()
{
}
mitk::DICOMDatasetList
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::GetBlockDatasets()
{
return m_GroupedFiles;
}
mitk::DICOMDatasetList
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::GetUnsortedDatasets()
{
return m_UnsortedFiles;
}
bool
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::ContainsGantryTilt()
{
return m_TiltInfo.IsRegularGantryTilt();
}
void
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::AddFileToSortedBlock(DICOMDatasetAccess* dataset)
{
m_GroupedFiles.push_back( dataset );
}
void
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::AddFileToUnsortedBlock(DICOMDatasetAccess* dataset)
{
m_UnsortedFiles.push_back( dataset );
}
void
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::AddFilesToUnsortedBlock(const DICOMDatasetList& datasets)
{
m_UnsortedFiles.insert( m_UnsortedFiles.end(), datasets.begin(), datasets.end() );
}
void
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::SetFirstFilenameOfBlock(const std::string& filename)
{
m_FirstFilenameOfBlock = filename;
}
std::string
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::GetFirstFilenameOfBlock() const
{
return m_FirstFilenameOfBlock;
}
void
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::SetLastFilenameOfBlock(const std::string& filename)
{
m_LastFilenameOfBlock = filename;
}
std::string
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::GetLastFilenameOfBlock() const
{
return m_LastFilenameOfBlock;
}
void
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::FlagGantryTilt(const GantryTiltInformation& tiltInfo)
{
m_TiltInfo = tiltInfo;
}
const mitk::GantryTiltInformation&
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::GetTiltInfo() const
{
return m_TiltInfo;
}
void
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
::UndoPrematureGrouping()
{
assert( !m_GroupedFiles.empty() );
m_UnsortedFiles.insert( m_UnsortedFiles.begin(), m_GroupedFiles.back() );
m_GroupedFiles.pop_back();
m_TiltInfo = GantryTiltInformation();
}
// ------------------------ end helper class
mitk::EquiDistantBlocksSorter
::EquiDistantBlocksSorter()
:DICOMDatasetSorter()
,m_AcceptTilt(false)
,m_ToleratedOriginOffset(0.3)
,m_ToleratedOriginOffsetIsAbsolute(false)
,m_AcceptTwoSlicesGroups(true)
{
}
mitk::EquiDistantBlocksSorter
::EquiDistantBlocksSorter(const EquiDistantBlocksSorter& other )
:DICOMDatasetSorter(other)
,m_AcceptTilt(other.m_AcceptTilt)
,m_ToleratedOriginOffset(other.m_ToleratedOriginOffset)
,m_ToleratedOriginOffsetIsAbsolute(other.m_ToleratedOriginOffsetIsAbsolute)
,m_AcceptTwoSlicesGroups(other.m_AcceptTwoSlicesGroups)
{
}
mitk::EquiDistantBlocksSorter
::~EquiDistantBlocksSorter()
{
}
bool
mitk::EquiDistantBlocksSorter
::operator==(const DICOMDatasetSorter& other) const
{
if (const auto* otherSelf = dynamic_cast<const EquiDistantBlocksSorter*>(&other))
{
return this->m_AcceptTilt == otherSelf->m_AcceptTilt
&& this->m_ToleratedOriginOffsetIsAbsolute == otherSelf->m_ToleratedOriginOffsetIsAbsolute
&& this->m_AcceptTwoSlicesGroups == otherSelf->m_AcceptTwoSlicesGroups
&& (fabs(this->m_ToleratedOriginOffset - otherSelf->m_ToleratedOriginOffset) < eps);
}
else
{
return false;
}
}
void
mitk::EquiDistantBlocksSorter
::PrintConfiguration(std::ostream& os, const std::string& indent) const
{
std::stringstream ts;
if (!m_ToleratedOriginOffsetIsAbsolute)
{
ts << "adaptive";
}
else
{
ts << m_ToleratedOriginOffset << "mm";
}
os << indent << "Sort into blocks of equidistant, well-aligned (tolerance "
<< ts.str() << ") slices "
<< (m_AcceptTilt ? "(accepting a gantry tilt)" : "")
<< std::endl;
}
void
mitk::EquiDistantBlocksSorter
::SetAcceptTilt(bool accept)
{
m_AcceptTilt = accept;
}
bool
mitk::EquiDistantBlocksSorter
::GetAcceptTilt() const
{
return m_AcceptTilt;
}
void
mitk::EquiDistantBlocksSorter
::SetAcceptTwoSlicesGroups(bool accept)
{
m_AcceptTwoSlicesGroups = accept;
}
bool
mitk::EquiDistantBlocksSorter
::GetAcceptTwoSlicesGroups() const
{
return m_AcceptTwoSlicesGroups;
}
mitk::EquiDistantBlocksSorter&
mitk::EquiDistantBlocksSorter
::operator=(const EquiDistantBlocksSorter& other)
{
if (this != &other)
{
DICOMDatasetSorter::operator=(other);
m_AcceptTilt = other.m_AcceptTilt;
m_ToleratedOriginOffset = other.m_ToleratedOriginOffset;
m_ToleratedOriginOffsetIsAbsolute = other.m_ToleratedOriginOffsetIsAbsolute;
m_AcceptTwoSlicesGroups = other.m_AcceptTwoSlicesGroups;
}
return *this;
}
mitk::DICOMTagList
mitk::EquiDistantBlocksSorter
::GetTagsOfInterest()
{
DICOMTagList tags;
tags.push_back( DICOMTag(0x0020, 0x0032) ); // ImagePositionPatient
tags.push_back( DICOMTag(0x0020, 0x0037) ); // ImageOrientationPatient
tags.push_back( DICOMTag(0x0018, 0x1120) ); // GantryDetectorTilt
return tags;
}
void
mitk::EquiDistantBlocksSorter
::Sort()
{
DICOMDatasetList remainingInput = GetInput(); // copy
typedef std::list<DICOMDatasetList> OutputListType;
OutputListType outputs;
m_SliceGroupingResults.clear();
while (!remainingInput.empty()) // repeat until all files are grouped somehow
{
SliceGroupingAnalysisResult regularBlock = this->AnalyzeFileForITKImageSeriesReaderSpacingAssumption( remainingInput, m_AcceptTilt );
#ifdef MBILOG_ENABLE_DEBUG
DICOMDatasetList inBlock = regularBlock.GetBlockDatasets();
DICOMDatasetList laterBlock = regularBlock.GetUnsortedDatasets();
MITK_DEBUG << "Result: sorted 3D group with " << inBlock.size() << " files";
for (DICOMDatasetList::const_iterator diter = inBlock.cbegin(); diter != inBlock.cend(); ++diter)
MITK_DEBUG << " IN " << (*diter)->GetFilenameIfAvailable();
for (DICOMDatasetList::const_iterator diter = laterBlock.cbegin(); diter != laterBlock.cend(); ++diter)
MITK_DEBUG << " OUT " << (*diter)->GetFilenameIfAvailable();
#endif // MBILOG_ENABLE_DEBUG
outputs.push_back( regularBlock.GetBlockDatasets() );
m_SliceGroupingResults.push_back( regularBlock );
remainingInput = regularBlock.GetUnsortedDatasets();
}
unsigned int numberOfOutputs = outputs.size();
this->SetNumberOfOutputs(numberOfOutputs);
unsigned int outputIndex(0);
for (auto oIter = outputs.cbegin();
oIter != outputs.cend();
++outputIndex, ++oIter)
{
this->SetOutput(outputIndex, *oIter);
}
}
void
mitk::EquiDistantBlocksSorter
::SetToleratedOriginOffsetToAdaptive(double fractionOfInterSliceDistance)
{
m_ToleratedOriginOffset = fractionOfInterSliceDistance;
m_ToleratedOriginOffsetIsAbsolute = false;
if (m_ToleratedOriginOffset < 0.0)
{
MITK_WARN << "Call SetToleratedOriginOffsetToAdaptive() only with positive numbers between 0.0 and 1.0, read documentation!";
}
if (m_ToleratedOriginOffset > 0.5)
{
- MITK_WARN << "EquiDistantBlocksSorter is now accepting large errors, take care of measurements, they could appear at unprecise locations!";
+ MITK_WARN << "EquiDistantBlocksSorter is now accepting large errors, take care of measurements, they could appear at imprecise locations!";
}
}
void
mitk::EquiDistantBlocksSorter
::SetToleratedOriginOffset(double millimeters)
{
m_ToleratedOriginOffset = millimeters;
m_ToleratedOriginOffsetIsAbsolute = true;
if (m_ToleratedOriginOffset < 0.0)
{
MITK_WARN << "Negative tolerance set to SetToleratedOriginOffset()!";
}
}
double
mitk::EquiDistantBlocksSorter
::GetToleratedOriginOffset() const
{
return m_ToleratedOriginOffset;
}
bool
mitk::EquiDistantBlocksSorter
::IsToleratedOriginOffsetAbsolute() const
{
return m_ToleratedOriginOffsetIsAbsolute;
}
std::string
mitk::EquiDistantBlocksSorter
::ConstCharStarToString(const char* s)
{
return s ? std::string(s) : std::string();
}
mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
mitk::EquiDistantBlocksSorter
::AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
const DICOMDatasetList& datasets,
bool groupImagesWithGantryTilt)
{
// result.first = files that fit ITK's assumption
// result.second = files that do not fit, should be run through AnalyzeFileForITKImageSeriesReaderSpacingAssumption() again
SliceGroupingAnalysisResult result;
const DICOMTag tagImagePositionPatient = DICOMTag(0x0020,0x0032); // Image Position (Patient)
const DICOMTag tagImageOrientation = DICOMTag(0x0020, 0x0037); // Image Orientation
Vector3D fromFirstToSecondOrigin; fromFirstToSecondOrigin.Fill(0.0);
bool fromFirstToSecondOriginInitialized(false);
Point3D thisOrigin;
thisOrigin.Fill(0.0f);
Point3D lastOrigin;
lastOrigin.Fill(0.0f);
Point3D lastDifferentOrigin;
lastDifferentOrigin.Fill(0.0f);
bool lastOriginInitialized(false);
MITK_DEBUG << "--------------------------------------------------------------------------------";
MITK_DEBUG << "Analyzing " << datasets.size() << " files for z-spacing assumption of ITK's ImageSeriesReader (group tilted: " << groupImagesWithGantryTilt << ")";
unsigned int fileIndex(0);
double toleratedOriginError(0.005); // default: max. 1/10mm error when measurement crosses 20 slices in z direction (too strict? we don't know better)
for (auto dsIter = datasets.cbegin();
dsIter != datasets.cend();
++dsIter, ++fileIndex)
{
bool fileFitsIntoPattern(false);
std::string thisOriginString;
// Read tag value into point3D. PLEASE replace this by appropriate GDCM code if you figure out how to do that
thisOriginString = (*dsIter)->GetTagValueAsString(tagImagePositionPatient).value;
if (thisOriginString.empty())
{
// don't let such files be in a common group. Everything without position information will be loaded as a single slice:
// with standard DICOM files this can happen to: CR, DX, SC
MITK_DEBUG << " ==> Sort away " << *dsIter << " for later analysis (no position information)"; // we already have one occupying this position
if ( result.GetBlockDatasets().empty() ) // nothing WITH position information yet
{
// ==> this is a group of its own, stop processing, come back later
result.AddFileToSortedBlock( *dsIter );
DICOMDatasetList remainingFiles;
remainingFiles.insert( remainingFiles.end(), dsIter+1, datasets.end() );
result.AddFilesToUnsortedBlock( remainingFiles );
fileFitsIntoPattern = false;
break; // no files anymore
}
else
{
// ==> this does not match, consider later
result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
fileFitsIntoPattern = false;
continue; // next file
}
}
bool ignoredConversionError(-42); // hard to get here, no graceful way to react
thisOrigin = DICOMStringToPoint3D( thisOriginString, ignoredConversionError );
MITK_DEBUG << " " << fileIndex << " " << (*dsIter)->GetFilenameIfAvailable()
<< " at "
/* << thisOriginString */ << "(" << thisOrigin[0] << "," << thisOrigin[1] << "," << thisOrigin[2] << ")";
if ( lastOriginInitialized && (thisOrigin == lastOrigin) )
{
MITK_DEBUG << " ==> Sort away " << *dsIter << " for separate time step"; // we already have one occupying this position
result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
fileFitsIntoPattern = false;
}
else
{
if (!fromFirstToSecondOriginInitialized && lastOriginInitialized) // calculate vector as soon as possible when we get a new position
{
fromFirstToSecondOrigin = thisOrigin - lastDifferentOrigin;
fromFirstToSecondOriginInitialized = true;
// classic mode without tolerance!
if (!m_ToleratedOriginOffsetIsAbsolute)
{
MITK_DEBUG << "Distance of two slices: " << fromFirstToSecondOrigin.GetNorm() << "mm";
toleratedOriginError =
fromFirstToSecondOrigin.GetNorm() * 0.3; // a third of the slice distance
// (less than half, which would mean that a slice is displayed where another slice should actually be)
}
else
{
toleratedOriginError = m_ToleratedOriginOffset;
}
MITK_DEBUG << "Accepting errors in actual versus expected origin up to " << toleratedOriginError << "mm";
// Here we calculate if this slice and the previous one are well aligned,
// i.e. we test if the previous origin is on a line through the current
// origin, directed into the normal direction of the current slice.
// If this is NOT the case, then we have a data set with a TILTED GANTRY geometry,
// which cannot be simply loaded into a single mitk::Image at the moment.
// For this case, we flag this finding in the result and DicomSeriesReader
// can correct for that later.
Vector3D right; right.Fill(0.0);
Vector3D up; right.Fill(0.0); // might be down as well, but it is just a name at this point
std::string orientationValue = (*dsIter)->GetTagValueAsString( tagImageOrientation ).value;
DICOMStringToOrientationVectors( orientationValue, right, up, ignoredConversionError );
GantryTiltInformation tiltInfo( lastDifferentOrigin, thisOrigin, right, up, 1 );
if ( tiltInfo.IsSheared() )
{
/* optimistic approach, accepting gantry tilt: save file for later, check all further files */
// at this point we have TWO slices analyzed! if they are the only two files, we still split, because there is no third to verify our tilting assumption.
// later with a third being available, we must check if the initial tilting vector is still valid. if yes, continue.
// if NO, we need to split the already sorted part (result.first) and the currently analyzed file (*dsIter)
// tell apart gantry tilt from overall skewedness
// sort out irregularly sheared slices, that IS NOT tilting
if ( groupImagesWithGantryTilt && tiltInfo.IsRegularGantryTilt() )
{
assert(!datasets.empty());
result.FlagGantryTilt(tiltInfo);
result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
result.SetFirstFilenameOfBlock( datasets.front()->GetFilenameIfAvailable() );
result.SetLastFilenameOfBlock( datasets.back()->GetFilenameIfAvailable() );
fileFitsIntoPattern = true;
}
else // caller does not want tilt compensation OR shearing is more complicated than tilt
{
result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
fileFitsIntoPattern = false;
}
}
else // not sheared
{
result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
fileFitsIntoPattern = true;
}
}
else if (fromFirstToSecondOriginInitialized) // we already know the offset between slices
{
Point3D assumedOrigin = lastDifferentOrigin + fromFirstToSecondOrigin;
Vector3D originError = assumedOrigin - thisOrigin;
double norm = originError.GetNorm();
if (norm > toleratedOriginError)
{
MITK_DEBUG << " File does not fit into the inter-slice distance pattern (diff = "
<< norm << ", allowed "
<< toleratedOriginError << ").";
MITK_DEBUG << " Expected position (" << assumedOrigin[0] << ","
<< assumedOrigin[1] << ","
<< assumedOrigin[2] << "), got position ("
<< thisOrigin[0] << ","
<< thisOrigin[1] << ","
<< thisOrigin[2] << ")";
MITK_DEBUG << " ==> Sort away " << *dsIter << " for later analysis";
// At this point we know we deviated from the expectation of ITK's ImageSeriesReader
// We split the input file list at this point, i.e. all files up to this one (excluding it)
// are returned as group 1, the remaining files (including the faulty one) are group 2
/* Optimistic approach: check if any of the remaining slices fits in */
result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
fileFitsIntoPattern = false;
}
else
{
result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
fileFitsIntoPattern = true;
}
}
else // this should be the very first slice
{
result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
fileFitsIntoPattern = true;
}
}
// record current origin for reference in later iterations
if ( !lastOriginInitialized || ( fileFitsIntoPattern && (thisOrigin != lastOrigin) ) )
{
lastDifferentOrigin = thisOrigin;
}
lastOrigin = thisOrigin;
lastOriginInitialized = true;
}
if ( result.ContainsGantryTilt() )
{
// check here how many files were grouped.
// IF it was only two files AND we assume tiltedness (e.g. save "distance")
// THEN we would want to also split the two previous files (simple) because
// we don't have any reason to assume they belong together
// Above behavior can be configured via m_AcceptTwoSlicesGroups, the default being "do accept"
if ( result.GetBlockDatasets().size() == 2 && !m_AcceptTwoSlicesGroups )
{
result.UndoPrematureGrouping();
}
}
// update tilt info to get maximum precision
// earlier, tilt was only calculated from first and second slice.
// now that we know the whole range, we can re-calculate using the very first and last slice
if ( result.ContainsGantryTilt() && result.GetBlockDatasets().size() > 1 )
{
try
{
DICOMDatasetList datasets = result.GetBlockDatasets();
DICOMDatasetAccess* firstDataset = datasets.front();
DICOMDatasetAccess* lastDataset = datasets.back();
unsigned int numberOfSlicesApart = datasets.size() - 1;
std::string orientationString = firstDataset->GetTagValueAsString( tagImageOrientation ).value;
std::string firstOriginString = firstDataset->GetTagValueAsString( tagImagePositionPatient ).value;
std::string lastOriginString = lastDataset->GetTagValueAsString( tagImagePositionPatient ).value;
result.FlagGantryTilt( GantryTiltInformation::MakeFromTagValues( firstOriginString, lastOriginString, orientationString, numberOfSlicesApart ));
}
catch (...)
{
// just do not flag anything, we are ok
}
}
return result;
}
diff --git a/Modules/DICOM/src/mitkThreeDnTDICOMSeriesReader.cpp b/Modules/DICOM/src/mitkThreeDnTDICOMSeriesReader.cpp
index ed8a80528e..a8245c16df 100644
--- a/Modules/DICOM/src/mitkThreeDnTDICOMSeriesReader.cpp
+++ b/Modules/DICOM/src/mitkThreeDnTDICOMSeriesReader.cpp
@@ -1,264 +1,264 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkThreeDnTDICOMSeriesReader.h"
#include "mitkITKDICOMSeriesReaderHelper.h"
mitk::ThreeDnTDICOMSeriesReader
::ThreeDnTDICOMSeriesReader(unsigned int decimalPlacesForOrientation)
:DICOMITKSeriesGDCMReader(decimalPlacesForOrientation)
,m_Group3DandT(m_DefaultGroup3DandT), m_OnlyCondenseSameSeries(m_DefaultOnlyCondenseSameSeries)
{
}
mitk::ThreeDnTDICOMSeriesReader
::ThreeDnTDICOMSeriesReader(const ThreeDnTDICOMSeriesReader& other )
:DICOMITKSeriesGDCMReader(other)
,m_Group3DandT(m_DefaultGroup3DandT), m_OnlyCondenseSameSeries(m_DefaultOnlyCondenseSameSeries)
{
}
mitk::ThreeDnTDICOMSeriesReader
::~ThreeDnTDICOMSeriesReader()
{
}
mitk::ThreeDnTDICOMSeriesReader&
mitk::ThreeDnTDICOMSeriesReader
::operator=(const ThreeDnTDICOMSeriesReader& other)
{
if (this != &other)
{
DICOMITKSeriesGDCMReader::operator=(other);
this->m_Group3DandT = other.m_Group3DandT;
}
return *this;
}
bool
mitk::ThreeDnTDICOMSeriesReader
::operator==(const DICOMFileReader& other) const
{
if (const auto* otherSelf = dynamic_cast<const Self*>(&other))
{
return
DICOMITKSeriesGDCMReader::operator==(other)
&& this->m_Group3DandT == otherSelf->m_Group3DandT;
}
else
{
return false;
}
}
void
mitk::ThreeDnTDICOMSeriesReader
::SetGroup3DandT(bool on)
{
m_Group3DandT = on;
}
bool
mitk::ThreeDnTDICOMSeriesReader
::GetGroup3DandT() const
{
return m_Group3DandT;
}
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);
const DICOMTag tagSeriesInstaceUID(0x0020, 0x000e);
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;
const auto currentBlockSeriesInstanceUID = firstBlock.back()->GetTagValueAsString(tagSeriesInstaceUID).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;
const auto otherBlockSeriesInstanceUID = otherBlock.back()->GetTagValueAsString(tagSeriesInstaceUID).value;
// add matching blocks to current3DnTBlock
// keep other blocks for later
if ( otherBlockNumberOfSlices == currentBlockNumberOfSlices
&& (!m_OnlyCondenseSameSeries || otherBlockSeriesInstanceUID == currentBlockSeriesInstanceUID)
&& 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
+ // in any case, we now know all about the first block of our list ...
+ // ... and we either 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;
}
bool
mitk::ThreeDnTDICOMSeriesReader
::LoadImages()
{
bool success = true;
unsigned int numberOfOutputs = this->GetNumberOfOutputs();
for (unsigned int o = 0; o < numberOfOutputs; ++o)
{
const DICOMImageBlockDescriptor& block = this->InternalGetOutput(o);
if (block.GetFlag("3D+t", false))
{
success &= this->LoadMitkImageForOutput(o);
}
else
{
success &= DICOMITKSeriesGDCMReader::LoadMitkImageForOutput(o); // let superclass handle non-3D+t
}
}
return success;
}
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;
}
diff --git a/Modules/DICOM/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp b/Modules/DICOM/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp
index e7dd37f559..d35028065e 100644
--- a/Modules/DICOM/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp
+++ b/Modules/DICOM/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp
@@ -1,121 +1,121 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkDICOMITKSeriesGDCMReader.h"
#include "mitkDICOMFileReaderTestHelper.h"
#include "mitkDICOMFilenameSorter.h"
#include "mitkDICOMTagBasedSorter.h"
#include "mitkDICOMSortByTag.h"
#include "mitkTestingMacros.h"
#include <unordered_map>
#include "mitkStringProperty.h"
using mitk::DICOMTag;
int mitkDICOMITKSeriesGDCMReaderBasicsTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkDICOMITKSeriesGDCMReaderBasicsTest");
mitk::DICOMITKSeriesGDCMReader::Pointer gdcmReader = mitk::DICOMITKSeriesGDCMReader::New();
MITK_TEST_CONDITION_REQUIRED(gdcmReader.IsNotNull(), "DICOMITKSeriesGDCMReader can be instantiated.");
mitk::DICOMFileReaderTestHelper::SetTestInputFilenames( argc,argv );
std::unordered_map<std::string, std::string> expectedPropertyTypes;
mitk::DICOMITKSeriesGDCMReader::AdditionalTagsMapType additionalTags;
additionalTags.insert( std::make_pair(DICOMTag( 0x0008, 0x0005 ), "Test1") );
additionalTags.insert( std::make_pair(DICOMTag( 0x0008, 0x0060 ), "Test2") );
additionalTags.insert( std::make_pair(DICOMTag( 0x0020, 0x1041 ), "Test3") );
gdcmReader->SetAdditionalTagsOfInterest( additionalTags );
// check the Set/GetInput function
mitk::DICOMFileReaderTestHelper::TestInputFilenames( gdcmReader );
// check that output is a good reproduction of input (no duplicates, no new elements)
mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
// repeat test with filename based sorter in-between
mitk::DICOMFilenameSorter::Pointer filenameSorter = mitk::DICOMFilenameSorter::New();
gdcmReader->AddSortingElement( filenameSorter );
mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
// repeat test with some more realistic sorting
gdcmReader = mitk::DICOMITKSeriesGDCMReader::New(); // this also tests destruction
mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
// all the things that split by tag in DicomSeriesReader
tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0010) ); // Number of Rows
tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0011) ); // Number of Columns
tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0037), new mitk::DICOMTagBasedSorter::CutDecimalPlaces(5) ); // Image Orientation (Patient)
tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x000e) ); // Series Instance UID
tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x0050) ); // Slice Thickness
tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0008) ); // Number of Frames
tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
// a sorter...
mitk::DICOMSortCriterion::ConstPointer sorting =
mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0013), // instance number
- mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0012), // aqcuisition number
- mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0032), // aqcuisition time
+ mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0012), // acquisition number
+ mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0032), // acquisition time
mitk::DICOMSortByTag::New( DICOMTag(0x0018, 0x1060), // trigger time
mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
).GetPointer()
).GetPointer()
).GetPointer()
).GetPointer()
).GetPointer();
tagSorter->SetSortCriterion( sorting );
gdcmReader->AddSortingElement( tagSorter );
gdcmReader->SetAdditionalTagsOfInterest( additionalTags );
mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
gdcmReader->PrintOutputs(std::cout, true);
// really load images
mitk::DICOMFileReaderTestHelper::TestMitkImagesAreLoaded( gdcmReader, additionalTags, expectedPropertyTypes );
//////////////////////////////////////////////////////////////////////////
//
// Load the images again with another TagLookupTableToPropertyFunctor
//
//////////////////////////////////////////////////////////////////////////
gdcmReader->SetTagLookupTableToPropertyFunctor( []( const mitk::DICOMCachedValueLookupTable& table )
{
return static_cast<mitk::BaseProperty::Pointer>( mitk::StringProperty::New( table.GetTableValue(0).Value ) );
} );
expectedPropertyTypes.insert(std::make_pair("Test1", "StringProperty"));
expectedPropertyTypes.insert(std::make_pair("Test2", "StringProperty"));
expectedPropertyTypes.insert(std::make_pair("Test3", "StringProperty"));
mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
gdcmReader->PrintOutputs(std::cout, true);
// really load images
mitk::DICOMFileReaderTestHelper::TestMitkImagesAreLoaded( gdcmReader, additionalTags, expectedPropertyTypes );
MITK_TEST_END();
}
diff --git a/Modules/DICOMTesting/src/mitkTestDICOMLoading.cpp b/Modules/DICOMTesting/src/mitkTestDICOMLoading.cpp
index d6a44162f7..f20a80829b 100644
--- a/Modules/DICOMTesting/src/mitkTestDICOMLoading.cpp
+++ b/Modules/DICOMTesting/src/mitkTestDICOMLoading.cpp
@@ -1,585 +1,585 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
//#define MBILOG_ENABLE_DEBUG
#include "mitkTestDICOMLoading.h"
#include "mitkDICOMIOMetaInformationPropertyConstants.h"
#include "mitkDICOMProperty.h"
#include "mitkArbitraryTimeGeometry.h"
#include <stack>
#include <gdcmVersion.h>
#include <dcmtk/config/osconfig.h>
#include "itksys/SystemTools.hxx"
mitk::TestDICOMLoading::TestDICOMLoading()
:m_PreviousCLocale(nullptr)
{
}
void mitk::TestDICOMLoading::SetDefaultLocale()
{
// remember old locale only once
if (m_PreviousCLocale == nullptr)
{
m_PreviousCLocale = setlocale(LC_NUMERIC, nullptr);
// set to "C"
setlocale(LC_NUMERIC, "C");
m_PreviousCppLocale = std::cin.getloc();
std::locale l( "C" );
std::cin.imbue(l);
std::cout.imbue(l);
}
}
void mitk::TestDICOMLoading::ResetUserLocale()
{
if (m_PreviousCLocale)
{
setlocale(LC_NUMERIC, m_PreviousCLocale);
std::cin.imbue(m_PreviousCppLocale);
std::cout.imbue(m_PreviousCppLocale);
m_PreviousCLocale = nullptr;
}
}
mitk::TestDICOMLoading::ImageList
mitk::TestDICOMLoading
::LoadFiles( const StringList& files )
{
for (auto iter = files.begin();
iter != files.end();
++iter)
{
MITK_DEBUG << "File " << *iter;
}
ImageList result;
ClassicDICOMSeriesReader::Pointer reader = this->BuildDICOMReader();
reader->SetTagLookupTableToPropertyFunctor(mitk::GetDICOMPropertyForDICOMValuesFunctor);
reader->SetInputFiles( files );
reader->AnalyzeInputFiles();
reader->PrintOutputs(std::cout,true);
reader->LoadImages();
unsigned int numberOfImages = reader->GetNumberOfOutputs();
for (unsigned imageIndex = 0; imageIndex < numberOfImages; ++imageIndex)
{
const DICOMImageBlockDescriptor& block = reader->GetOutput(imageIndex);
result.push_back( block.GetMitkImage() );
}
return result;
}
mitk::ClassicDICOMSeriesReader::Pointer
mitk::TestDICOMLoading
::BuildDICOMReader()
{
ClassicDICOMSeriesReader::Pointer reader = ClassicDICOMSeriesReader::New();
reader->SetFixTiltByShearing(true);
return reader;
}
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->SetTagLookupTableToPropertyFunctor(mitk::GetDICOMPropertyForDICOMValuesFunctor);
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();
}
std::string
mitk::TestDICOMLoading::ComponentTypeToString(itk::IOComponentEnum type)
{
if (type == itk::IOComponentEnum::UCHAR)
return "UCHAR";
else if (type == itk::IOComponentEnum::CHAR)
return "CHAR";
else if (type == itk::IOComponentEnum::USHORT)
return "USHORT";
else if (type == itk::IOComponentEnum::SHORT)
return "SHORT";
else if (type == itk::IOComponentEnum::UINT)
return "UINT";
else if (type == itk::IOComponentEnum::INT)
return "INT";
else if (type == itk::IOComponentEnum::ULONG)
return "ULONG";
else if (type == itk::IOComponentEnum::LONG)
return "LONG";
else if (type == itk::IOComponentEnum::FLOAT)
return "FLOAT";
else if (type == itk::IOComponentEnum::DOUBLE)
return "DOUBLE";
else
return "UNKNOWN";
}
// add a line to stringstream result (see DumpImageInformation
#define DumpLine(field, data) DumpILine(0, field, data)
// add an indented(!) line to stringstream result (see DumpImageInformation
#define DumpILine(indent, field, data) \
{ \
std::string DumpLine_INDENT; DumpLine_INDENT.resize(indent, ' ' ); \
result << DumpLine_INDENT << field << ": " << data << "\n"; \
}
std::string
mitk::TestDICOMLoading::DumpImageInformation( const Image* image )
{
std::stringstream result;
if (image == nullptr) return result.str();
SetDefaultLocale();
// basic image data
DumpLine( "Pixeltype", ComponentTypeToString(image->GetPixelType().GetComponentType()) );
DumpLine( "BitsPerPixel", image->GetPixelType().GetBpe() );
DumpLine( "Dimension", image->GetDimension() );
result << "Dimensions: ";
for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
result << image->GetDimension(dim) << " ";
result << "\n";
// geometry data
result << "Geometry: \n";
const TimeGeometry* timeGeometry = image->GetTimeGeometry();
BaseGeometry* geometry = timeGeometry->GetGeometryForTimeStep(0);
if (geometry)
{
AffineTransform3D* transform = geometry->GetIndexToWorldTransform();
if (transform)
{
result << " " << "Matrix: ";
const AffineTransform3D::MatrixType& matrix = transform->GetMatrix();
for (unsigned int i = 0; i < 3; ++i)
for (unsigned int j = 0; j < 3; ++j)
result << matrix[i][j] << " ";
result << "\n";
result << " " << "Offset: ";
const AffineTransform3D::OutputVectorType& offset = transform->GetOffset();
for (unsigned int i = 0; i < 3; ++i)
result << offset[i] << " ";
result << "\n";
result << " " << "Center: ";
const AffineTransform3D::InputPointType& center = transform->GetCenter();
for (unsigned int i = 0; i < 3; ++i)
result << center[i] << " ";
result << "\n";
result << " " << "Translation: ";
const AffineTransform3D::OutputVectorType& translation = transform->GetTranslation();
for (unsigned int i = 0; i < 3; ++i)
result << translation[i] << " ";
result << "\n";
result << " " << "Scale: ";
const double* scale = transform->GetScale();
for (unsigned int i = 0; i < 3; ++i)
result << scale[i] << " ";
result << "\n";
result << " " << "Origin: ";
const Point3D& origin = geometry->GetOrigin();
for (unsigned int i = 0; i < 3; ++i)
result << origin[i] << " ";
result << "\n";
result << " " << "Spacing: ";
const Vector3D& spacing = geometry->GetSpacing();
for (unsigned int i = 0; i < 3; ++i)
result << spacing[i] << " ";
result << "\n";
result << " " << "TimeBounds: ";
///////////////////////////////////////
- // Workarround T27883. See https://phabricator.mitk.org/T27883#219473 for more details.
- // This workarround should be removed as soon as T28262 is solved!
+ // Workaround T27883. See https://phabricator.mitk.org/T27883#219473 for more details.
+ // This workaround should be removed as soon as T28262 is solved!
TimeBounds timeBounds = timeGeometry->GetTimeBounds();
auto atg = dynamic_cast<const mitk::ArbitraryTimeGeometry*>(timeGeometry);
if (atg && atg->HasCollapsedFinalTimeStep())
{
timeBounds[1] = timeBounds[1] - 1.;
}
//Original code:
//const TimeBounds timeBounds = timeGeometry->GetTimeBounds();
//
- // End of workarround for T27883
+ // End of workaround for T27883
//////////////////////////////////////
for (unsigned int i = 0; i < 2; ++i)
result << timeBounds[i] << " ";
result << "\n";
}
}
// io dicom meta information
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_CONFIGURATION(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_FILES(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_GANTRY_TILT_CORRECTED(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL_STRING(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION_STRING(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_3D_plus_t(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_DCMTK(), image, result);
AddPropertyToDump(mitk::DICOMIOMetaInformationPropertyConstants::READER_GDCM(), image, result);
ResetUserLocale();
return result.str();
}
void mitk::TestDICOMLoading::AddPropertyToDump(const mitk::PropertyKeyPath& key, const mitk::Image* image, std::stringstream& result)
{
auto propKey = mitk::PropertyKeyPathToPropertyName(key);
auto prop = image->GetProperty(propKey.c_str());
if (prop.IsNotNull())
{
auto value = prop->GetValueAsString();
auto dicomProp = dynamic_cast< mitk::DICOMProperty*>(prop.GetPointer());
if (dicomProp != nullptr)
{
auto strippedProp = dicomProp->Clone();
if (key == mitk::DICOMIOMetaInformationPropertyConstants::READER_FILES())
{//strip dicom file information from path to ensure generalized dump files
auto timePoints = strippedProp->GetAvailableTimeSteps();
for (auto timePoint : timePoints)
{
auto slices = strippedProp->GetAvailableSlices(timePoint);
for (auto slice : slices)
{
auto value = strippedProp->GetValue(timePoint, slice);
value = itksys::SystemTools::GetFilenameName(value);
strippedProp->SetValue(timePoint, slice, value);
}
}
}
value = mitk::PropertyPersistenceSerialization::serializeTemporoSpatialStringPropertyToJSON(strippedProp);
}
result << propKey << ": " << value << "\n";
}
}
std::string
mitk::TestDICOMLoading::trim(const std::string& pString,
const std::string& pWhitespace)
{
const size_t beginStr = pString.find_first_not_of(pWhitespace);
if (beginStr == std::string::npos)
{
// no content
return "";
}
const size_t endStr = pString.find_last_not_of(pWhitespace);
const size_t range = endStr - beginStr + 1;
return pString.substr(beginStr, range);
}
std::string
mitk::TestDICOMLoading::reduce(const std::string& pString,
const std::string& pFill,
const std::string& pWhitespace)
{
// trim first
std::string result(trim(pString, pWhitespace));
// replace sub ranges
size_t beginSpace = result.find_first_of(pWhitespace);
while (beginSpace != std::string::npos)
{
const size_t endSpace =
result.find_first_not_of(pWhitespace, beginSpace);
const size_t range = endSpace - beginSpace;
result.replace(beginSpace, range, pFill);
const size_t newStart = beginSpace + pFill.length();
beginSpace = result.find_first_of(pWhitespace, newStart);
}
return result;
}
bool
mitk::TestDICOMLoading::CompareSpacedValueFields( const std::string& reference,
const std::string& test,
double /*eps*/ )
{
bool result(true);
// tokenize string, compare each token, if possible by float comparison
std::stringstream referenceStream(reduce(reference));
std::stringstream testStream(reduce(test));
std::string refToken;
std::string testToken;
while ( std::getline( referenceStream, refToken, ' ' ) &&
std::getline ( testStream, testToken, ' ' ) )
{
float refNumber;
float testNumber;
if ( this->StringToNumber(refToken, refNumber) )
{
if ( this->StringToNumber(testToken, testNumber) )
{
// print-out compared tokens if DEBUG output allowed
MITK_DEBUG << "Reference Token '" << refToken << "'" << " value " << refNumber
<< ", test Token '" << testToken << "'" << " value " << testNumber;
bool old_result = result;
result &= ( std::abs(refNumber - testNumber) < 0.0001f /*mitk::eps*/ );
// log the token/number which causes the test to fail
if( old_result != result)
{
MITK_ERROR << std::setprecision(16) << "Reference Token '" << refToken << "'" << " value " << refNumber
<< ", test Token '" << testToken << "'" << " value " << testNumber;
MITK_ERROR << "[FALSE] - difference: " << std::setprecision(16) << std::abs(refNumber - testNumber) << " EPS: " << 0.0001f; //mitk::eps;
}
}
else
{
MITK_ERROR << refNumber << " cannot be compared to '" << testToken << "'";
}
}
else
{
MITK_DEBUG << "Token '" << refToken << "'" << " handled as string";
result &= refToken == testToken;
}
}
if ( std::getline( referenceStream, refToken, ' ' ) )
{
MITK_ERROR << "Reference string still had values when test string was already parsed: ref '" << reference << "', test '" << test << "'";
result = false;
}
else if ( std::getline( testStream, testToken, ' ' ) )
{
MITK_ERROR << "Test string still had values when reference string was already parsed: ref '" << reference << "', test '" << test << "'";
result = false;
}
return result;
}
bool
mitk::TestDICOMLoading::CompareImageInformationDumps( const std::string& referenceDump,
const std::string& testDump )
{
KeyValueMap reference = ParseDump(referenceDump);
KeyValueMap test = ParseDump(testDump);
bool testResult(true);
// verify all expected values
for (KeyValueMap::const_iterator refIter = reference.begin();
refIter != reference.end();
++refIter)
{
const std::string& refKey = refIter->first;
const std::string& refValue = refIter->second;
if ( test.find(refKey) != test.end() )
{
const std::string& testValue = test[refKey];
if (refKey == mitk::PropertyKeyPathToPropertyName(mitk::DICOMIOMetaInformationPropertyConstants::READER_DCMTK()))
{ //check dcmtk version always against the current version of the system
bool thisTestResult = testValue == std::string(" ") + PACKAGE_VERSION;
testResult &= thisTestResult;
MITK_DEBUG << refKey << ": '" << PACKAGE_VERSION << "' == '" << testValue << "' ? " << (thisTestResult ? "YES" : "NO");
}
else if (refKey == mitk::PropertyKeyPathToPropertyName(mitk::DICOMIOMetaInformationPropertyConstants::READER_GDCM()))
{//check gdcm version always against the current version of the system
bool thisTestResult = testValue == std::string(" ") + gdcm::Version::GetVersion();
testResult &= thisTestResult;
MITK_DEBUG << refKey << ": '" << gdcm::Version::GetVersion() << "' == '" << testValue << "' ? " << (thisTestResult ? "YES" : "NO");
}
else
{
bool thisTestResult = CompareSpacedValueFields(refValue, testValue);
testResult &= thisTestResult;
MITK_DEBUG << refKey << ": '" << refValue << "' == '" << testValue << "' ? " << (thisTestResult ? "YES" : "NO");
}
}
else
{
MITK_ERROR << "Reference dump contains a key'" << refKey << "' (value '" << refValue << "')." ;
MITK_ERROR << "This key is expected to be generated for tests (but was not). Most probably you need to update your test data.";
return false;
}
}
// now check test dump does not contain any additional keys
for (KeyValueMap::const_iterator testIter = test.begin();
testIter != test.end();
++testIter)
{
const std::string& key = testIter->first;
const std::string& value = testIter->second;
if (key == mitk::PropertyKeyPathToPropertyName(mitk::DICOMIOMetaInformationPropertyConstants::READER_DCMTK()))
{//check dcmtk version always against the current version of the system
bool thisTestResult = value == std::string(" ")+PACKAGE_VERSION;
testResult &= thisTestResult;
MITK_DEBUG << key << ": '" << PACKAGE_VERSION << "' == '" << value << "' ? " << (thisTestResult ? "YES" : "NO");
}
else if (key == mitk::PropertyKeyPathToPropertyName(mitk::DICOMIOMetaInformationPropertyConstants::READER_GDCM()))
{//check gdcm version always against the current version of the system
bool thisTestResult = value == std::string(" ") + gdcm::Version::GetVersion();
testResult &= thisTestResult;
MITK_DEBUG << key << ": '" << gdcm::Version::GetVersion() << "' == '" << value << "' ? " << (thisTestResult ? "YES" : "NO");
}
else if ( reference.find(key) == reference.end() )
{
MITK_ERROR << "Test dump contains an unexpected key'" << key << "' (value '" << value << "')." ;
MITK_ERROR << "This key is not expected. Most probably you need to update your test data.";
return false;
}
}
return testResult;
}
mitk::TestDICOMLoading::KeyValueMap
mitk::TestDICOMLoading::ParseDump( const std::string& dump )
{
KeyValueMap parsedResult;
std::string shredder(dump);
std::stack<std::string> surroundingKeys;
std::stack<std::string::size_type> expectedIndents;
expectedIndents.push(0);
while (true)
{
std::string::size_type newLinePos = shredder.find( '\n' );
if (newLinePos == std::string::npos || newLinePos == 0) break;
std::string line = shredder.substr( 0, newLinePos );
shredder = shredder.erase( 0, newLinePos+1 );
std::string::size_type keyPosition = line.find_first_not_of( ' ' );
std::string::size_type colonPosition = line.find( ':' );
std::string key = line.substr(keyPosition, colonPosition - keyPosition);
std::string::size_type firstSpacePosition = key.find_first_of(" ");
if (firstSpacePosition != std::string::npos)
{
key.erase(firstSpacePosition);
}
if ( keyPosition > expectedIndents.top() )
{
// more indent than before
expectedIndents.push(keyPosition);
}
else
{
if (!surroundingKeys.empty())
{
surroundingKeys.pop(); // last of same length
}
while (expectedIndents.top() != keyPosition)
{
expectedIndents.pop();
if (!surroundingKeys.empty())
{
surroundingKeys.pop();
}
}; // unwind until current indent is found
}
if (!surroundingKeys.empty())
{
key = surroundingKeys.top() + "." + key; // construct current key name
}
surroundingKeys.push(key); // this is the new embracing key
std::string value = line.substr(colonPosition+1);
MITK_DEBUG << " Key: '" << key << "' value '" << value << "'" ;
parsedResult[key] = value; // store parsing result
}
return parsedResult;
}