diff --git a/CMake/PackageDepends/MITK_DCMTK_Config.cmake b/CMake/PackageDepends/MITK_DCMTK_Config.cmake
index 4a29a52ff1..155a9ab47b 100644
--- a/CMake/PackageDepends/MITK_DCMTK_Config.cmake
+++ b/CMake/PackageDepends/MITK_DCMTK_Config.cmake
@@ -1,10 +1,10 @@
if( NOT WIN32 AND NOT APPLE )
- set(MISSING_LIBS_REQUIRED_BY_DCMTK wrap tiff z)
+ set(MISSING_LIBS_REQUIRED_BY_DCMTK tiff z)
endif( NOT WIN32 AND NOT APPLE )
set(QT_USE_QTSQL 1)
find_package(DCMTK)
list(APPEND ALL_INCLUDE_DIRECTORIES ${DCMTK_INCLUDE_DIRS})
list(APPEND ALL_LIBRARIES ${DCMTK_LIBRARIES} ${MISSING_LIBS_REQUIRED_BY_DCMTK})
diff --git a/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.h b/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.h
index 8e5e41d396..3f2fcfa147 100644
--- a/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.h
@@ -1,66 +1,66 @@
#ifndef itkMultiHistogramFilter_h
#define itkMultiHistogramFilter_h
#include "itkImageToImageFilter.h"
namespace itk
{
template
class MultiHistogramFilter : public ImageToImageFilter< TInputImageType, TOuputImageType>
{
public:
typedef MultiHistogramFilter Self;
typedef ImageToImageFilter< TInputImageType, TOuputImageType > Superclass;
typedef SmartPointer< Self > Pointer;
typedef typename TInputImageType::ConstPointer InputImagePointer;
typedef typename TOuputImageType::Pointer OutputImagePointer;
typedef typename TOuputImageType::RegionType OutputImageRegionType;
itkNewMacro (Self);
itkTypeMacro(MultiHistogramFilter, ImageToImageFilter);
itkSetMacro(Delta, double);
itkGetConstMacro(Delta, double);
itkSetMacro(Offset, double);
itkGetConstMacro(Offset, double);
itkSetMacro(Bins, int);
itkGetConstMacro(Bins, int);
itkSetMacro(Size, int);
itkGetConstMacro(Size, int);
itkSetMacro(UseImageIntensityRange, bool);
itkGetConstMacro(UseImageIntensityRange, bool);
protected:
MultiHistogramFilter();
~MultiHistogramFilter(){};
- virtual void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId);
- virtual void BeforeThreadedGenerateData(void);
+ virtual void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId) override;
+ virtual void BeforeThreadedGenerateData(void) override;
using itk::ProcessObject::MakeOutput;
itk::ProcessObject::DataObjectPointer MakeOutput(itk::ProcessObject::DataObjectPointerArraySizeType /*idx*/) override;
void CreateOutputImage(InputImagePointer input, OutputImagePointer output);
private:
MultiHistogramFilter(const Self &); // purposely not implemented
void operator=(const Self &); // purposely not implemented
double m_Delta;
double m_Offset;
int m_Bins;
int m_Size;
bool m_UseImageIntensityRange;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMultiHistogramFilter.cpp"
#endif
#endif // itkMultiHistogramFilter_h
diff --git a/Modules/DICOMReader/include/mitkDICOMTagPath.h b/Modules/DICOMReader/include/mitkDICOMTagPath.h
index c877341417..e5bd3e6464 100644
--- a/Modules/DICOMReader/include/mitkDICOMTagPath.h
+++ b/Modules/DICOMReader/include/mitkDICOMTagPath.h
@@ -1,180 +1,180 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef mitkDICOMTagPath_h
#define mitkDICOMTagPath_h
#include
#include
#include
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 MITKDICOMREADER_EXPORT DICOMTagPath
{
public:
typedef int ItemSelectionIndex;
struct MITKDICOMREADER_EXPORT NodeInfo
{
enum class NodeType
{
Invalid = 0, //*< Node is non existant 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 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
* 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);
- ~DICOMTagPath();
+ virtual ~DICOMTagPath();
virtual void Reset();
protected:
NodeInfoVectorType m_NodeInfos;
static bool DICOMTagPathesMatch(const DICOMTagPath& left, const DICOMTagPath& right);
};
typedef std::vector DICOMTagPathList;
MITKDICOMREADER_EXPORT std::ostream& operator<<(std::ostream& os, const DICOMTagPath& path);
MITKDICOMREADER_EXPORT std::string DICOMTagPathToPropertyRegEx(const DICOMTagPath& tagPath);
MITKDICOMREADER_EXPORT std::string DICOMTagPathToPersistenceKeyRegEx(const DICOMTagPath& tagPath);
MITKDICOMREADER_EXPORT std::string DICOMTagPathToPersistenceKeyTemplate(const DICOMTagPath& tagPath);
MITKDICOMREADER_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()).*/
MITKDICOMREADER_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.*/
MITKDICOMREADER_EXPORT DICOMTagPath PropertyNameToDICOMTagPath(const std::string& propertyName);
/** returns the correct property name for a given DICOMTagPath instance. */
MITKDICOMREADER_EXPORT std::string DICOMTagPathToPropertyName(const DICOMTagPath& tagPath);
}
#endif
diff --git a/Modules/DICOMReader/src/legacy/mitkDicomSR_ImageBlockDescriptor.cpp b/Modules/DICOMReader/src/legacy/mitkDicomSR_ImageBlockDescriptor.cpp
index 6ef0bf1d74..6f12bb6f2f 100644
--- a/Modules/DICOMReader/src/legacy/mitkDicomSR_ImageBlockDescriptor.cpp
+++ b/Modules/DICOMReader/src/legacy/mitkDicomSR_ImageBlockDescriptor.cpp
@@ -1,197 +1,197 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include
#include
namespace mitk
{
DicomSeriesReader::ImageBlockDescriptor::ImageBlockDescriptor()
: m_HasGantryTiltCorrected(false), m_HasMultipleTimePoints(false), m_IsMultiFrameImage(false)
{
}
DicomSeriesReader::ImageBlockDescriptor::~ImageBlockDescriptor()
{
// nothing
}
DicomSeriesReader::ImageBlockDescriptor::ImageBlockDescriptor(const StringContainer &files)
: m_HasGantryTiltCorrected(false), m_HasMultipleTimePoints(false), m_IsMultiFrameImage(false)
{
m_Filenames = files;
}
void DicomSeriesReader::ImageBlockDescriptor::AddFile(const std::string &filename)
{
m_Filenames.push_back(filename);
}
void DicomSeriesReader::ImageBlockDescriptor::AddFiles(const StringContainer &files)
{
m_Filenames.insert(m_Filenames.end(), files.begin(), files.end());
}
DicomSeriesReader::StringContainer DicomSeriesReader::ImageBlockDescriptor::GetFilenames() const
{
return m_Filenames;
}
std::string DicomSeriesReader::ImageBlockDescriptor::GetImageBlockUID() const { return m_ImageBlockUID; }
std::string DicomSeriesReader::ImageBlockDescriptor::GetSeriesInstanceUID() const { return m_SeriesInstanceUID; }
std::string DicomSeriesReader::ImageBlockDescriptor::GetModality() const { return m_Modality; }
std::string DicomSeriesReader::ImageBlockDescriptor::GetSOPClassUIDAsString() const
{
gdcm::UIDs uidKnowledge;
uidKnowledge.SetFromUID(m_SOPClassUID.c_str());
return uidKnowledge.GetName();
}
std::string DicomSeriesReader::ImageBlockDescriptor::GetSOPClassUID() const { return m_SOPClassUID; }
bool DicomSeriesReader::ImageBlockDescriptor::IsMultiFrameImage() const { return m_IsMultiFrameImage; }
DicomSeriesReader::ReaderImplementationLevel DicomSeriesReader::ImageBlockDescriptor::GetReaderImplementationLevel()
const
{
if (this->IsMultiFrameImage())
return ReaderImplementationLevel_Unsupported;
gdcm::UIDs uidKnowledge;
uidKnowledge.SetFromUID(m_SOPClassUID.c_str());
- gdcm::UIDs::TSType uid = uidKnowledge;
+ gdcm::UIDs::TSName uid = static_cast((gdcm::UIDs::TSType)uidKnowledge);
switch (uid)
{
case gdcm::UIDs::CTImageStorage:
case gdcm::UIDs::MRImageStorage:
case gdcm::UIDs::PositronEmissionTomographyImageStorage:
case gdcm::UIDs::ComputedRadiographyImageStorage:
case gdcm::UIDs::DigitalXRayImageStorageForPresentation:
case gdcm::UIDs::DigitalXRayImageStorageForProcessing:
return ReaderImplementationLevel_Supported;
case gdcm::UIDs::NuclearMedicineImageStorage:
return ReaderImplementationLevel_PartlySupported;
case gdcm::UIDs::SecondaryCaptureImageStorage:
return ReaderImplementationLevel_Implemented;
default:
return ReaderImplementationLevel_Unsupported;
}
}
bool DicomSeriesReader::ImageBlockDescriptor::HasGantryTiltCorrected() const { return m_HasGantryTiltCorrected; }
/*
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
*/
DicomSeriesReader::PixelSpacingInterpretation DicomSeriesReader::ImageBlockDescriptor::GetPixelSpacingType() const
{
if (m_PixelSpacing.empty())
{
if (m_ImagerPixelSpacing.empty())
{
return PixelSpacingInterpretation_SpacingUnknown;
}
else
{
return PixelSpacingInterpretation_SpacingAtDetector;
}
}
else // Pixel Spacing defined
{
if (m_ImagerPixelSpacing.empty())
{
return PixelSpacingInterpretation_SpacingInPatient;
}
else if (m_PixelSpacing != m_ImagerPixelSpacing)
{
return PixelSpacingInterpretation_SpacingInPatient;
}
else
{
return PixelSpacingInterpretation_SpacingAtDetector;
}
}
}
bool DicomSeriesReader::ImageBlockDescriptor::PixelSpacingRelatesToPatient() const
{
return GetPixelSpacingType() == PixelSpacingInterpretation_SpacingInPatient;
}
bool DicomSeriesReader::ImageBlockDescriptor::PixelSpacingRelatesToDetector() const
{
return GetPixelSpacingType() == PixelSpacingInterpretation_SpacingAtDetector;
}
bool DicomSeriesReader::ImageBlockDescriptor::PixelSpacingIsUnknown() const
{
return GetPixelSpacingType() == PixelSpacingInterpretation_SpacingUnknown;
}
void DicomSeriesReader::ImageBlockDescriptor::SetPixelSpacingInformation(const std::string &pixelSpacing,
const std::string &imagerPixelSpacing)
{
m_PixelSpacing = pixelSpacing;
m_ImagerPixelSpacing = imagerPixelSpacing;
}
void DicomSeriesReader::ImageBlockDescriptor::GetDesiredMITKImagePixelSpacing(ScalarType &spacingX,
ScalarType &spacingY) const
{
// preference for "in patient" pixel spacing
if (!DICOMStringToSpacing(m_PixelSpacing, spacingX, spacingY))
{
// fallback to "on detector" spacing
if (!DICOMStringToSpacing(m_ImagerPixelSpacing, spacingX, spacingY))
{
// last resort: invent something
spacingX = spacingY = 1.0;
}
}
}
bool DicomSeriesReader::ImageBlockDescriptor::HasMultipleTimePoints() const { return m_HasMultipleTimePoints; }
void DicomSeriesReader::ImageBlockDescriptor::SetImageBlockUID(const std::string &uid) { m_ImageBlockUID = uid; }
void DicomSeriesReader::ImageBlockDescriptor::SetSeriesInstanceUID(const std::string &uid)
{
m_SeriesInstanceUID = uid;
}
void DicomSeriesReader::ImageBlockDescriptor::SetModality(const std::string &modality) { m_Modality = modality; }
void DicomSeriesReader::ImageBlockDescriptor::SetNumberOfFrames(const std::string &numberOfFrames)
{
m_IsMultiFrameImage = !numberOfFrames.empty();
}
void DicomSeriesReader::ImageBlockDescriptor::SetSOPClassUID(const std::string &sopClassUID)
{
m_SOPClassUID = sopClassUID;
}
void DicomSeriesReader::ImageBlockDescriptor::SetHasGantryTiltCorrected(bool on) { m_HasGantryTiltCorrected = on; }
void DicomSeriesReader::ImageBlockDescriptor::SetHasMultipleTimePoints(bool on) { m_HasMultipleTimePoints = on; }
} // end namespace mitk
diff --git a/Modules/DICOMReader/src/mitkDICOMITKSeriesGDCMReader.cpp b/Modules/DICOMReader/src/mitkDICOMITKSeriesGDCMReader.cpp
index 857610edfc..a12a611e50 100644
--- a/Modules/DICOMReader/src/mitkDICOMITKSeriesGDCMReader.cpp
+++ b/Modules/DICOMReader/src/mitkDICOMITKSeriesGDCMReader.cpp
@@ -1,622 +1,622 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//#define MBILOG_ENABLE_DEBUG
#define ENABLE_TIMING
#include
#include
#include "mitkDICOMITKSeriesGDCMReader.h"
#include "mitkITKDICOMSeriesReaderHelper.h"
#include "mitkGantryTiltInformation.h"
#include "mitkDICOMTagBasedSorter.h"
#include "mitkDICOMGDCMTagScanner.h"
itk::MutexLock::Pointer mitk::DICOMITKSeriesGDCMReader::s_LocaleMutex = itk::MutexLock::New();
mitk::DICOMITKSeriesGDCMReader::DICOMITKSeriesGDCMReader( unsigned int decimalPlacesForOrientation, bool simpleVolumeImport )
: DICOMFileReader()
, m_FixTiltByShearing(m_DefaultFixTiltByShearing)
, m_SimpleVolumeReading( simpleVolumeImport )
, m_DecimalPlacesForOrientation( decimalPlacesForOrientation )
, m_ExternalCache(false)
{
this->EnsureMandatorySortersArePresent( decimalPlacesForOrientation, simpleVolumeImport );
}
mitk::DICOMITKSeriesGDCMReader::DICOMITKSeriesGDCMReader( const DICOMITKSeriesGDCMReader& other )
: DICOMFileReader( other )
, m_FixTiltByShearing( other.m_FixTiltByShearing)
, m_SortingResultInProgress( other.m_SortingResultInProgress )
, m_Sorter( other.m_Sorter )
, m_EquiDistantBlocksSorter( other.m_EquiDistantBlocksSorter->Clone() )
, m_NormalDirectionConsistencySorter( other.m_NormalDirectionConsistencySorter->Clone() )
, m_ReplacedCLocales( other.m_ReplacedCLocales )
, m_ReplacedCinLocales( other.m_ReplacedCinLocales )
, m_DecimalPlacesForOrientation( other.m_DecimalPlacesForOrientation )
, m_TagCache( other.m_TagCache )
, m_ExternalCache(other.m_ExternalCache)
{
}
mitk::DICOMITKSeriesGDCMReader::~DICOMITKSeriesGDCMReader()
{
}
mitk::DICOMITKSeriesGDCMReader& mitk::DICOMITKSeriesGDCMReader::
operator=( const DICOMITKSeriesGDCMReader& other )
{
if ( this != &other )
{
DICOMFileReader::operator =( other );
this->m_FixTiltByShearing = other.m_FixTiltByShearing;
this->m_SortingResultInProgress = other.m_SortingResultInProgress;
this->m_Sorter = other.m_Sorter; // TODO should clone the list items
this->m_EquiDistantBlocksSorter = other.m_EquiDistantBlocksSorter->Clone();
this->m_NormalDirectionConsistencySorter = other.m_NormalDirectionConsistencySorter->Clone();
this->m_ReplacedCLocales = other.m_ReplacedCLocales;
this->m_ReplacedCinLocales = other.m_ReplacedCinLocales;
this->m_DecimalPlacesForOrientation = other.m_DecimalPlacesForOrientation;
this->m_TagCache = other.m_TagCache;
}
return *this;
}
bool mitk::DICOMITKSeriesGDCMReader::operator==( const DICOMFileReader& other ) const
{
if ( const auto* otherSelf = dynamic_cast( &other ) )
{
if ( this->m_FixTiltByShearing == otherSelf->m_FixTiltByShearing
&& *( this->m_EquiDistantBlocksSorter ) == *( otherSelf->m_EquiDistantBlocksSorter )
&& ( fabs( this->m_DecimalPlacesForOrientation - otherSelf->m_DecimalPlacesForOrientation ) < eps ) )
{
// test sorters for equality
if ( this->m_Sorter.size() != otherSelf->m_Sorter.size() )
return false;
auto mySorterIter = this->m_Sorter.cbegin();
auto oSorterIter = otherSelf->m_Sorter.cbegin();
for ( ; mySorterIter != this->m_Sorter.cend() && oSorterIter != otherSelf->m_Sorter.cend();
++mySorterIter, ++oSorterIter )
{
if ( !( **mySorterIter == **oSorterIter ) )
return false; // this sorter differs
}
// nothing differs ==> all is equal
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
void mitk::DICOMITKSeriesGDCMReader::SetFixTiltByShearing( bool on )
{
this->Modified();
m_FixTiltByShearing = on;
}
bool mitk::DICOMITKSeriesGDCMReader::GetFixTiltByShearing() const
{
return m_FixTiltByShearing;
}
void mitk::DICOMITKSeriesGDCMReader::SetAcceptTwoSlicesGroups( bool accept ) const
{
this->Modified();
m_EquiDistantBlocksSorter->SetAcceptTwoSlicesGroups( accept );
}
bool mitk::DICOMITKSeriesGDCMReader::GetAcceptTwoSlicesGroups() const
{
return m_EquiDistantBlocksSorter->GetAcceptTwoSlicesGroups();
}
void mitk::DICOMITKSeriesGDCMReader::InternalPrintConfiguration( std::ostream& os ) const
{
unsigned int sortIndex( 1 );
for ( auto sorterIter = m_Sorter.cbegin(); sorterIter != m_Sorter.cend(); ++sortIndex, ++sorterIter )
{
os << "Sorting step " << sortIndex << ":" << std::endl;
( *sorterIter )->PrintConfiguration( os, " " );
}
os << "Sorting step " << sortIndex << ":" << std::endl;
m_EquiDistantBlocksSorter->PrintConfiguration( os, " " );
}
std::string mitk::DICOMITKSeriesGDCMReader::GetActiveLocale()
{
return setlocale( LC_NUMERIC, nullptr );
}
void mitk::DICOMITKSeriesGDCMReader::PushLocale() const
{
s_LocaleMutex->Lock();
std::string currentCLocale = setlocale( LC_NUMERIC, nullptr );
m_ReplacedCLocales.push( currentCLocale );
setlocale( LC_NUMERIC, "C" );
std::locale currentCinLocale( std::cin.getloc() );
m_ReplacedCinLocales.push( currentCinLocale );
std::locale l( "C" );
std::cin.imbue( l );
s_LocaleMutex->Unlock();
}
void mitk::DICOMITKSeriesGDCMReader::PopLocale() const
{
s_LocaleMutex->Lock();
if ( !m_ReplacedCLocales.empty() )
{
setlocale( LC_NUMERIC, m_ReplacedCLocales.top().c_str() );
m_ReplacedCLocales.pop();
}
else
{
MITK_WARN << "Mismatched PopLocale on DICOMITKSeriesGDCMReader.";
}
if ( !m_ReplacedCinLocales.empty() )
{
std::cin.imbue( m_ReplacedCinLocales.top() );
m_ReplacedCinLocales.pop();
}
else
{
MITK_WARN << "Mismatched PopLocale on DICOMITKSeriesGDCMReader.";
}
s_LocaleMutex->Unlock();
}
mitk::DICOMITKSeriesGDCMReader::SortingBlockList
mitk::DICOMITKSeriesGDCMReader::Condense3DBlocks( SortingBlockList& input )
{
return input; // to be implemented differently by sub-classes
}
#if defined( MBILOG_ENABLE_DEBUG ) || defined( ENABLE_TIMING )
#define timeStart( part ) timer.Start( part );
#define timeStop( part ) timer.Stop( part );
#else
#define timeStart( part )
#define timeStop( part )
#endif
void mitk::DICOMITKSeriesGDCMReader::AnalyzeInputFiles()
{
itk::TimeProbesCollectorBase timer;
timeStart( "Reset" );
this->ClearOutputs();
timeStop( "Reset" );
// prepare initial sorting (== list of input files)
const StringList inputFilenames = this->GetInputFiles();
timeStart( "Check input for DCM" );
if ( inputFilenames.empty() || !this->CanHandleFile( inputFilenames.front() ) // first
|| !this->CanHandleFile( inputFilenames.back() ) // last
|| !this->CanHandleFile( inputFilenames[inputFilenames.size() / 2] ) // roughly central file
)
{
// TODO a read-as-many-as-possible fallback could be implemented here
MITK_DEBUG << "Reader unable to process files..";
return;
}
timeStop( "Check input for DCM" );
// scan files for sorting-relevant tags
if ( m_TagCache.IsNull() || ( m_TagCache->GetMTime()GetMTime() && !m_ExternalCache ))
{
timeStart( "Tag scanning" );
DICOMGDCMTagScanner::Pointer filescanner = DICOMGDCMTagScanner::New();
filescanner->SetInputFiles( inputFilenames );
filescanner->AddTagPaths( this->GetTagsOfInterest() );
PushLocale();
filescanner->Scan();
PopLocale();
m_TagCache = filescanner->GetScanCache(); // keep alive and make accessible to sub-classes
timeStop("Tag scanning");
}
else
{
// ensure that the tag cache contains our required tags AND files and has scanned!
}
m_SortingResultInProgress.clear();
m_SortingResultInProgress.push_back(m_TagCache->GetFrameInfoList());
// sort and split blocks as configured
timeStart( "Sorting frames" );
unsigned int sorterIndex = 0;
for ( auto sorterIter = m_Sorter.cbegin(); sorterIter != m_Sorter.cend(); ++sorterIndex, ++sorterIter )
{
std::stringstream ss;
ss << "Sorting step " << sorterIndex;
timeStart( ss.str().c_str() );
m_SortingResultInProgress =
this->InternalExecuteSortingStep( sorterIndex, *sorterIter, m_SortingResultInProgress );
timeStop( ss.str().c_str() );
}
if ( !m_SimpleVolumeReading )
{
// a last extra-sorting step: ensure equidistant slices
timeStart( "EquiDistantBlocksSorter" );
m_SortingResultInProgress = this->InternalExecuteSortingStep(
sorterIndex++, m_EquiDistantBlocksSorter.GetPointer(), m_SortingResultInProgress );
timeStop( "EquiDistantBlocksSorter" );
}
timeStop( "Sorting frames" );
timeStart( "Condensing 3D blocks" );
m_SortingResultInProgress = this->Condense3DBlocks( m_SortingResultInProgress );
timeStop( "Condensing 3D blocks" );
// provide final result as output
timeStart( "Output" );
unsigned int o = this->GetNumberOfOutputs();
this->SetNumberOfOutputs(
o + m_SortingResultInProgress.size() ); // Condense3DBlocks may already have added outputs!
for ( auto blockIter = m_SortingResultInProgress.cbegin(); blockIter != m_SortingResultInProgress.cend();
++o, ++blockIter )
{
const 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.SetReaderImplementationLevel( this->GetReaderImplementationLevel( block.GetSOPClassUID() ) );
this->SetOutput( o, block );
}
timeStop( "Output" );
#if defined( MBILOG_ENABLE_DEBUG ) || defined( ENABLE_TIMING )
std::cout << "---------------------------------------------------------------" << std::endl;
timer.Report( std::cout );
std::cout << "---------------------------------------------------------------" << std::endl;
#endif
}
mitk::DICOMITKSeriesGDCMReader::SortingBlockList mitk::DICOMITKSeriesGDCMReader::InternalExecuteSortingStep(
unsigned int sortingStepIndex, const DICOMDatasetSorter::Pointer& sorter, const SortingBlockList& input )
{
SortingBlockList nextStepSorting; // we should not modify our input list while processing it
std::stringstream ss;
ss << "Sorting step " << sortingStepIndex << " '";
#if defined( MBILOG_ENABLE_DEBUG )
sorter->PrintConfiguration( ss );
#endif
ss << "'";
nextStepSorting.clear();
MITK_DEBUG << "================================================================================";
MITK_DEBUG << "DICOMITKSeriesGDCMReader: " << ss.str() << ": " << input.size() << " groups input";
unsigned int groupIndex = 0;
for ( auto blockIter = input.cbegin(); blockIter != input.cend(); ++groupIndex, ++blockIter )
{
const DICOMDatasetAccessingImageFrameList& gdcmInfoFrameList = *blockIter;
const DICOMDatasetList datasetList = ConvertToDICOMDatasetList( gdcmInfoFrameList );
#if defined( MBILOG_ENABLE_DEBUG )
MITK_DEBUG << "--------------------------------------------------------------------------------";
MITK_DEBUG << "DICOMITKSeriesGDCMReader: " << ss.str() << ", dataset group " << groupIndex << " ("
<< datasetList.size() << " datasets): ";
for ( auto oi = datasetList.cbegin(); oi != datasetList.cend(); ++oi )
{
MITK_DEBUG << " INPUT : " << ( *oi )->GetFilenameIfAvailable();
}
#endif
sorter->SetInput( datasetList );
sorter->Sort();
unsigned int numberOfResultingBlocks = sorter->GetNumberOfOutputs();
for ( unsigned int b = 0; b < numberOfResultingBlocks; ++b )
{
const DICOMDatasetList blockResult = sorter->GetOutput( b );
for ( auto oi = blockResult.cbegin(); oi != blockResult.cend(); ++oi )
{
MITK_DEBUG << " OUTPUT(" << b << ") :" << ( *oi )->GetFilenameIfAvailable();
}
DICOMDatasetAccessingImageFrameList sortedGdcmInfoFrameList = ConvertToDICOMDatasetAccessingImageFrameList( blockResult );
nextStepSorting.push_back( sortedGdcmInfoFrameList );
}
}
return nextStepSorting;
}
mitk::ReaderImplementationLevel
mitk::DICOMITKSeriesGDCMReader::GetReaderImplementationLevel( const std::string sopClassUID )
{
if ( sopClassUID.empty() )
{
return SOPClassUnknown;
}
gdcm::UIDs uidKnowledge;
uidKnowledge.SetFromUID( sopClassUID.c_str() );
- gdcm::UIDs::TSType gdcmType = uidKnowledge;
+ gdcm::UIDs::TSName gdcmType = static_cast((gdcm::UIDs::TSType)uidKnowledge);
switch ( gdcmType )
{
case gdcm::UIDs::CTImageStorage:
case gdcm::UIDs::MRImageStorage:
case gdcm::UIDs::PositronEmissionTomographyImageStorage:
case gdcm::UIDs::ComputedRadiographyImageStorage:
case gdcm::UIDs::DigitalXRayImageStorageForPresentation:
case gdcm::UIDs::DigitalXRayImageStorageForProcessing:
return SOPClassSupported;
case gdcm::UIDs::NuclearMedicineImageStorage:
return SOPClassPartlySupported;
case gdcm::UIDs::SecondaryCaptureImageStorage:
return SOPClassImplemented;
default:
return SOPClassUnsupported;
}
}
// void AllocateOutputImages();
bool mitk::DICOMITKSeriesGDCMReader::LoadImages()
{
bool success = true;
unsigned int numberOfOutputs = this->GetNumberOfOutputs();
for ( unsigned int o = 0; o < numberOfOutputs; ++o )
{
success &= this->LoadMitkImageForOutput( o );
}
return success;
}
bool mitk::DICOMITKSeriesGDCMReader::LoadMitkImageForImageBlockDescriptor(
DICOMImageBlockDescriptor& block ) const
{
PushLocale();
const DICOMImageFrameList& frames = block.GetImageFrameList();
const GantryTiltInformation tiltInfo = block.GetTiltInformation();
bool hasTilt = tiltInfo.IsRegularGantryTilt();
ITKDICOMSeriesReaderHelper::StringContainer filenames;
filenames.reserve( frames.size() );
for ( auto frameIter = frames.cbegin(); frameIter != frames.cend(); ++frameIter )
{
filenames.push_back( ( *frameIter )->Filename );
}
mitk::ITKDICOMSeriesReaderHelper helper;
bool success( true );
try
{
mitk::Image::Pointer mitkImage = helper.Load( filenames, m_FixTiltByShearing && hasTilt, tiltInfo );
block.SetMitkImage( mitkImage );
}
catch ( const std::exception& e )
{
success = false;
MITK_ERROR << "Exception during image loading: " << e.what();
}
PopLocale();
return success;
}
bool mitk::DICOMITKSeriesGDCMReader::LoadMitkImageForOutput( unsigned int o )
{
DICOMImageBlockDescriptor& block = this->InternalGetOutput( o );
return this->LoadMitkImageForImageBlockDescriptor( block );
}
bool mitk::DICOMITKSeriesGDCMReader::CanHandleFile( const std::string& filename )
{
return ITKDICOMSeriesReaderHelper::CanHandleFile( filename );
}
void mitk::DICOMITKSeriesGDCMReader::AddSortingElement( DICOMDatasetSorter* sorter, bool atFront )
{
assert( sorter );
if ( atFront )
{
m_Sorter.push_front( sorter );
}
else
{
m_Sorter.push_back( sorter );
}
this->Modified();
}
mitk::DICOMITKSeriesGDCMReader::ConstSorterList
mitk::DICOMITKSeriesGDCMReader::GetFreelyConfiguredSortingElements() const
{
std::list result;
unsigned int sortIndex( 0 );
for ( auto sorterIter = m_Sorter.begin(); sorterIter != m_Sorter.end(); ++sortIndex, ++sorterIter )
{
if ( sortIndex > 0 ) // ignore first element (see EnsureMandatorySortersArePresent)
{
result.push_back( ( *sorterIter ).GetPointer() );
}
}
return result;
}
void mitk::DICOMITKSeriesGDCMReader::EnsureMandatorySortersArePresent(
unsigned int decimalPlacesForOrientation, bool simpleVolumeImport )
{
DICOMTagBasedSorter::Pointer splitter = DICOMTagBasedSorter::New();
splitter->AddDistinguishingTag( DICOMTag(0x0028, 0x0010) ); // Number of Rows
splitter->AddDistinguishingTag( DICOMTag(0x0028, 0x0011) ); // Number of Columns
splitter->AddDistinguishingTag( DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
splitter->AddDistinguishingTag( DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
splitter->AddDistinguishingTag( DICOMTag(0x0020, 0x0037), new mitk::DICOMTagBasedSorter::CutDecimalPlaces(decimalPlacesForOrientation) ); // Image Orientation (Patient)
splitter->AddDistinguishingTag( DICOMTag(0x0018, 0x0050) ); // Slice Thickness
if ( !simpleVolumeImport )
{
std::cout << "Simple volume reading: ignoring number of frames" << std::endl;
splitter->AddDistinguishingTag( DICOMTag(0x0028, 0x0008) ); // Number of Frames
}
this->AddSortingElement( splitter, true ); // true = at front
if ( m_EquiDistantBlocksSorter.IsNull() )
{
m_EquiDistantBlocksSorter = mitk::EquiDistantBlocksSorter::New();
}
m_EquiDistantBlocksSorter->SetAcceptTilt( m_FixTiltByShearing );
if ( m_NormalDirectionConsistencySorter.IsNull() )
{
m_NormalDirectionConsistencySorter = mitk::NormalDirectionConsistencySorter::New();
}
}
void mitk::DICOMITKSeriesGDCMReader::SetToleratedOriginOffsetToAdaptive( double fractionOfInterSliceDistance ) const
{
assert( m_EquiDistantBlocksSorter.IsNotNull() );
m_EquiDistantBlocksSorter->SetToleratedOriginOffsetToAdaptive( fractionOfInterSliceDistance );
this->Modified();
}
void mitk::DICOMITKSeriesGDCMReader::SetToleratedOriginOffset( double millimeters ) const
{
assert( m_EquiDistantBlocksSorter.IsNotNull() );
m_EquiDistantBlocksSorter->SetToleratedOriginOffset( millimeters );
this->Modified();
}
double mitk::DICOMITKSeriesGDCMReader::GetToleratedOriginError() const
{
assert( m_EquiDistantBlocksSorter.IsNotNull() );
return m_EquiDistantBlocksSorter->GetToleratedOriginOffset();
}
bool mitk::DICOMITKSeriesGDCMReader::IsToleratedOriginOffsetAbsolute() const
{
assert( m_EquiDistantBlocksSorter.IsNotNull() );
return m_EquiDistantBlocksSorter->IsToleratedOriginOffsetAbsolute();
}
double mitk::DICOMITKSeriesGDCMReader::GetDecimalPlacesForOrientation() const
{
return m_DecimalPlacesForOrientation;
}
mitk::DICOMTagCache::Pointer mitk::DICOMITKSeriesGDCMReader::GetTagCache() const
{
return m_TagCache;
}
void mitk::DICOMITKSeriesGDCMReader::SetTagCache( const DICOMTagCache::Pointer& tagCache )
{
m_TagCache = tagCache;
m_ExternalCache = tagCache.IsNotNull();
}
mitk::DICOMTagPathList mitk::DICOMITKSeriesGDCMReader::GetTagsOfInterest() const
{
DICOMTagPathList completeList;
// check all configured sorters
for ( auto sorterIter = m_Sorter.cbegin(); sorterIter != m_Sorter.cend(); ++sorterIter )
{
assert( sorterIter->IsNotNull() );
const DICOMTagList tags = ( *sorterIter )->GetTagsOfInterest();
completeList.insert( completeList.end(), tags.cbegin(), tags.cend() );
}
// check our own forced sorters
DICOMTagList tags = m_EquiDistantBlocksSorter->GetTagsOfInterest();
completeList.insert( completeList.end(), tags.cbegin(), tags.cend() );
tags = m_NormalDirectionConsistencySorter->GetTagsOfInterest();
completeList.insert( completeList.end(), tags.cbegin(), tags.cend() );
// add the tags for DICOMImageBlockDescriptor
tags = DICOMImageBlockDescriptor::GetTagsOfInterest();
completeList.insert( completeList.end(), tags.cbegin(), tags.cend() );
const AdditionalTagsMapType tagList = GetAdditionalTagsOfInterest();
for ( auto iter = tagList.cbegin();
iter != tagList.cend();
++iter
)
{
completeList.push_back( iter->first ) ;
}
return completeList;
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/Reconstruction/itkOrientationDistributionFunction.txx b/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/Reconstruction/itkOrientationDistributionFunction.txx
index dc9107f3b9..c50bf289c1 100644
--- a/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/Reconstruction/itkOrientationDistributionFunction.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/Reconstruction/itkOrientationDistributionFunction.txx
@@ -1,1367 +1,1366 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _itkOrientationDistributionFunction_txx
#define _itkOrientationDistributionFunction_txx
#include
#include
#include
#include
#include
#include
#include "itkPointShell.h"
#ifdef _MSC_VER
#if _MSC_VER <= 1700
#define fmin(a,b) ((a<=b)?(a):(b))
#define fmax(a,b) ((a>=b)?(a):(b))
#define isnan(c) (c!=c)
#endif
#endif
#include
#include
#include
#include
#include
#include
namespace itk
{
template
vtkPolyData* itk::OrientationDistributionFunction::m_BaseMesh = nullptr;
template
double itk::OrientationDistributionFunction::m_MaxChordLength = -1.0;
template
vnl_matrix_fixed* itk::OrientationDistributionFunction::m_Directions
= itk::PointShell >::DistributePointShell();
template
std::vector< std::vector* >* itk::OrientationDistributionFunction::m_NeighborIdxs = nullptr;
template
std::vector< std::vector* >* itk::OrientationDistributionFunction::m_AngularRangeIdxs = nullptr;
template
std::vector* itk::OrientationDistributionFunction::m_HalfSphereIdxs = nullptr;
template
itk::SimpleFastMutexLock itk::OrientationDistributionFunction::m_MutexBaseMesh;
template
itk::SimpleFastMutexLock itk::OrientationDistributionFunction::m_MutexHalfSphereIdxs;
template
itk::SimpleFastMutexLock itk::OrientationDistributionFunction::m_MutexNeighbors;
template
itk::SimpleFastMutexLock itk::OrientationDistributionFunction::m_MutexAngularRange;
/**
* Assignment Operator
*/
template
OrientationDistributionFunction&
OrientationDistributionFunction
::operator= (const Self& r)
{
BaseArray::operator=(r);
return *this;
}
/**
* Assignment Operator from a scalar constant
*/
template
OrientationDistributionFunction&
OrientationDistributionFunction
::operator= (const ComponentType & r)
{
BaseArray::operator=(&r);
return *this;
}
/**
* Assigment from a plain array
*/
template
OrientationDistributionFunction&
OrientationDistributionFunction
::operator= (const ComponentArrayType r )
{
BaseArray::operator=(r);
return *this;
}
/**
* Returns a temporary copy of a vector
*/
template
OrientationDistributionFunction
OrientationDistributionFunction
::operator+(const Self & r) const
{
Self result;
for( unsigned int i=0; i
OrientationDistributionFunction
OrientationDistributionFunction
::operator-(const Self & r) const
{
Self result;
for( unsigned int i=0; i
const OrientationDistributionFunction &
OrientationDistributionFunction
::operator+=(const Self & r)
{
for( unsigned int i=0; i
const OrientationDistributionFunction &
OrientationDistributionFunction
::operator-=(const Self & r)
{
for( unsigned int i=0; i
const OrientationDistributionFunction &
OrientationDistributionFunction
::operator*=(const RealValueType & r)
{
for( unsigned int i=0; i
const OrientationDistributionFunction &
OrientationDistributionFunction
::operator/=(const RealValueType & r)
{
for( unsigned int i=0; i
OrientationDistributionFunction
OrientationDistributionFunction
::operator*(const RealValueType & r) const
{
Self result;
for( unsigned int i=0; i
OrientationDistributionFunction
OrientationDistributionFunction
::operator/(const RealValueType & r) const
{
Self result;
for( unsigned int i=0; i
const typename OrientationDistributionFunction::ValueType &
OrientationDistributionFunction
::operator()(unsigned int row, unsigned int col) const
{
unsigned int k;
if( row < col )
{
k = row * InternalDimension + col - row * ( row + 1 ) / 2;
}
else
{
k = col * InternalDimension + row - col * ( col + 1 ) / 2;
}
if( k >= InternalDimension )
{
k = 0;
}
return (*this)[k];
}
/**
* Matrix notation access to elements
*/
template
typename OrientationDistributionFunction::ValueType &
OrientationDistributionFunction
::operator()(unsigned int row, unsigned int col)
{
unsigned int k;
if( row < col )
{
k = row * InternalDimension + col - row * ( row + 1 ) / 2;
}
else
{
k = col * InternalDimension + row - col * ( col + 1 ) / 2;
}
if( k >= InternalDimension )
{
k = 0;
}
return (*this)[k];
}
/**
* Set the Tensor to an Identity.
* Set ones in the diagonal and zeroes every where else.
*/
template
void
OrientationDistributionFunction
::SetIsotropic()
{
this->Fill(NumericTraits< T >::One / NOdfDirections);
}
/**
* InitFromTensor()
*/
template
void
OrientationDistributionFunction
::InitFromTensor(itk::DiffusionTensor3D tensor)
{
m_EigenAnalysisCalculated = false;
for(unsigned int i=0; i
void OrientationDistributionFunction::
InitFromEllipsoid( itk::DiffusionTensor3D tensor )
{
m_EigenAnalysisCalculated = false;
FixedArray nulltensor;
nulltensor.Fill(0.0);
if( tensor == nulltensor )
{
for ( unsigned int it=0; it < NOdfDirections; ++it ){ (*this)[it] = (T)0; }
MITK_DEBUG << "OrientationDistributionFunction<" << typeid(T).name() << ", " << NOdfDirections
<< ">::InitFromEllipsoid(" << typeid(tensor).name()
<< ") encountered a nulltensor as dti input point and ignorend it.";
return;
}
tensor.ComputeEigenAnalysis( m_EigenValues, this->m_EigenVectors ); // gives normalized eigenvectors as lines i.e. rows.
m_EigenAnalysisCalculated = true;
double a = m_EigenValues[0]; // those eigenvalues are the 3 |axes of the ellipsoid|,
double b = m_EigenValues[1]; // ComputeEigenAnalysis gives eigenValues in ascending < order per default,
double c = m_EigenValues[2]; // therefor the third eigenVector is the main direction of diffusion.
if( a <= 0.0 || b <= 0.0 || c <= 0.0 )
{
for ( unsigned int it=0; it < NOdfDirections; ++it ){ (*this)[it] = (T)0; }
MITK_DEBUG << "OrientationDistributionFunction<" << typeid(T).name() << ", " << NOdfDirections
<< ">::InitFromEllipsoid(" << typeid(tensor).name()
<< ") encountered an eigenvalue <= 0 and ignored this input point.";
return;
}
// check magnitude and scale towards 1 to minimize numerical condition kappa:
#ifdef _MSC_VER
#if _MSC_VER <= 1700
int exponent_a = floor(std::log(a)/std::log(2));
int exponent_b = floor(std::log(b)/std::log(2));
int exponent_c = floor(std::log(c)/std::log(2));
#else
int exponent_a = std::ilogb(a);
int exponent_b = std::ilogb(b);
int exponent_c = std::ilogb(c);
#endif
#else
int exponent_a = std::ilogb(a);
int exponent_b = std::ilogb(b);
int exponent_c = std::ilogb(c);
#endif
T min_exponent= fmin(exponent_a, fmin(exponent_b, exponent_c) );
T max_exponent= fmax(exponent_c, fmax(exponent_b, exponent_a) );
int scale_exponent = floor(0.5 * (min_exponent + max_exponent));
double scaling = pow(2, scale_exponent);
a= a/scaling;
b= b/scaling;
c= c/scaling;
vnl_matrix_fixed eigenBase; // for change of base system.
for (int row = 0 ; row < 3; ++row) // Transposing because ComputeEigenAnalysis(,) gave us _row_ vectors.
{
for (int col = 0; col < 3; ++col)
{
eigenBase(row, col) = this->m_EigenVectors(col, row);
}
}
eigenBase= vnl_inverse(eigenBase); // Assuming canonical orthonormal system x=[1;0;0];y=[0;1;0];z=[0;0;1] for original DT.
eigenBase.assert_finite();
#ifndef NDEBUG
double kappa=1.0;
{ // calculate numerical condition kappa= ||f(x)-f(x~)|| approximately:
double gxaa = pow( a, -2.0); double gybb = pow( b, -2.0); double gzcc = pow( c, -2.0);
kappa = sqrt( pow( a, 2.0)+ pow( b, 2.0)+ pow( c, 2.0) + 1 ) / (gxaa + gybb + gzcc)
* sqrt( pow( a, -6.0)+ pow( b, -6.0)+ pow( c, -6.0) + pow( a, -4.0)+ pow( b, -4.0)+ pow( c, -4.0) );
MITK_DEBUG <<"kappa= "<< kappa << ", eigenvalues= [" << a <<", "<< b <<", "<< c <<"], eigenbase= ["
< g( (*m_Directions)(0,i), (*m_Directions)(1,i), (*m_Directions)(2,i) );
g = eigenBase*g; // passive change of base system of g.
g = g.normalize(); // unit vectors necessary.
(*this)[i] = scaling / sqrt( (g[0]/a)*(g[0]/a) + (g[1]/b)*(g[1]/b) + (g[2]/c)*(g[2]/c) );
#ifndef NDEBUG
{ // boundary check for numerical stability, assuming sigma=6, ||f(x~)-f~(x~)|| <= eps*kappa*sigma.
T min_ev= fmin(a, fmin(b, c) ); T max_ev= fmax(c, fmax(b, a) );
double eps= std::numeric_limits::epsilon();
assert( scaling*min_ev <= ((*this)[i] + eps*kappa*6.0) ); // we should be between smallest and
assert( (*this)[i] <= (scaling*max_ev + eps*kappa*6.0) ); // biggest eigenvalue.
}
#endif
if ( (*this)[i] < T(0) || (*this)[i] > T(1) || std::isnan((*this)[i]) ) // P∈[0;1] sanity check.
{ // C: NaN != NaN, C++11: isnan((*this)[i]).
MITK_DEBUG << "OrientationDistributionFunction<" << typeid(T).name() << ", " << NOdfDirections
<< ">::InitFromEllipsoid(" << typeid(tensor).name()
<< ") encountered a probability value out of range [0;1] and set it to zero: (*this)["
<< i <<"]= " << (*this)[i];
(*this)[i] = T(0);
}
}
}
/**
* L2-Normalization
*/
template
void
OrientationDistributionFunction
::L2Normalize()
{
T sum = 0;
for( unsigned int i=0; i
void
OrientationDistributionFunction
::Normalize()
{
T sum = 0;
for( unsigned int i=0; i0)
{
for( unsigned int i=0; i
OrientationDistributionFunction
OrientationDistributionFunction
::MinMaxNormalize() const
{
T max = NumericTraits::NonpositiveMin();
T min = NumericTraits::max();
for( unsigned int i=0; i max ? (*this)[i] : max;
min = (*this)[i] < min ? (*this)[i] : min;
}
Self retval;
for( unsigned int i=0; i
OrientationDistributionFunction
OrientationDistributionFunction
::MaxNormalize() const
{
T max = NumericTraits::NonpositiveMin();
for( unsigned int i=0; i max ? (*this)[i] : max;
}
Self retval;
for( unsigned int i=0; i
T
OrientationDistributionFunction
::GetMaxValue() const
{
T max = NumericTraits::NonpositiveMin();
for( unsigned int i=0; i= max )
{
max = (*this)[i];
}
}
return max;
}
template
T
OrientationDistributionFunction
::GetMinValue() const
{
T min = NumericTraits::max();
for( unsigned int i=0; i= min )
{
min = (*this)[i];
}
}
return min;
}
template
T
OrientationDistributionFunction
::GetMeanValue() const
{
T sum = 0;
for( unsigned int i=0; i
double
OrientationDistributionFunction
::GetMaxChordLength()
{
if(m_MaxChordLength<0.0)
{
ComputeBaseMesh();
double max_dist = -1;
vtkPoints* points = m_BaseMesh->GetPoints();
for(int i=0; iGetPoint(i,p);
std::vector neighbors = GetNeighbors(i);
for(std::size_t j=0; jGetPoint(neighbors[j],n);
double d = sqrt(
(p[0]-n[0])*(p[0]-n[0]) +
(p[1]-n[1])*(p[1]-n[1]) +
(p[2]-n[2])*(p[2]-n[2]));
max_dist = d>max_dist ? d : max_dist;
}
}
m_MaxChordLength = max_dist;
}
return m_MaxChordLength;
}
template
void
OrientationDistributionFunction
::ComputeBaseMesh()
{
m_MutexBaseMesh.Lock();
if(m_BaseMesh == nullptr)
{
vtkPoints* points = vtkPoints::New();
for(unsigned int j=0; jInsertNextPoint(az,elev,r);
}
vtkPolyData* polydata = vtkPolyData::New();
polydata->SetPoints( points );
vtkDelaunay2D *delaunay = vtkDelaunay2D::New();
delaunay->SetInputData( polydata );
delaunay->Update();
vtkCellArray* vtkpolys = delaunay->GetOutput()->GetPolys();
vtkCellArray* vtknewpolys = vtkCellArray::New();
vtkIdType npts; vtkIdType *pts;
while(vtkpolys->GetNextCell(npts,pts))
{
bool insert = true;
for(int i=0; iGetPoint(pts[i]);
double az = tmpPoint[0];
double elev = tmpPoint[1];
if((std::abs(az)>itk::Math::pi-0.5) || (std::abs(elev)>itk::Math::pi/2-0.5))
insert = false;
}
if(insert)
vtknewpolys->InsertNextCell(npts, pts);
}
vtkPoints* points2 = vtkPoints::New();
for(unsigned int j=0; jInsertNextPoint(az,elev,r);
}
vtkPolyData* polydata2 = vtkPolyData::New();
polydata2->SetPoints( points2 );
vtkDelaunay2D *delaunay2 = vtkDelaunay2D::New();
delaunay2->SetInputData( polydata2 );
delaunay2->Update();
vtkpolys = delaunay2->GetOutput()->GetPolys();
while(vtkpolys->GetNextCell(npts,pts))
{
bool insert = true;
for(int i=0; iGetPoint(pts[i]);
double az = tmpPoint[0];
double elev = tmpPoint[1];
if((std::abs(az)>itk::Math::pi-0.5) || (std::abs(elev)>itk::Math::pi/2-0.5))
insert = false;
}
if(insert)
vtknewpolys->InsertNextCell(npts, pts);
}
polydata->SetPolys(vtknewpolys);
for (unsigned int p = 0; p < NOdfDirections; p++)
{
points->SetPoint(p,m_Directions->get_column(p).data_block());
}
polydata->SetPoints( points );
m_BaseMesh = polydata;
}
m_MutexBaseMesh.Unlock();
}
/**
* Extract the index of the principal diffusion direction
*/
template
int OrientationDistributionFunction::GetPrincipalDiffusionDirectionIndex() const
{
T max = NumericTraits::NonpositiveMin();
int maxidx = -1;
for( unsigned int i=0; i= max )
{
max = (*this)[i];
maxidx = i;
}
}
return maxidx;
}
/**
* Extract the principal diffusion direction
*/
template
vnl_vector_fixed OrientationDistributionFunction::GetPrincipalDiffusionDirection() const
{
if (m_EigenAnalysisCalculated)
{
vnl_vector_fixed vec;
vec[0] = this->m_EigenVectors(2,0);
vec[1] = this->m_EigenVectors(2,1);
vec[2] = this->m_EigenVectors(2,2);
vec.normalize();
return vec;
}
else
{
int idx = GetPrincipalDiffusionDirectionIndex();
if (idx>0 && idx<(int)NOdfDirections)
return OrientationDistributionFunction::GetDirection(idx);
vnl_vector_fixed vec; vec.fill(0);
return vec;
}
}
template
std::vector
OrientationDistributionFunction
::GetNeighbors(int idx)
{
ComputeBaseMesh();
m_MutexNeighbors.Lock();
if(m_NeighborIdxs == nullptr)
{
m_NeighborIdxs = new std::vector< std::vector* >();
vtkCellArray* polys = m_BaseMesh->GetPolys();
for(unsigned int i=0; i();
polys->InitTraversal();
vtkIdType npts; vtkIdType *pts;
while(polys->GetNextCell(npts,pts))
{
if( pts[0] == i )
{
idxs->push_back(pts[1]);
idxs->push_back(pts[2]);
}
else if( pts[1] == i )
{
idxs->push_back(pts[0]);
idxs->push_back(pts[2]);
}
else if( pts[2] == i )
{
idxs->push_back(pts[0]);
idxs->push_back(pts[1]);
}
}
std::sort(idxs->begin(), idxs->end());
std::vector< int >::iterator endLocation;
endLocation = std::unique( idxs->begin(), idxs->end() );
idxs->erase(endLocation, idxs->end());
m_NeighborIdxs->push_back(idxs);
}
}
m_MutexNeighbors.Unlock();
return *m_NeighborIdxs->at(idx);
}
/**
* Extract the n-th diffusion direction
*/
template
int
OrientationDistributionFunction
::GetNthDiffusionDirection(int n, vnl_vector_fixed rndVec) const
{
if( n == 0 )
return GetPrincipalDiffusionDirectionIndex();
m_MutexHalfSphereIdxs.Lock();
if( !m_HalfSphereIdxs )
{
m_HalfSphereIdxs = new std::vector();
for( unsigned int i=0; iget_column(i),rndVec) > 0.0)
{
m_HalfSphereIdxs->push_back(i);
}
}
}
m_MutexHalfSphereIdxs.Unlock();
// collect indices of directions
// that are local maxima
std::vector localMaxima;
std::vector::iterator it;
for( it=m_HalfSphereIdxs->begin();
it!=m_HalfSphereIdxs->end();
it++)
{
std::vector nbs = GetNeighbors(*it);
std::vector::iterator it2;
bool max = true;
for(it2 = nbs.begin();
it2 != nbs.end();
it2++)
{
if((*this)[*it2] > (*this)[*it])
{
max = false;
break;
}
}
if(max)
localMaxima.push_back(*it);
}
// delete n highest local maxima from list
// and return remaining highest
int maxidx = -1;
- std::vector::iterator itMax;
for( int i=0; i<=n; i++ )
{
maxidx = -1;
T max = NumericTraits::NonpositiveMin();
for(it = localMaxima.begin();
it != localMaxima.end();
it++)
{
if((*this)[*it]>max)
{
max = (*this)[*it];
maxidx = *it;
}
}
it = find(localMaxima.begin(), localMaxima.end(), maxidx);
if(it!=localMaxima.end())
localMaxima.erase(it);
}
return maxidx;
}
template < typename TComponent, unsigned int NOdfDirections >
vnl_vector_fixed itk::OrientationDistributionFunction
::GetDirection( int i )
{
return m_Directions->get_column(i);
}
/**
* Interpolate a position between sampled directions
*/
template
T
OrientationDistributionFunction
::GetInterpolatedComponent(vnl_vector_fixed dir, InterpolationMethods method) const
{
ComputeBaseMesh();
double retval = -1.0;
switch(method)
{
case ODF_NEAREST_NEIGHBOR_INTERP:
{
vtkPoints* points = m_BaseMesh->GetPoints();
double current_min = NumericTraits::max();
int current_min_idx = -1;
for(int i=0; i P(points->GetPoint(i));
double dist = (dir-P).two_norm();
current_min_idx = distGetNthComponent(current_min_idx);
break;
}
case ODF_TRILINEAR_BARYCENTRIC_INTERP:
{
double maxChordLength = GetMaxChordLength();
vtkCellArray* polys = m_BaseMesh->GetPolys();
vtkPoints* points = m_BaseMesh->GetPoints();
vtkIdType npts; vtkIdType *pts;
double current_min = NumericTraits::max();
polys->InitTraversal();
while(polys->GetNextCell(npts,pts))
{
vnl_vector_fixed A(points->GetPoint(pts[0]));
vnl_vector_fixed B(points->GetPoint(pts[1]));
vnl_vector_fixed C(points->GetPoint(pts[2]));
vnl_vector_fixed d1;
d1.put(0,(dir-A).two_norm());
d1.put(1,(dir-B).two_norm());
d1.put(2,(dir-C).two_norm());
double maxval = d1.max_value();
if(maxval>maxChordLength)
{
continue;
}
// Compute vectors
vnl_vector_fixed v0 = C - A;
vnl_vector_fixed v1 = B - A;
// Project direction to plane ABC
vnl_vector_fixed v6 = dir;
vnl_vector_fixed cross = vnl_cross_3d(v0, v1);
cross = cross.normalize();
vtkPlane::ProjectPoint(v6.data_block(),A.data_block(),cross.data_block(),v6.data_block());
v6 = v6-A;
// Calculate barycentric coords
vnl_matrix_fixed mat;
mat.set_column(0, v0);
mat.set_column(1, v1);
vnl_matrix_inverse inv(mat);
vnl_matrix_fixed inver = inv.pinverse();
vnl_vector uv = inv.pinverse()*v6;
// Check if point is in triangle
double eps = 0.01;
if( (uv(0) >= 0-eps) && (uv(1) >= 0-eps) && (uv(0) + uv(1) <= 1+eps) )
{
// check if minimum angle is the max so far
if(d1.two_norm() < current_min)
{
current_min = d1.two_norm();
vnl_vector barycentricCoords(3);
barycentricCoords[2] = uv[0]<0 ? 0 : (uv[0]>1?1:uv[0]);
barycentricCoords[1] = uv[1]<0 ? 0 : (uv[1]>1?1:uv[1]);
barycentricCoords[0] = 1-(barycentricCoords[1]+barycentricCoords[2]);
retval = barycentricCoords[0]*this->GetNthComponent(pts[0]) +
barycentricCoords[1]*this->GetNthComponent(pts[1]) +
barycentricCoords[2]*this->GetNthComponent(pts[2]);
}
}
}
break;
}
case ODF_SPHERICAL_GAUSSIAN_BASIS_FUNCTIONS:
{
double maxChordLength = GetMaxChordLength();
double sigma = asin(maxChordLength/2);
// this is the contribution of each kernel to each sampling point on the
// equator
vnl_vector contrib;
contrib.set_size(NOdfDirections);
vtkPoints* points = m_BaseMesh->GetPoints();
double sum = 0;
for(int i=0; i P(points->GetPoint(i));
double stv = dir[0]*P[0]
+ dir[1]*P[1]
+ dir[2]*P[2];
stv = (stv<-1.0) ? -1.0 : ( (stv>1.0) ? 1.0 : stv);
double x = acos(stv);
contrib[i] = (1.0/(sigma*sqrt(2.0*itk::Math::pi)))
*exp((-x*x)/(2*sigma*sigma));
sum += contrib[i];
}
retval = 0;
for(int i=0; iGetNthComponent(i);
}
break;
}
}
if(retval==-1)
{
std::cout << "Interpolation failed" << std::endl;
return 0;
}
return retval;
}
/**
* Calculate Generalized Fractional Anisotropy
*/
template
T
OrientationDistributionFunction
::GetGeneralizedFractionalAnisotropy() const
{
double mean = 0;
double std = 0;
double rms = 0;
for( unsigned int i=0; i
T itk::OrientationDistributionFunction
::GetGeneralizedGFA( int k, int p ) const
{
double mean = 0;
double std = 0;
double rms = 0;
double max = NumericTraits::NonpositiveMin();
for( unsigned int i=0; i max ? val : max;
}
max = pow(max,(double)p);
mean /= N;
for( unsigned int i=0; i0)
{
rms += pow(val,(double)(p*k));
}
}
std /= N - 1;
std = sqrt(std);
if(k>0)
{
rms /= N;
rms = pow(rms,(double)(1.0/k));
}
else if(k<0) // lim k->inf gives us the maximum
{
rms = max;
}
else // k==0 undefined, we define zeros root from 1 as 1
{
rms = 1;
}
if(rms == 0)
{
return 0;
}
else
{
return (T)(std/rms);
}
}
/**
* Calculate Nematic Order Parameter
*/
template < typename T, unsigned int N >
T itk::OrientationDistributionFunction
::GetNematicOrderParameter() const
{
// not yet implemented
return 0;
}
/**
* Calculate StdDev by MaxValue
*/
template < typename T, unsigned int N >
T itk::OrientationDistributionFunction
::GetStdDevByMaxValue() const
{
double mean = 0;
double std = 0;
T max = NumericTraits::NonpositiveMin();
for( unsigned int i=0; i max ? (*this)[i] : max;
}
mean /= InternalDimension;
for( unsigned int i=0; i
T itk::OrientationDistributionFunction
::GetPrincipleCurvature(double alphaMinDegree, double alphaMaxDegree, int invert) const
{
// following loop only performed once
// (computing indices of each angular range)
m_MutexAngularRange.Lock();
if(m_AngularRangeIdxs == nullptr)
{
m_AngularRangeIdxs = new std::vector< std::vector* >();
for(unsigned int i=0; i pDir = GetDirection(i);
auto idxs = new std::vector();
for(unsigned int j=0; j cDir = GetDirection(j);
double angle = ( 180 / itk::Math::pi ) * acos( dot_product(pDir, cDir) );
if( (angle < alphaMaxDegree) && (angle > alphaMinDegree) )
{
idxs->push_back(j);
}
}
m_AngularRangeIdxs->push_back(idxs);
}
}
m_MutexAngularRange.Unlock();
// find the maximum (or minimum) direction (remember index and value)
T mode;
int pIdx = -1;
if(invert == 0)
{
pIdx = GetPrincipalDiffusionDirectionIndex();
mode = (*this)[pIdx];
}
else
{
mode = NumericTraits::max();
for( unsigned int i=0; i nbs = GetNeighbors(pIdx);
//////std::vector modeAndNeighborVals;
//////modeAndNeighborVals.push_back(mode);
//////int numNeighbors = nbs.size();
//////for(int i=0; i odfValuesInAngularRange;
int numInRange = m_AngularRangeIdxs->at(pIdx)->size();
for(int i=0; iat(pIdx))[i] ]);
}
// sort them by value
std::sort( odfValuesInAngularRange.begin(), odfValuesInAngularRange.end() );
// median of angular range
T median = odfValuesInAngularRange[floor(quantile*(double)numInRange+0.5)];
// compute and return final value
if(mode > median)
{
return mode/median - 1.0;
}
else
{
return median/mode - 1.0;
}
}
/**
* Calculate Normalized Entropy
*/
template < typename T, unsigned int N >
T itk::OrientationDistributionFunction
::GetNormalizedEntropy() const
{
double mean = 0;
for( unsigned int i=0; i
OrientationDistributionFunction
OrientationDistributionFunction
::PreMultiply( const MatrixType & m ) const
{
Self result;
typedef typename NumericTraits::AccumulateType AccumulateType;
for(unsigned int r=0; r::ZeroValue();
for(unsigned int t=0; t( sum );
}
}
return result;
}
/**
* Post-multiply the Tensor by a Matrix
*/
template
OrientationDistributionFunction
OrientationDistributionFunction
::PostMultiply( const MatrixType & m ) const
{
Self result;
typedef typename NumericTraits::AccumulateType AccumulateType;
for(unsigned int r=0; r::ZeroValue();
for(unsigned int t=0; t( sum );
}
}
return result;
}
/**
* Print content to an ostream
*/
template
std::ostream &
operator<<(std::ostream& os,const OrientationDistributionFunction & c )
{
for(unsigned int i=0; i::PrintType>(c[i]) << " ";
}
return os;
}
/**
* Read content from an istream
*/
template
std::istream &
operator>>(std::istream& is, OrientationDistributionFunction & dt )
{
for(unsigned int i=0; i < dt.GetNumberOfComponents(); i++)
{
is >> dt[i];
}
return is;
}
} // end namespace itk
#endif
diff --git a/Plugins/org.blueberry.ui.qt/src/actions/berryContributionItemFactory.h b/Plugins/org.blueberry.ui.qt/src/actions/berryContributionItemFactory.h
index 6cd54e8dda..656bcc835d 100644
--- a/Plugins/org.blueberry.ui.qt/src/actions/berryContributionItemFactory.h
+++ b/Plugins/org.blueberry.ui.qt/src/actions/berryContributionItemFactory.h
@@ -1,134 +1,136 @@
/*===================================================================
BlueBerry Platform
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BERRYCONTRIBUTIONITEMFACTORY_H
#define BERRYCONTRIBUTIONITEMFACTORY_H
#include
#include
#include
namespace berry {
struct IContributionItem;
struct IWorkbenchWindow;
/**
* Access to standard contribution items provided by the workbench.
*
* Most of the functionality of this class is provided by
* static methods and fields.
* Example usage:
*
* MenuManager menu = ...;
* IContributionItem::Pointer reEdit
* = ContributionItemFactory::REOPEN_EDITORS->Create(window);
* menu->Add(reEdit);
*
*
*
* Clients may declare subclasses that provide additional application-specific
* contribution item factories.
*
*/
class BERRY_UI_QT ContributionItemFactory
{
private:
/**
* Id of contribution items created by this factory.
*/
const QString contributionItemId;
protected:
/**
* Creates a new workbench contribution item factory with the given id.
*
* @param contributionItemId the id of contribution items created by this factory
*/
ContributionItemFactory(const QString& contributionItemId);
public:
/**
* Creates a new standard contribution item for the given workbench window.
*
* A typical contribution item automatically registers listeners against the
* workbench window so that it can keep its enablement state up to date.
* Ordinarily, the window's references to these listeners will be dropped
* automatically when the window closes. However, if the client needs to get
* rid of a contribution item while the window is still open, the client must
* call IContributionItem#dispose to give the item an
* opportunity to deregister its listeners and to perform any other cleanup.
*
*
* @param window the workbench window
* @return the workbench contribution item
*/
virtual SmartPointer Create(IWorkbenchWindow* window) = 0;
/**
* Returns the id of this contribution item factory.
*
* @return the id of contribution items created by this factory
*/
QString GetId() const;
/**
* Workbench contribution item (id "openWindows"): A list of windows
* currently open in the workbench. Selecting one of the items makes the
* corresponding window the active window.
* This action dynamically maintains the list of windows.
*/
static const QScopedPointer OPEN_WINDOWS;
/**
* Workbench contribution item (id "viewsShortlist"): A list of views
* available to be opened in the window, arranged as a shortlist of
* promising views and an "Other" subitem. Selecting
* one of the items opens the corresponding view in the active window.
* This action dynamically maintains the view shortlist.
*/
static const QScopedPointer VIEWS_SHORTLIST;
/**
* Workbench contribution item (id "reopenEditors"): A list of recent
* editors (with inputs) available to be reopened in the window. Selecting
* one of the items reopens the corresponding editor on its input in the
* active window. This action dynamically maintains the list of editors.
*/
static const QScopedPointer REOPEN_EDITORS;
/**
* Workbench contribution item (id "perspectivesShortlist"): A list of
* perspectives available to be opened, arranged as a shortlist of
* promising perspectives and an "Other" subitem. Selecting
* one of the items makes the corresponding perspective active. Should a
* new perspective need to be opened, a workbench user preference controls
* whether the prespective is opened in the active window or a new window.
* This action dynamically maintains the perspectives shortlist.
*/
static const QScopedPointer PERSPECTIVES_SHORTLIST;
+ virtual ~ContributionItemFactory() = default;
+
};
}
#endif // BERRYCONTRIBUTIONITEMFACTORY_H
diff --git a/Plugins/org.blueberry.ui.qt/src/berryIElementFactory.h b/Plugins/org.blueberry.ui.qt/src/berryIElementFactory.h
index a3a821e884..8e22b87dd9 100644
--- a/Plugins/org.blueberry.ui.qt/src/berryIElementFactory.h
+++ b/Plugins/org.blueberry.ui.qt/src/berryIElementFactory.h
@@ -1,75 +1,75 @@
/*===================================================================
BlueBerry Platform
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BERRYIELEMENTFACTORY_H
#define BERRYIELEMENTFACTORY_H
#include
#include
namespace berry {
struct IAdaptable;
struct IMemento;
/**
* A factory for re-creating objects from a previously saved memento.
*
* Clients should implement this interface and include the name of their class
* in an extension to the platform extension point named
* "org.blueberry.ui.elementFactories"
.
* For example, the plug-in's XML markup might contain:
*
* <extension point="org.blueberry.ui.elementFactories">
* <factory id="com.example.myplugin.MyFactory" class="MyFactory" />
* </extension>
*
*
*
* @see IPersistableElement
* @see IMemento
* @see IWorkbench#GetElementFactory
*/
struct BERRY_UI_QT IElementFactory
{
- ~IElementFactory();
+ virtual ~IElementFactory();
/**
* Re-creates and returns an object from the state captured within the given
* memento.
*
* If the result is not null, it should be persistable; that is,
*
* result.getAdapter(org.eclipse.ui.IPersistableElement.class)
*
* should not return null
. The caller takes ownership of the
* result and must delete it when it is not needed any more.
*
*
* @param memento
* a memento containing the state for the object
* @return an object, or nullptr
if the element could not be
* created
*/
virtual IAdaptable* CreateElement(const SmartPointer& memento) = 0;
};
}
Q_DECLARE_INTERFACE(berry::IElementFactory, "org.blueberry.ui.IElementFactory")
#endif // BERRYIELEMENTFACTORY_H
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index d89a677015..fb9dbcfcf0 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,456 +1,453 @@
include(mitkFunctionInstallExternalCMakeProject)
#-----------------------------------------------------------------------------
# Convenient macro allowing to download a file
#-----------------------------------------------------------------------------
if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
endif()
macro(downloadFile url dest)
file(DOWNLOAD ${url} ${dest} STATUS status)
list(GET status 0 error_code)
list(GET status 1 error_msg)
if(error_code)
message(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}")
endif()
endmacro()
#-----------------------------------------------------------------------------
# MITK Prerequisites
#-----------------------------------------------------------------------------
if(UNIX AND NOT APPLE)
include(mitkFunctionCheckPackageHeader)
# Check for libxt-dev
mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/)
# Check for libtiff4-dev
mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev)
- # Check for libwrap0-dev
- mitkFunctionCheckPackageHeader(tcpd.h libwrap0-dev)
-
endif()
# We need a proper patch program. On Linux and MacOS, we assume
# that "patch" is available. On Windows, we download patch.exe
# if not patch program is found.
find_program(PATCH_COMMAND patch)
if((NOT PATCH_COMMAND OR NOT EXISTS ${PATCH_COMMAND}) AND WIN32)
downloadFile(${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/patch.exe
${CMAKE_CURRENT_BINARY_DIR}/patch.exe)
find_program(PATCH_COMMAND patch ${CMAKE_CURRENT_BINARY_DIR})
endif()
if(NOT PATCH_COMMAND)
message(FATAL_ERROR "No patch program found.")
endif()
#-----------------------------------------------------------------------------
# ExternalProjects
#-----------------------------------------------------------------------------
get_property(external_projects GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
if(MITK_CTEST_SCRIPT_MODE)
# Write a file containing the list of enabled external project targets.
# This file can be read by a ctest script to separately build projects.
set(SUPERBUILD_TARGETS )
foreach(proj ${external_projects})
if(MITK_USE_${proj})
list(APPEND SUPERBUILD_TARGETS ${proj})
endif()
endforeach()
file(WRITE "${CMAKE_BINARY_DIR}/SuperBuildTargets.cmake" "set(SUPERBUILD_TARGETS ${SUPERBUILD_TARGETS})")
endif()
# A list of "nice" external projects, playing well together with CMake
set(nice_external_projects ${external_projects})
list(REMOVE_ITEM nice_external_projects Boost Python)
foreach(proj ${nice_external_projects})
if(MITK_USE_${proj})
set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
mark_as_advanced(EXTERNAL_${proj}_DIR)
if(EXTERNAL_${proj}_DIR)
set(${proj}_DIR ${EXTERNAL_${proj}_DIR})
endif()
endif()
endforeach()
set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
mark_as_advanced(EXTERNAL_BOOST_ROOT)
if(EXTERNAL_BOOST_ROOT)
set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT})
endif()
# Setup file for setting custom ctest vars
configure_file(
CMake/SuperbuildCTestCustom.cmake.in
${MITK_BINARY_DIR}/CTestCustom.cmake
@ONLY
)
if(BUILD_TESTING)
set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory")
mark_as_advanced(EXTERNAL_MITK_DATA_DIR)
if(EXTERNAL_MITK_DATA_DIR)
set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR})
endif()
endif()
#-----------------------------------------------------------------------------
# External project settings
#-----------------------------------------------------------------------------
include(ExternalProject)
set(ep_prefix "${CMAKE_BINARY_DIR}/ep")
set_property(DIRECTORY PROPERTY EP_PREFIX ${ep_prefix})
# Compute -G arg for configuring external projects with the same CMake generator:
if(CMAKE_EXTRA_GENERATOR)
set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
else()
set(gen "${CMAKE_GENERATOR}")
endif()
# Use this value where semi-colons are needed in ep_add args:
set(sep "^^")
##
if(MSVC_VERSION)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
endif()
# This is a workaround for passing linker flags
# actually down to the linker invocation
set(_cmake_required_flags_orig ${CMAKE_REQUIRED_FLAGS})
set(CMAKE_REQUIRED_FLAGS "-Wl,-rpath")
mitkFunctionCheckCompilerFlags(${CMAKE_REQUIRED_FLAGS} _has_rpath_flag)
set(CMAKE_REQUIRED_FLAGS ${_cmake_required_flags_orig})
set(_install_rpath_linkflag )
if(_has_rpath_flag)
if(APPLE)
set(_install_rpath_linkflag "-Wl,-rpath,@loader_path/../lib")
else()
set(_install_rpath_linkflag "-Wl,-rpath='$ORIGIN/../lib'")
endif()
endif()
set(_install_rpath)
if(APPLE)
set(_install_rpath "@loader_path/../lib")
elseif(UNIX)
# this work for libraries as well as executables
set(_install_rpath "\$ORIGIN/../lib")
endif()
set(ep_common_args
-DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
-DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
-DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
-DCMAKE_MACOSX_RPATH:BOOL=TRUE
"-DCMAKE_INSTALL_RPATH:STRING=${_install_rpath}"
-DBUILD_TESTING:BOOL=OFF
-DCMAKE_INSTALL_PREFIX:PATH=
-DBUILD_SHARED_LIBS:BOOL=ON
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
-DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
"-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_CXX14_FLAG}"
#debug flags
-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
#release flags
-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
#relwithdebinfo
-DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
-DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
#link flags
-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS}
)
set(DCMTK_CMAKE_DEBUG_POSTFIX )
# python libraries wont work with it
if(NOT MITK_USE_Python)
list(APPEND ep_common_args -DCMAKE_DEBUG_POSTFIX:STRING=d)
set(DCMTK_CMAKE_DEBUG_POSTFIX d)
endif()
set(ep_common_cache_args
)
set(ep_common_cache_default_args
"-DCMAKE_PREFIX_PATH:PATH=;${CMAKE_PREFIX_PATH}"
"-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
"-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
)
# Pass the CMAKE_OSX variables to external projects
if(APPLE)
set(MAC_OSX_ARCHITECTURE_ARGS
-DCMAKE_OSX_ARCHITECTURES:PATH=${CMAKE_OSX_ARCHITECTURES}
-DCMAKE_OSX_DEPLOYMENT_TARGET:PATH=${CMAKE_OSX_DEPLOYMENT_TARGET}
-DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
)
set(ep_common_args
${MAC_OSX_ARCHITECTURE_ARGS}
${ep_common_args}
)
endif()
set(mitk_superbuild_ep_args)
set(mitk_depends )
# Include external projects
include(CMakeExternals/MITKData.cmake)
foreach(p ${external_projects})
if(EXISTS ${CMAKE_SOURCE_DIR}/CMakeExternals/${p}.cmake)
include(CMakeExternals/${p}.cmake)
else()
foreach(MITK_EXTENSION_DIR ${MITK_EXTENSION_DIRS})
get_filename_component(MITK_EXTENSION_DIR ${MITK_EXTENSION_DIR} ABSOLUTE)
set(MITK_CMAKE_EXTERNALS_EXTENSION_DIR ${MITK_EXTENSION_DIR}/CMakeExternals)
if(EXISTS ${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/${p}.cmake)
include(${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/${p}.cmake)
break()
endif()
endforeach()
endif()
list(APPEND mitk_superbuild_ep_args
-DMITK_USE_${p}:BOOL=${MITK_USE_${p}}
)
get_property(_package GLOBAL PROPERTY MITK_${p}_PACKAGE)
if(_package)
list(APPEND mitk_superbuild_ep_args -D${p}_DIR:PATH=${${p}_DIR})
endif()
list(APPEND mitk_depends ${${p}_DEPENDS})
endforeach()
if (SWIG_EXECUTABLE)
list(APPEND mitk_superbuild_ep_args -DSWIG_EXECUTABLE=${SWIG_EXECUTABLE})
endif()
#-----------------------------------------------------------------------------
# Set superbuild boolean args
#-----------------------------------------------------------------------------
set(mitk_cmake_boolean_args
BUILD_SHARED_LIBS
WITH_COVERAGE
BUILD_TESTING
MITK_BUILD_ALL_PLUGINS
MITK_BUILD_ALL_APPS
MITK_BUILD_EXAMPLES
MITK_USE_Qt5
MITK_USE_SYSTEM_Boost
MITK_USE_BLUEBERRY
MITK_USE_OpenCL
MITK_ENABLE_PIC_READER
)
#-----------------------------------------------------------------------------
# Create the final variable containing superbuild boolean args
#-----------------------------------------------------------------------------
set(mitk_superbuild_boolean_args)
foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
list(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
endforeach()
if(MITK_BUILD_ALL_PLUGINS)
list(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON)
endif()
#-----------------------------------------------------------------------------
# MITK Utilities
#-----------------------------------------------------------------------------
set(proj MITK-Utilities)
ExternalProject_Add(${proj}
DOWNLOAD_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
DEPENDS
${mitk_depends}
)
#-----------------------------------------------------------------------------
# Additional MITK CXX/C Flags
#-----------------------------------------------------------------------------
set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK")
set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK")
set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK")
mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE)
set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK")
set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK")
set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK")
mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE)
set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK")
set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK")
set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK")
mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS)
#-----------------------------------------------------------------------------
# MITK Configure
#-----------------------------------------------------------------------------
if(MITK_INITIAL_CACHE_FILE)
set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
endif()
set(mitk_optional_cache_args )
foreach(type RUNTIME ARCHIVE LIBRARY)
if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
endif()
endforeach()
# Optional python variables
if(MITK_USE_Python)
list(APPEND mitk_optional_cache_args
-DMITK_USE_Python:BOOL=${MITK_USE_Python}
-DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
-DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
-DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
-DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
)
endif()
if(Eigen_INCLUDE_DIR)
list(APPEND mitk_optional_cache_args
-DEigen_INCLUDE_DIR:PATH=${Eigen_INCLUDE_DIR}
)
endif()
set(proj MITK-Configure)
ExternalProject_Add(${proj}
LIST_SEPARATOR ${sep}
DOWNLOAD_COMMAND ""
CMAKE_GENERATOR ${gen}
CMAKE_CACHE_ARGS
# --------------- Build options ----------------
-DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
"-DCMAKE_PREFIX_PATH:PATH=${ep_prefix};${CMAKE_PREFIX_PATH}"
"-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
"-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
# --------------- Compile options ----------------
-DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
-DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
-DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
-DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
-DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
"-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}"
"-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}"
# debug flags
"-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}"
"-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}"
# release flags
"-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}"
"-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}"
# relwithdebinfo
-DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
-DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
# link flags
"-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}"
"-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}"
"-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}"
# Output directories
-DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
-DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
-DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
# ------------- Boolean build options --------------
${mitk_superbuild_boolean_args}
${mitk_optional_cache_args}
-DMITK_USE_SUPERBUILD:BOOL=OFF
-DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
-DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
# ----------------- Miscellaneous ---------------
-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}
-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}
-DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
-DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
-DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD}
-DMITK_WHITELIST:STRING=${MITK_WHITELIST}
-DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH}
-DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH}
-DMITK_EXTENSION_DIRS:STRING=${MITK_EXTENSION_DIRS}
-DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
-DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
-DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
-DMITK_ACCESSBYITK_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
-DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
# --------------- External project options ---------------
-DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
-DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix}
-DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
-DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=${DCMTK_CMAKE_DEBUG_POSTFIX}
-DBOOST_ROOT:PATH=${BOOST_ROOT}
-DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
-DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
-DQt5_DIR:PATH=${Qt5_DIR}
CMAKE_ARGS
${mitk_initial_cache_arg}
${MAC_OSX_ARCHITECTURE_ARGS}
${mitk_superbuild_ep_args}
SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
BUILD_COMMAND ""
INSTALL_COMMAND ""
DEPENDS
MITK-Utilities
)
mitkFunctionInstallExternalCMakeProject(${proj})
#-----------------------------------------------------------------------------
# MITK
#-----------------------------------------------------------------------------
if(CMAKE_GENERATOR MATCHES ".*Makefiles.*")
set(mitk_build_cmd "$(MAKE)")
else()
set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR})
endif()
if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
set(MITKBUILD_TARGET_ALL_OPTION "ALL")
else()
set(MITKBUILD_TARGET_ALL_OPTION "")
endif()
add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION}
COMMAND ${mitk_build_cmd}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
DEPENDS MITK-Configure
)
#-----------------------------------------------------------------------------
# Custom target allowing to drive the build of the MITK project itself
#-----------------------------------------------------------------------------
add_custom_target(MITK
COMMAND ${mitk_build_cmd}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
)