diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
index 6e7bccd182..f1e55fa6ac 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
@@ -1,220 +1,220 @@
/*===================================================================
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 __itkDiffusionMultiShellQballReconstructionImageFilter_h_
#define __itkDiffusionMultiShellQballReconstructionImageFilter_h_
#include <itkImageToImageFilter.h>
namespace itk{
/** \class DiffusionMultiShellQballReconstructionImageFilter
I. Aganj, C. Lenglet, G. Sapiro, E. Yacoub, K. Ugurbil, and N. Harel, “Reconstruction of the orientation distribution function in single and multiple shell q-ball imaging within constant solid angle,” Magnetic Resonance in Medicine, vol. 64, no. 2, pp. 554–566, 2010.
*/
template< class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
class DiffusionMultiShellQballReconstructionImageFilter : public ImageToImageFilter< Image< TReferenceImagePixelType, 3 >, Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
{
public:
typedef DiffusionMultiShellQballReconstructionImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< TReferenceImagePixelType, 3>, Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > > Superclass;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef TReferenceImagePixelType ReferencePixelType;
/** GradientImageType
* (e.g. type short)*/
typedef TGradientImagePixelType GradientPixelType;
/** GradientImageType
* 3D VectorImage containing GradientPixelTypes */
typedef VectorImage< GradientPixelType, 3 > GradientImagesType;
/** ODF PixelType */
typedef Vector< TOdfPixelType, NrOdfDirections > OdfPixelType;
/** ODF ImageType */
typedef Image< OdfPixelType, 3 > OdfImageType;
/** BzeroImageType */
typedef Image< TOdfPixelType, 3 > BZeroImageType;
/** Container to hold gradient directions of the 'n' DW measurements */
typedef VectorContainer< unsigned int, vnl_vector_fixed< double, 3 > > GradientDirectionContainerType;
typedef Image< Vector< TOdfPixelType, (NOrderL*NOrderL + NOrderL + 2)/2 + NOrderL >, 3 > CoefficientImageType;
typedef std::map<unsigned int, std::vector<unsigned int> > BValueMap;
typedef std::map<unsigned int, std::vector<unsigned int> >::iterator BValueMapIteraotr;
typedef std::vector<unsigned int> IndiciesVector;
// --------------------------------------------------------------------------------------------//
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(DiffusionMultiShellQballReconstructionImageFilter, ImageToImageFilter)
/** Get reference image */
virtual typename Superclass::InputImageType * GetInputImage()
{ return ( static_cast< typename Superclass::InputImageType *>(this->ProcessObject::GetInput(0)) ); }
/** Replaces the Input method.
- * Var vols = mitk::DiffusionImage<type>
+ * Var vols = mitk::Image
* -----------------------------------------------------
- * GradientDirectionContainerType-Input gradientDirectionContainer (e.g. vols->GetDirections)
- * GradientImagesType-Input gradientImage (e.g. vols->GetVectorImage)
- * float-Input bvalue (e.g. vols->GetB_Value) */
+ * GradientDirectionContainerType-Input gradientDirectionContainer (e.g. GradientDirectionsContainerProperty)
+ * GradientImagesType-Input gradientImage (e.g. itkVectorImage)
+ * float-Input bvalue (e.g. ReferenceBValueProperty) */
void SetGradientImage( const GradientDirectionContainerType * gradientDirectionContainer, const GradientImagesType *gradientImage , float bvalue);//, std::vector<bool> listOfUserSelctedBValues );
/** Set a BValue Map (key = bvalue, value = indicies splittet for each shell)
* If the input image containes more than three q-shells
* (e.g. b-Values of 0, 1000, 2000, 3000, 4000, ...).
* For the Analytical-Reconstruction it is needed to set a
* BValue Map containing three shells in an arithmetic series
* (e.g. 0, 1000, 2000, 3000).
*/
inline void SetBValueMap(BValueMap map){this->m_BValueMap = map;}
/** Threshold on the reference image data. The output ODF will be a null
* pdf for pixels in the reference image that have a value less than this
* threshold. */
itkSetMacro( Threshold, ReferencePixelType )
itkGetMacro( Threshold, ReferencePixelType )
itkGetMacro( CoefficientImage, typename CoefficientImageType::Pointer )
/** Return non-diffusion weighted images */
itkGetMacro( BZeroImage, typename BZeroImageType::Pointer)
/** Factor for Laplacian-Baltrami smoothing of the SH-coefficients*/
itkSetMacro( Lambda, double )
itkGetMacro( Lambda, double )
protected:
DiffusionMultiShellQballReconstructionImageFilter();
~DiffusionMultiShellQballReconstructionImageFilter() { }
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType NumberOfThreads );
private:
enum ReconstructionType
{
Mode_Analytical3Shells,
Mode_NumericalNShells,
Mode_Standard1Shell
};
ReconstructionType m_ReconstructionType;
// Interpolation
bool m_Interpolation_Flag;
vnl_matrix< double > * m_Interpolation_SHT1_inv;
vnl_matrix< double > * m_Interpolation_SHT2_inv;
vnl_matrix< double > * m_Interpolation_SHT3_inv;
vnl_matrix< double > * m_TARGET_SH_shell1;
vnl_matrix< double > * m_TARGET_SH_shell2;
vnl_matrix< double > * m_TARGET_SH_shell3;
unsigned int m_MaxDirections;
vnl_matrix< double > * m_CoeffReconstructionMatrix;
vnl_matrix< double > * m_ODFSphericalHarmonicBasisMatrix;
/** container to hold gradient directions */
GradientDirectionContainerType::Pointer m_GradientDirectionContainer;
/** Number of gradient measurements */
unsigned int m_NumberOfGradientDirections;
/** Number of baseline images */
unsigned int m_NumberOfBaselineImages;
/** Threshold on the reference image data */
ReferencePixelType m_Threshold;
typename BZeroImageType::Pointer m_BZeroImage;
typename CoefficientImageType::Pointer m_CoefficientImage;
float m_BValue;
BValueMap m_BValueMap;
double m_Lambda;
bool m_IsHemisphericalArrangementOfGradientDirections;
bool m_IsArithmeticProgession;
void ComputeReconstructionMatrix(IndiciesVector const & refVector);
void ComputeODFSHBasis();
bool CheckDuplicateDiffusionGradients();
bool CheckForDifferingShellDirections();
IndiciesVector GetAllDirections();
void ComputeSphericalHarmonicsBasis(vnl_matrix<double>* QBallReference, vnl_matrix<double>* SHBasisOutput, int Lorder , vnl_matrix<double>* LaplaciaBaltramiOutput =0 , vnl_vector<int>* SHOrderAssociation =0 , vnl_matrix<double> * SHEigenvalues =0);
void Normalize(OdfPixelType & odf );
void S_S0Normalization( vnl_vector<double> & vec, double b0 = 0 );
void DoubleLogarithm(vnl_vector<double> & vec);
double CalculateThreashold(const double value, const double delta);
void Projection1(vnl_vector<double> & vec, double delta = 0.01);
void Projection2( vnl_vector<double> & E1, vnl_vector<double> & E2, vnl_vector<double> & E3, double delta = 0.01);
void Projection3( vnl_vector<double> & A, vnl_vector<double> & alpha, vnl_vector<double> & beta, double delta = 0.01);
void StandardOneShellReconstruction(const OutputImageRegionType& outputRegionForThread);
void AnalyticalThreeShellReconstruction(const OutputImageRegionType& outputRegionForThread);
void NumericalNShellReconstruction(const OutputImageRegionType& outputRegionForThread);
void GenerateAveragedBZeroImage(const OutputImageRegionType& outputRegionForThread);
void ComputeSphericalFromCartesian(vnl_matrix<double> * Q, const IndiciesVector & refShell);
//------------------------- VNL-function ------------------------------------
template<typename CurrentValue, typename WntValue>
vnl_vector< WntValue> element_cast (vnl_vector< CurrentValue> const& v1)
{
vnl_vector<WntValue> result(v1.size());
for(unsigned int i = 0 ; i < v1.size(); i++)
result[i] = static_cast< WntValue>(v1[i]);
return result;
}
template<typename type>
double dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 )
{
double result = (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) / (v1.two_norm() * v2.two_norm());
return result ;
}
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDiffusionMultiShellQballReconstructionImageFilter.cpp"
#endif
#endif //__itkDiffusionMultiShellQballReconstructionImageFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
index 32bccf0800..f465a7c29c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
@@ -1,117 +1,116 @@
/*===================================================================
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 __mitkTeemDiffusionTensor3DReconstructionImageFilter_h__
#define __mitkTeemDiffusionTensor3DReconstructionImageFilter_h__
#include "mitkImage.h"
#include "mitkTensorImage.h"
-#include "mitkDiffusionImage.h"
#include "itkDiffusionTensor3D.h"
namespace mitk
{
enum TeemTensorEstimationMethods{
TeemTensorEstimationMethodsLLS,
TeemTensorEstimationMethodsNLS,
TeemTensorEstimationMethodsWLS,
TeemTensorEstimationMethodsMLE,
};
template< class DiffusionImagePixelType = short,
class TTensorPixelType=float >
class TeemDiffusionTensor3DReconstructionImageFilter : public itk::Object
{
public:
typedef TTensorPixelType TensorPixelType;
typedef itk::Vector<TensorPixelType,7> VectorType;
typedef itk::Image<VectorType,3> VectorImageType;
typedef itk::DiffusionTensor3D<TensorPixelType> TensorType;
typedef itk::Image<TensorType,3 > ItkTensorImageType;
typedef itk::Vector<TensorPixelType,6> ItkTensorVectorType;
typedef itk::Image<ItkTensorVectorType,3> ItkTensorVectorImageType;
typedef DiffusionImagePixelType DiffusionPixelType;
typedef itk::VectorImage< DiffusionPixelType, 3 > DiffusionImageType;
mitkClassMacro( TeemDiffusionTensor3DReconstructionImageFilter,
itk::Object );
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkGetMacro(Input,
- typename DiffusionImage<DiffusionImagePixelType>::Pointer);
+ mitk::Image::Pointer);
itkSetMacro(Input,
- typename DiffusionImage<DiffusionImagePixelType>::Pointer);
+ mitk::Image::Pointer);
itkGetMacro(EstimateErrorImage, bool);
itkSetMacro(EstimateErrorImage, bool);
itkGetMacro(Sigma, float);
itkSetMacro(Sigma, float);
itkGetMacro(EstimationMethod, TeemTensorEstimationMethods);
itkSetMacro(EstimationMethod, TeemTensorEstimationMethods);
itkGetMacro(NumIterations, int);
itkSetMacro(NumIterations, int);
itkGetMacro(ConfidenceThreshold, double);
itkSetMacro(ConfidenceThreshold, double);
itkGetMacro(ConfidenceFuzzyness, float);
itkSetMacro(ConfidenceFuzzyness, float);
itkGetMacro(MinPlausibleValue, double);
itkSetMacro(MinPlausibleValue, double);
itkGetMacro(Output, mitk::TensorImage::Pointer);
itkGetMacro(OutputItk, mitk::TensorImage::Pointer);
// do the work
virtual void Update();
protected:
TeemDiffusionTensor3DReconstructionImageFilter();
virtual ~TeemDiffusionTensor3DReconstructionImageFilter();
- typename DiffusionImage<DiffusionImagePixelType>::Pointer m_Input;
+ mitk::Image::Pointer m_Input;
bool m_EstimateErrorImage;
float m_Sigma;
TeemTensorEstimationMethods m_EstimationMethod;
int m_NumIterations;
double m_ConfidenceThreshold;
float m_ConfidenceFuzzyness;
double m_MinPlausibleValue;
mitk::TensorImage::Pointer m_Output;
mitk::TensorImage::Pointer m_OutputItk;
mitk::Image::Pointer m_ErrorImage;
};
}
#include "mitkTeemDiffusionTensor3DReconstructionImageFilter.cpp"
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
index d11c505925..3f6fbc61a9 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
@@ -1,327 +1,316 @@
/*===================================================================
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 MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
-#define MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
+#ifndef MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
+#define MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
#include "mitkDWIHeadMotionCorrectionFilter.h"
#include "itkSplitDWImageFilter.h"
#include "itkB0ImageExtractionToSeparateImageFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkPyramidImageRegistrationMethod.h"
//#include "mitkRegistrationMethodITK4.h"
-#include "mitkImageToDiffusionImageSource.h"
+#include <mitkDiffusionPropertyHelper.h>
#include "mitkDiffusionImageCorrectionFilter.h"
#include <mitkImageWriteAccessor.h>
+#include <mitkProperties.h>
#include <vector>
#include "mitkIOUtil.h"
#include <itkImage.h>
-template< typename DiffusionPixelType>
-mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>
- ::DWIHeadMotionCorrectionFilter()
+mitk::DWIHeadMotionCorrectionFilter::DWIHeadMotionCorrectionFilter()
: m_CurrentStep(0),
m_Steps(100),
m_IsInValidState(true),
m_AbortRegistration(false),
m_AverageUnweighted(true)
{
}
-template< typename DiffusionPixelType>
-void mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>
-::GenerateData()
+
+void mitk::DWIHeadMotionCorrectionFilter::GenerateData()
{
typedef itk::SplitDWImageFilter< DiffusionPixelType, DiffusionPixelType> SplitFilterType;
- DiffusionImageType* input = const_cast<DiffusionImageType*>(this->GetInput(0));
+ InputImageType* input = const_cast<InputImageType*>(this->GetInput(0));
+
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(input, itkVectorImagePointer);
typedef mitk::PyramidImageRegistrationMethod RegistrationMethod;
// typedef mitk::RegistrationMethodITKV4 RegistrationMethod
-
- unsigned int numberOfSteps = input->GetVectorImage()->GetNumberOfComponentsPerPixel () ;
+ unsigned int numberOfSteps = itkVectorImagePointer->GetNumberOfComponentsPerPixel () ;
m_Steps = numberOfSteps;
//
// (1) Extract the b-zero images to a 3d+t image, register them by NCorr metric and
// rigid registration : they will then be used are reference image for registering
// the gradient images
//
typedef itk::B0ImageExtractionToSeparateImageFilter< DiffusionPixelType, DiffusionPixelType> B0ExtractorType;
- typename B0ExtractorType::Pointer b0_extractor = B0ExtractorType::New();
- b0_extractor->SetInput( input->GetVectorImage() );
- b0_extractor->SetDirections( input->GetDirections() );
+ B0ExtractorType::Pointer b0_extractor = B0ExtractorType::New();
+ b0_extractor->SetInput( itkVectorImagePointer );
+ b0_extractor->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( input->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
b0_extractor->Update();
mitk::Image::Pointer b0Image = mitk::Image::New();
b0Image->InitializeByItk( b0_extractor->GetOutput() );
b0Image->SetImportChannel( b0_extractor->GetOutput()->GetBufferPointer(),
mitk::Image::CopyMemory );
// (2.1) Use the extractor to access the extracted b0 volumes
mitk::ImageTimeSelector::Pointer t_selector =
mitk::ImageTimeSelector::New();
t_selector->SetInput( b0Image );
t_selector->SetTimeNr(0);
t_selector->Update();
// first unweighted image as reference space for the registration
mitk::Image::Pointer b0referenceImage = t_selector->GetOutput();
const unsigned int numberOfb0Images = b0Image->GetTimeSteps();
// register b-zeros only if the flag to average is set, use the first one otherwise
if( m_AverageUnweighted && numberOfb0Images > 1)
{
RegistrationMethod::Pointer registrationMethod = RegistrationMethod::New();
registrationMethod->SetFixedImage( b0referenceImage );
registrationMethod->SetTransformToRigid();
// the unweighted images are of same modality
registrationMethod->SetCrossModalityOff();
// use the advanced (windowed sinc) interpolation
registrationMethod->SetUseAdvancedInterpolation(true);
// Initialize the temporary output image
mitk::Image::Pointer registeredB0Image = b0Image->Clone();
mitk::ImageTimeSelector::Pointer t_selector2 =
mitk::ImageTimeSelector::New();
t_selector2->SetInput( b0Image );
for( unsigned int i=1; i<numberOfb0Images; i++)
{
m_CurrentStep = i + 1;
if( m_AbortRegistration == true) {
m_IsInValidState = false;
mitkThrow() << "Stopped by user.";
};
t_selector2->SetTimeNr(i);
t_selector2->Update();
registrationMethod->SetMovingImage( t_selector2->GetOutput() );
try
{
MITK_INFO << " === (" << i <<"/"<< numberOfb0Images-1 << ") :: Starting registration";
registrationMethod->Update();
}
catch( const itk::ExceptionObject& e)
{
m_IsInValidState = false;
mitkThrow() << "Failed to register the b0 images, the PyramidRegistration threw an exception: \n" << e.what();
}
// import volume to the inter-results
mitk::ImageWriteAccessor imac(registrationMethod->GetResampledMovingImage());
registeredB0Image->SetImportVolume( imac.GetData(),
i, 0, mitk::Image::ReferenceMemory );
}
// use the accumulateImageFilter as provided by the ItkAccumulateFilter method in the header file
AccessFixedDimensionByItk_1(registeredB0Image, ItkAccumulateFilter, (4), b0referenceImage );
}
//
// (2) Split the diffusion image into a 3d+t regular image, extract only the weighted images
//
- typename SplitFilterType::Pointer split_filter = SplitFilterType::New();
- split_filter->SetInput (input->GetVectorImage() );
- split_filter->SetExtractAllAboveThreshold(8, input->GetBValueMap() );
+ SplitFilterType::Pointer split_filter = SplitFilterType::New();
+ split_filter->SetInput (itkVectorImagePointer );
+ split_filter->SetExtractAllAboveThreshold(8, static_cast<mitk::BValueMapProperty*>(input->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap() );
try
{
split_filter->Update();
}
catch( const itk::ExceptionObject &e)
{
m_IsInValidState = false;
mitkThrow() << " Caught exception from SplitImageFilter : " << e.what();
}
mitk::Image::Pointer splittedImage = mitk::Image::New();
splittedImage->InitializeByItk( split_filter->GetOutput() );
splittedImage->SetImportChannel( split_filter->GetOutput()->GetBufferPointer(),
mitk::Image::CopyMemory );
//
// (3) Use again the time-selector to access the components separately in order
// to perform the registration of Image -> unweighted reference
//
RegistrationMethod::Pointer weightedRegistrationMethod
= RegistrationMethod::New();
weightedRegistrationMethod->SetTransformToAffine();
weightedRegistrationMethod->SetCrossModalityOn();
//
// - (3.1) Set the reference image
// - a single b0 image
// - average over the registered b0 images if multiple present
//
weightedRegistrationMethod->SetFixedImage( b0referenceImage );
// use the advanced (windowed sinc) interpolation
weightedRegistrationMethod->SetUseAdvancedInterpolation(true);
weightedRegistrationMethod->SetVerboseOn();
//
// - (3.2) Register all timesteps in the splitted image onto the first reference
//
unsigned int maxImageIdx = splittedImage->GetTimeSteps();
mitk::TimeGeometry* tsg = splittedImage->GetTimeGeometry();
mitk::ProportionalTimeGeometry* ptg = dynamic_cast<ProportionalTimeGeometry*>(tsg);
ptg->Expand(maxImageIdx+1);
ptg->SetTimeStepGeometry( ptg->GetGeometryForTimeStep(0), maxImageIdx );
mitk::Image::Pointer registeredWeighted = mitk::Image::New();
registeredWeighted->Initialize( splittedImage->GetPixelType(0), *tsg );
// insert the first unweighted reference as the first volume
// in own scope to release the accessor asap after copy
{
mitk::ImageWriteAccessor imac(b0referenceImage);
registeredWeighted->SetImportVolume( imac.GetData(),
0,0, mitk::Image::CopyMemory );
}
// mitk::Image::Pointer registeredWeighted = splittedImage->Clone();
// this time start at 0, we have only gradient images in the 3d+t file
// the reference image comes form an other image
mitk::ImageTimeSelector::Pointer t_selector_w =
mitk::ImageTimeSelector::New();
t_selector_w->SetInput( splittedImage );
// store the rotation parts of the transformations in a vector
typedef RegistrationMethod::TransformMatrixType MatrixType;
std::vector< MatrixType > estimated_transforms;
for( unsigned int i=0; i<maxImageIdx; i++)
{
m_CurrentStep = numberOfb0Images + i + 1;
if( m_AbortRegistration == true) {
m_IsInValidState = false;
mitkThrow() << "Stopped by user.";
};
t_selector_w->SetTimeNr(i);
t_selector_w->Update();
weightedRegistrationMethod->SetMovingImage( t_selector_w->GetOutput() );
try
{
MITK_INFO << " === (" << i+1 <<"/"<< maxImageIdx << ") :: Starting registration";
weightedRegistrationMethod->Update();
}
catch( const itk::ExceptionObject& e)
{
m_IsInValidState = false;
mitkThrow() << "Failed to register the b0 images, the PyramidRegistration threw an exception: \n" << e.what();
}
// allow expansion
mitk::ImageWriteAccessor imac(weightedRegistrationMethod->GetResampledMovingImage());
registeredWeighted->SetImportVolume( imac.GetData(),
i+1, 0, mitk::Image::CopyMemory);
estimated_transforms.push_back( weightedRegistrationMethod->GetLastRotationMatrix() );
}
//
// (4) Cast the resulting image back to an diffusion weighted image
//
- typename DiffusionImageType::GradientDirectionContainerType *gradients = input->GetDirections();
- typename DiffusionImageType::GradientDirectionContainerType::Pointer gradients_new =
- DiffusionImageType::GradientDirectionContainerType::New();
- typename DiffusionImageType::GradientDirectionType bzero_vector;
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType *gradients = static_cast<mitk::GradientDirectionsProperty*>( input->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradients_new =
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
+ mitk::DiffusionPropertyHelper::GradientDirectionType bzero_vector;
bzero_vector.fill(0);
// compose the direction vector
// - no direction for the first image
// - correct ordering of the directions based on the index list
gradients_new->push_back( bzero_vector );
- typename SplitFilterType::IndexListType index_list = split_filter->GetIndexList();
- typename SplitFilterType::IndexListType::const_iterator lIter = index_list.begin();
+ SplitFilterType::IndexListType index_list = split_filter->GetIndexList();
+ SplitFilterType::IndexListType::const_iterator lIter = index_list.begin();
while( lIter != index_list.end() )
{
gradients_new->push_back( gradients->at( *lIter ) );
++lIter;
}
- typename mitk::ImageToDiffusionImageSource< DiffusionPixelType >::Pointer caster =
- mitk::ImageToDiffusionImageSource< DiffusionPixelType >::New();
-
- caster->SetImage( registeredWeighted );
- caster->SetBValue( input->GetReferenceBValue() );
- caster->SetGradientDirections( gradients_new.GetPointer() );
-
- try
- {
- caster->Update();
- }
- catch( const itk::ExceptionObject& e)
- {
- m_IsInValidState = false;
- MITK_ERROR << "Casting back to diffusion image failed: ";
- mitkThrow() << "Subprocess failed with exception: " << e.what();
- }
+ registeredWeighted->SetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradients_new.GetPointer() ));
+ registeredWeighted->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(input->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
//
// (5) Adapt the gradient directions according to the estimated transforms
//
- typedef mitk::DiffusionImageCorrectionFilter< DiffusionPixelType > CorrectionFilterType;
- typename CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
+ typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
+ CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
- OutputImagePointerType output = caster->GetOutput();
+ mitk::Image::Pointer output = registeredWeighted;
corrector->SetImage( output );
corrector->CorrectDirections( estimated_transforms );
//
// (6) Pass the corrected image to the filters output port
//
m_CurrentStep += 1;
- this->GetOutput()->SetVectorImage(output->GetVectorImage());
- this->GetOutput()->SetReferenceBValue(output->GetReferenceBValue());
- this->GetOutput()->SetMeasurementFrame(output->GetMeasurementFrame());
- this->GetOutput()->SetDirections(output->GetDirections());
- this->GetOutput()->InitializeFromVectorImage();
+
+ this->GetOutput()->Initialize( output );
+
+ this->GetOutput()->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( output->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+ this->GetOutput()->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>( output->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ this->GetOutput()->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(output->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+
+ mitk::DiffusionPropertyHelper propertyHelper( this->GetOutput() );
+ propertyHelper.InitializeImage();
this->GetOutput()->Modified();
}
-#endif // MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
+#endif // MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
index d8065ff27d..e159597b08 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
@@ -1,132 +1,131 @@
/*===================================================================
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 MITKDWIHEADMOTIONCORRECTIONFILTER_H
#define MITKDWIHEADMOTIONCORRECTIONFILTER_H
-#include "mitkDiffusionImageToDiffusionImageFilter.h"
+#include "mitkImageToImageFilter.h"
#include <itkAccumulateImageFilter.h>
#include <itkExtractImageFilter.h>
#include "mitkITKImageImport.h"
+#include <itkVectorImage.h>
+#include <MitkDiffusionCoreExports.h>
namespace mitk
{
/**
* @class DWIHeadMotionCorrectionFilter
*
* @brief Performs standard head-motion correction by using affine registration of the gradient images.
*
* (Head) motion correction is a essential pre-processing step before performing any further analysis of a diffusion-weighted
* images since all model fits ( tensor, QBI ) rely on an aligned diffusion-weighted dataset. The correction is done in two steps. First the
* unweighted images ( if multiple present ) are separately registered on the first one by means of rigid registration and normalized correlation
* as error metric. Second, the weighted gradient images are registered to the unweighted reference ( computed as average from the aligned images from first step )
* by an affine transformation using the MattesMutualInformation metric as optimizer guidance.
*
*/
-template< typename DiffusionPixelType>
-class DWIHeadMotionCorrectionFilter
- : public DiffusionImageToDiffusionImageFilter< DiffusionPixelType >
+
+class MitkDiffusionCore_EXPORT DWIHeadMotionCorrectionFilter
+ : public ImageToImageFilter
{
public:
// class macros
mitkClassMacro( DWIHeadMotionCorrectionFilter,
- DiffusionImageToDiffusionImageFilter<DiffusionPixelType> )
+ ImageToImageFilter )
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkGetMacro( Steps, unsigned long )
itkGetMacro( CurrentStep, unsigned long )
itkGetMacro( IsInValidState, bool)
itkSetMacro( AbortRegistration, bool )
itkSetMacro( AverageUnweighted, bool )
// public typedefs
- typedef typename Superclass::InputImageType DiffusionImageType;
- typedef typename Superclass::InputImagePointerType DiffusionImagePointerType;
-
- typedef typename Superclass::OutputImageType OutputImageType;
- typedef typename Superclass::OutputImagePointerType OutputImagePointerType;
+ typedef short DiffusionPixelType;
+ typedef Superclass::InputImageType InputImageType;
+ typedef Superclass::OutputImageType OutputImageType;
+ typedef itk::VectorImage<DiffusionPixelType, 3> ITKDiffusionImageType;
protected:
DWIHeadMotionCorrectionFilter();
virtual ~DWIHeadMotionCorrectionFilter() {}
virtual void GenerateData();
unsigned long m_CurrentStep;
unsigned long m_Steps;
bool m_IsInValidState; ///< Whether the filter is in a valid state, false if error occured
bool m_AbortRegistration; ///< set flag to abort
bool m_AverageUnweighted;
};
/**
* @brief Averages an 3d+t image along the time axis.
*
* The method uses the AccumulateImageFilter as provided by ITK and collapses the given 3d+t image
* to an 3d image while computing the average over the time axis for each of the spatial voxels.
*/
template< typename TPixel, unsigned int VDimensions>
static void ItkAccumulateFilter(
const itk::Image< TPixel, VDimensions>* image,
mitk::Image::Pointer& output)
{
// input 3d+t --> output 3d
typedef itk::Image< TPixel, 4> InputItkType;
typedef itk::Image< TPixel, 3> OutputItkType;
// the accumulate filter requires the same dimension in output and input image
typedef typename itk::AccumulateImageFilter< InputItkType, InputItkType > FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput( image );
filter->SetAccumulateDimension( 3 );
filter->SetAverage( true );
// we need to extract the volume to reduce the size from 4 to 3 for further processing
typedef typename itk::ExtractImageFilter< InputItkType, OutputItkType > ExtractFilterType;
typename ExtractFilterType::Pointer extractor = ExtractFilterType::New();
extractor->SetInput( filter->GetOutput() );
extractor->SetDirectionCollapseToIdentity();
typename InputItkType::RegionType extractRegion = image->GetLargestPossibleRegion();
// crop out the time axis
extractRegion.SetSize( 3, 0);
extractor->SetExtractionRegion( extractRegion );
try
{
extractor->Update();
}
catch( const itk::ExceptionObject& e)
{
mitkThrow() << " Exception while averaging: " << e.what();
}
output = mitk::GrabItkImageMemory( extractor->GetOutput() );
}
} //end namespace mitk
-#include "mitkDWIHeadMotionCorrectionFilter.cpp"
-
#endif // MITKDWIHEADMOTIONCORRECTIONFILTER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp
index 0e1982705b..2f488f4334 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp
@@ -1,196 +1,216 @@
#include "mitkRegistrationWrapper.h"
#include "mitkPyramidImageRegistrationMethod.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
#include <mitkDiffusionImageCorrectionFilter.h>
#include "itkB0ImageExtractionImageFilter.h"
#include <itkResampleImageFilter.h>
#include <itkWindowedSincInterpolateImageFunction.h>
#include <itkLinearInterpolateImageFunction.h>
#include <itkNearestNeighborExtrapolateImageFunction.h>
#include <itkBSplineInterpolateImageFunction.h>
+#include <mitkDiffusionPropertyHelper.h>
#include <vnl/vnl_inverse.h>
void mitk::RegistrationWrapper::ApplyTransformationToImage(mitk::Image::Pointer img, const mitk::RegistrationWrapper::RidgidTransformType &transformation,double* offset, mitk::Image* resampleReference, bool binary)
{
- typedef mitk::DiffusionImage<short> DiffusionImageType;
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientDirections =
+ static_cast<mitk::GradientDirectionsProperty*>( img->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
- if (dynamic_cast<DiffusionImageType*> (img.GetPointer()) == NULL)
+ if (gradientDirections.IsNull() || ( gradientDirections->Size() == 0) )
{
ItkImageType::Pointer itkImage = ItkImageType::New();
CastToItkImage(img, itkImage);
typedef itk::Euler3DTransform< double > RigidTransformType;
RigidTransformType::Pointer rtransform = RigidTransformType::New();
RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension);
for (int i = 0; i<6;++i)
parameters[i] = transformation[i];
rtransform->SetParameters( parameters );
mitk::Point3D origin = itkImage->GetOrigin();
origin[0]-=offset[0];
origin[1]-=offset[1];
origin[2]-=offset[2];
mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(origin);
itk::Matrix<double,3,3> dir = itkImage->GetDirection();
itk::Matrix<double,3,3> transM ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix()));
itk::Matrix<double,3,3> newDirection = transM * dir;
itkImage->SetOrigin(newOrigin);
itkImage->SetDirection(newDirection);
// Perform Resampling if reference image is provided
if (resampleReference != NULL)
{
typedef itk::ResampleImageFilter<ItkImageType, ItkImageType> ResampleFilterType;
ItkImageType::Pointer itkReference = ItkImageType::New();
CastToItkImage(resampleReference,itkReference);
typedef itk::Function::WelchWindowFunction<4> WelchWindowFunction;
typedef itk::WindowedSincInterpolateImageFunction< ItkImageType, 4,WelchWindowFunction> WindowedSincInterpolatorType;
WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
typedef itk::LinearInterpolateImageFunction< ItkImageType> LinearInterpolatorType;
LinearInterpolatorType::Pointer lin_interpolator = LinearInterpolatorType::New();
typedef itk::NearestNeighborInterpolateImageFunction< ItkImageType, double > NearestNeighborInterpolatorType;
NearestNeighborInterpolatorType::Pointer nn_interpolator = NearestNeighborInterpolatorType::New();
typedef itk::BSplineInterpolateImageFunction< ItkImageType, double > BSplineInterpolatorType;
BSplineInterpolatorType::Pointer bSpline_interpolator = BSplineInterpolatorType::New();
ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetInput(itkImage);
resampler->SetReferenceImage( itkReference );
resampler->UseReferenceImageOn();
if (binary)
resampler->SetInterpolator(nn_interpolator);
else
resampler->SetInterpolator(lin_interpolator);
resampler->Update();
GrabItkImageMemory(resampler->GetOutput(), img);
}
else
{
// !! CastToItk behaves very differently depending on the original data type
// if the target type is the same as the original, only a pointer to the data is set
// and an additional GrabItkImageMemory will cause a segfault when the image is destroyed
// GrabItkImageMemory - is not necessary in this case since we worked on the original data
// See Bug 17538.
if (img->GetPixelType().GetComponentTypeAsString() != "double")
img = GrabItkImageMemory(itkImage);
}
}
else
{
- DiffusionImageType::Pointer diffImages = dynamic_cast<DiffusionImageType*>(img.GetPointer());
+ mitk::Image::Pointer diffImages = dynamic_cast<mitk::Image*>(img.GetPointer());
typedef itk::Euler3DTransform< double > RigidTransformType;
RigidTransformType::Pointer rtransform = RigidTransformType::New();
RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension);
for (int i = 0; i<6;++i)
{
parameters[i] = transformation[i];
}
rtransform->SetParameters( parameters );
- mitk::Point3D b0origin = diffImages->GetVectorImage()->GetOrigin();
+ typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(diffImages, itkVectorImagePointer);
+
+ mitk::Point3D b0origin = itkVectorImagePointer->GetOrigin();
b0origin[0]-=offset[0];
b0origin[1]-=offset[1];
b0origin[2]-=offset[2];
mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(b0origin);
- itk::Matrix<double,3,3> dir = diffImages->GetVectorImage()->GetDirection();
+ itk::Matrix<double,3,3> dir = itkVectorImagePointer->GetDirection();
itk::Matrix<double,3,3> transM ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix()));
itk::Matrix<double,3,3> newDirection = transM * dir;
- diffImages->GetVectorImage()->SetOrigin(newOrigin);
- diffImages->GetVectorImage()->SetDirection(newDirection);
+ itkVectorImagePointer->SetOrigin(newOrigin);
+ itkVectorImagePointer->SetDirection(newDirection);
diffImages->Modified();
- mitk::DiffusionImageCorrectionFilter<short>::Pointer correctionFilter = mitk::DiffusionImageCorrectionFilter<short>::New();
+ mitk::DiffusionImageCorrectionFilter::Pointer correctionFilter = mitk::DiffusionImageCorrectionFilter::New();
// For Diff. Images: Need to rotate the gradients (works in-place)
correctionFilter->SetImage(diffImages);
correctionFilter->CorrectDirections(transM.GetVnlMatrix());
img = diffImages;
}
}
void mitk::RegistrationWrapper::GetTransformation(mitk::Image::Pointer fixedImage, mitk::Image::Pointer movingImage, RidgidTransformType transformation,double* offset, bool useSameOrigin, mitk::Image* mask)
{
// Handle the case that fixed/moving image is a DWI image
- mitk::DiffusionImage<short>* fixedDwi = dynamic_cast<mitk::DiffusionImage<short>*> (fixedImage.GetPointer());
- mitk::DiffusionImage<short>* movingDwi = dynamic_cast<mitk::DiffusionImage<short>*> (movingImage.GetPointer());
+ mitk::Image* fixedDwi = dynamic_cast<mitk::Image*> (fixedImage.GetPointer());
+ mitk::Image* movingDwi = dynamic_cast<mitk::Image*> (movingImage.GetPointer());
itk::B0ImageExtractionImageFilter<short,short >::Pointer b0Extraction = itk::B0ImageExtractionImageFilter<short,short>::New();
offset[0]=offset[1]=offset[2]=0;
- if (fixedDwi != NULL)
+
+ typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
+ ITKDiffusionImageType::Pointer itkFixedDwiPointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(fixedDwi, itkFixedDwiPointer);
+
+ ITKDiffusionImageType::Pointer itkMovingDwiPointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(movingDwi, itkMovingDwiPointer);
+
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer fixedGradientDirections =
+ static_cast<mitk::GradientDirectionsProperty*>( fixedDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer movingGradientDirections =
+ static_cast<mitk::GradientDirectionsProperty*>( movingDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+ if (fixedGradientDirections.IsNull() || ( fixedGradientDirections->Size() == 0))
{ // Set b0 extraction as fixed image
- b0Extraction->SetInput(fixedDwi->GetVectorImage());
- b0Extraction->SetDirections(fixedDwi->GetDirections());
+ b0Extraction->SetInput( itkFixedDwiPointer );
+ b0Extraction->SetDirections(fixedGradientDirections);
b0Extraction->Update();
mitk::Image::Pointer tmp = mitk::Image::New();
tmp->InitializeByItk(b0Extraction->GetOutput());
tmp->SetVolume(b0Extraction->GetOutput()->GetBufferPointer());
fixedImage = tmp;
}
- if (movingDwi != NULL)
+ if (movingGradientDirections || ( movingGradientDirections->Size() == 0))
{ // Set b0 extraction as moving image
- b0Extraction->SetInput(movingDwi->GetVectorImage());
- b0Extraction->SetDirections(movingDwi->GetDirections());
+ b0Extraction->SetInput( itkMovingDwiPointer );
+ b0Extraction->SetDirections(movingGradientDirections);
b0Extraction->Update();
mitk::Image::Pointer tmp = mitk::Image::New();
tmp->InitializeByItk(b0Extraction->GetOutput());
tmp->SetVolume(b0Extraction->GetOutput()->GetBufferPointer());
movingImage = tmp;
}
// align the offsets of the two images. this is done to avoid non-overlapping initialization
Point3D origin = fixedImage->GetGeometry()->GetOrigin();
Point3D originMoving = movingImage->GetGeometry()->GetOrigin();
mitk::Image::Pointer tmpImage = movingImage->Clone();
if (useSameOrigin)
{
offset[0] = originMoving[0]-origin[0];
offset[1] = originMoving[1]-origin[1];
offset[2] = originMoving[2]-origin[2];
tmpImage->GetGeometry()->SetOrigin(origin);
}
// Start registration
mitk::PyramidImageRegistrationMethod::Pointer registrationMethod = mitk::PyramidImageRegistrationMethod::New();
registrationMethod->SetFixedImage( fixedImage );
if (mask != NULL)
{
registrationMethod->SetFixedImageMask(mask);
registrationMethod->SetUseFixedImageMask(true);
}
else
{
registrationMethod->SetUseFixedImageMask(false);
}
registrationMethod->SetTransformToRigid();
registrationMethod->SetCrossModalityOn();
registrationMethod->SetMovingImage(tmpImage);
registrationMethod->Update();
registrationMethod->GetParameters(transformation); // first three: euler angles, last three translation
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
index deead178e9..7b7802c3cc 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
@@ -1,80 +1,80 @@
/*===================================================================
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.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkAdcImageFilter_h_
#define __itkAdcImageFilter_h_
#include "itkImageToImageFilter.h"
#include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
+#include <mitkDiffusionPropertyHelper.h>
namespace itk{
/** \class AdcImageFilter
*/
template< class TInPixelType, class TOutPixelType >
class AdcImageFilter :
public ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TOutPixelType, 3 > >
{
public:
typedef AdcImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TOutPixelType, 3 > > Superclass;
- typedef mitk::DiffusionImage< short >::GradientDirectionType GradientDirectionType;
- typedef mitk::DiffusionImage< short >::GradientDirectionContainerType::Pointer GradientContainerType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer GradientContainerType;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(AdcImageFilter, ImageToImageFilter)
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
itkSetMacro( B_value, double )
itkSetMacro( GradientDirections, GradientContainerType )
protected:
AdcImageFilter();
~AdcImageFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
double m_B_value;
GradientContainerType m_GradientDirections;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkAdcImageFilter.txx"
#endif
#endif //__itkAdcImageFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
index cdb43eec2e..c268bb5e40 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
@@ -1,100 +1,100 @@
/*===================================================================
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.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkDwiNormilzationFilter_h_
#define __itkDwiNormilzationFilter_h_
#include "itkImageToImageFilter.h"
#include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
#include <itkLabelStatisticsImageFilter.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkShiftScaleImageFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
namespace itk{
/** \class DwiNormilzationFilter
* \brief Normalizes the data vectors either using the specified reference value or the voxelwise baseline value.
*/
template< class TInPixelType >
class DwiNormilzationFilter :
public ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > >
{
public:
typedef DwiNormilzationFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > > Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(DwiNormilzationFilter, ImageToImageFilter)
typedef itk::Image< double, 3 > DoubleImageType;
typedef itk::Image< unsigned char, 3 > UcharImageType;
typedef itk::Image< unsigned short, 3 > BinImageType;
typedef itk::Image< TInPixelType, 3 > TInPixelImageType;
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
- typedef mitk::DiffusionImage< short >::GradientDirectionType GradientDirectionType;
- typedef mitk::DiffusionImage< short >::GradientDirectionContainerType::Pointer GradientContainerType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer GradientContainerType;
typedef itk::LabelStatisticsImageFilter< TInPixelImageType,BinImageType > StatisticsFilterType;
typedef itk::Statistics::Histogram< typename TInPixelImageType::PixelType > HistogramType;
typedef typename HistogramType::MeasurementType MeasurementType;
typedef itk::ShiftScaleImageFilter<TInPixelImageType, DoubleImageType> ShiftScaleImageFilterType;
itkSetMacro( GradientDirections, GradientContainerType )
itkSetMacro( ScalingFactor, TInPixelType )
itkSetMacro( UseGlobalReference, bool )
itkSetMacro( MaskImage, UcharImageType::Pointer )
itkSetMacro( Reference, double )
protected:
DwiNormilzationFilter();
~DwiNormilzationFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
UcharImageType::Pointer m_MaskImage;
GradientContainerType m_GradientDirections;
int m_B0Index;
TInPixelType m_ScalingFactor;
bool m_UseGlobalReference;
double m_Reference;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDwiNormilzationFilter.txx"
#endif
#endif //__itkDwiNormilzationFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
index dd75de3f14..9c80bb27e4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
@@ -1,123 +1,126 @@
/*===================================================================
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.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_h_
#define _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_h_
#include <itkImageToImageFilter.h>
#include <itkVectorImage.h>
#include <itkPointShell.h>
namespace itk
{
/**
* \brief Select subset of the input vectors equally distributed over the sphere using an iterative electrostatic repulsion strategy. */
template <class TInputScalarType, class TOutputScalarType>
class ElectrostaticRepulsionDiffusionGradientReductionFilter
: public ImageToImageFilter<itk::VectorImage<TInputScalarType,3>, itk::VectorImage<TOutputScalarType,3> >
{
public:
typedef ElectrostaticRepulsionDiffusionGradientReductionFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< itk::VectorImage<TOutputScalarType,3>, itk::VectorImage<TOutputScalarType,3> >
Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(ElectrostaticRepulsionDiffusionGradientReductionFilter, ImageToImageFilter)
typedef TInputScalarType InputScalarType;
typedef itk::VectorImage<InputScalarType,3> InputImageType;
typedef typename InputImageType::PixelType InputPixelType;
typedef TOutputScalarType OutputScalarType;
typedef itk::VectorImage<OutputScalarType,3> OutputImageType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef OutputScalarType BaselineScalarType;
typedef BaselineScalarType BaselinePixelType;
typedef typename itk::Image<BaselinePixelType,3> BaselineImageType;
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
typedef itk::VectorContainer< unsigned int, GradientDirectionType > GradientDirectionContainerType;
typedef std::vector<unsigned int> IndicesVector;
typedef std::map<unsigned int, IndicesVector> BValueMap;
itkGetMacro(OriginalGradientDirections, GradientDirectionContainerType::Pointer)
itkSetMacro(OriginalGradientDirections, GradientDirectionContainerType::Pointer)
itkGetMacro(GradientDirections, GradientDirectionContainerType::Pointer)
itkSetMacro(GradientDirections, GradientDirectionContainerType::Pointer)
IndicesVector GetUsedGradientIndices(){return m_UsedGradientIndices;}
void SetOriginalBValueMap(BValueMap inp){m_OriginalBValueMap = inp;}
void SetShellSelectionBValueMap(BValueMap inp){m_InputBValueMap = inp;}
void SetNumGradientDirections(std::vector<unsigned int> numDirs){m_NumGradientDirections = numDirs;}
+
+ void UpdateOutputInformation();
+
protected:
ElectrostaticRepulsionDiffusionGradientReductionFilter();
~ElectrostaticRepulsionDiffusionGradientReductionFilter() {}
void GenerateData();
double Costs(); ///< calculates electrostatic energy of current direction set
GradientDirectionContainerType::Pointer m_GradientDirections; ///< container for the subsampled output gradient directions
GradientDirectionContainerType::Pointer m_OriginalGradientDirections; ///< input gradient directions
IndicesVector m_UsedGradientIndices;
IndicesVector m_UnusedGradientIndices;
IndicesVector m_BaselineImageIndices;
BValueMap m_OriginalBValueMap;
BValueMap m_InputBValueMap;
std::vector<unsigned int> m_NumGradientDirections;
};
} // end of namespace
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
index 3b601cdb0a..7253e35b42 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
@@ -1,247 +1,261 @@
/*===================================================================
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.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_txx_
#define _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_txx_
#endif
#define _USE_MATH_DEFINES
#include "itkElectrostaticRepulsionDiffusionGradientReductionFilter.h"
#include <math.h>
#include <time.h>
#include <itkImageRegionIterator.h>
#include <itkImageRegion.h>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
::ElectrostaticRepulsionDiffusionGradientReductionFilter()
{
this->SetNumberOfRequiredInputs( 1 );
}
template <class TInputScalarType, class TOutputScalarType>
double
ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
::Costs()
{
double costs = 2*M_PI;
for (IndicesVector::iterator it = m_UsedGradientIndices.begin(); it!=m_UsedGradientIndices.end(); ++it)
{
for (IndicesVector::iterator it2 = m_UsedGradientIndices.begin(); it2!=m_UsedGradientIndices.end(); ++it2)
if (it != it2)
{
vnl_vector_fixed<double,3> v1 = m_OriginalGradientDirections->at(*it);
vnl_vector_fixed<double,3> v2 = m_OriginalGradientDirections->at(*it2);
v1.normalize(); v2.normalize();
double temp = dot_product(v1,v2);
if (temp>1)
temp = 1;
else if (temp<-1)
temp = -1;
double angle = acos(temp);
if (angle<costs)
costs = angle;
temp = dot_product(-v1,v2);
if (temp>1)
temp = 1;
else if (temp<-1)
temp = -1;
angle = acos(temp);
if (angle<costs)
costs = angle;
}
}
return costs;
}
template <class TInputScalarType, class TOutputScalarType>
void
ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
::GenerateData()
{
unsigned int randSeed = time(NULL);
if(m_InputBValueMap.empty() || m_NumGradientDirections.size()!=m_InputBValueMap.size())
return;
BValueMap manipulatedMap = m_InputBValueMap;
int shellCounter = 0;
for(BValueMap::iterator it = m_InputBValueMap.begin(); it != m_InputBValueMap.end(); it++ )
{
srand(randSeed);
// initialize index vectors
m_UsedGradientIndices.clear();
m_UnusedGradientIndices.clear();
if ( it->second.size() <= m_NumGradientDirections[shellCounter] )
{
itkWarningMacro( << "current directions: " << it->second.size() << " wanted directions: " << m_NumGradientDirections[shellCounter]);
m_NumGradientDirections[shellCounter] = it->second.size();
shellCounter++;
continue;
}
MITK_INFO << "Shell number: " << shellCounter;
unsigned int c=0;
for (unsigned int i=0; i<it->second.size(); i++)
{
if (c<m_NumGradientDirections[shellCounter])
m_UsedGradientIndices.push_back(it->second.at(i));
else
m_UnusedGradientIndices.push_back(it->second.at(i));
c++;
}
double minAngle = Costs();
double newMinAngle = 0;
MITK_INFO << "minimum angle: " << 180*minAngle/M_PI;
int stagnationCount = 0;
int rejectionCount = 0;
int maxRejections = m_NumGradientDirections[shellCounter] * 1000;
if (maxRejections<10000)
maxRejections = 10000;
int iUsed = 0;
if (m_UsedGradientIndices.size()>0)
while ( stagnationCount<1000 && rejectionCount<maxRejections )
{
// make proposal for new gradient configuration by randomly removing one of the currently used directions and instead adding one of the unused directions
//int iUsed = rand() % m_UsedGradientIndices.size();
int iUnUsed = rand() % m_UnusedGradientIndices.size();
int vUsed = m_UsedGradientIndices.at(iUsed);
int vUnUsed = m_UnusedGradientIndices.at(iUnUsed);
m_UsedGradientIndices.at(iUsed) = vUnUsed;
m_UnusedGradientIndices.at(iUnUsed) = vUsed;
newMinAngle = Costs(); // calculate costs of proposed configuration
if (newMinAngle > minAngle) // accept or reject proposal
{
MITK_INFO << "minimum angle: " << 180*newMinAngle/M_PI;
if ( (newMinAngle-minAngle)<0.01 )
stagnationCount++;
else
stagnationCount = 0;
minAngle = newMinAngle;
rejectionCount = 0;
}
else
{
rejectionCount++;
m_UsedGradientIndices.at(iUsed) = vUsed;
m_UnusedGradientIndices.at(iUnUsed) = vUnUsed;
}
iUsed++;
iUsed = iUsed % m_UsedGradientIndices.size();
}
manipulatedMap[it->first] = m_UsedGradientIndices;
shellCounter++;
}
int vecLength = 0 ;
for(BValueMap::iterator it = manipulatedMap.begin(); it != manipulatedMap.end(); it++)
vecLength += it->second.size();
// initialize output image
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( this->GetInput()->GetSpacing() ); // Set the image spacing
outImage->SetOrigin( this->GetInput()->GetOrigin() ); // Set the image origin
outImage->SetDirection( this->GetInput()->GetDirection() ); // Set the image direction
outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->SetVectorLength( vecLength ); // Set the vector length
outImage->Allocate();
itk::ImageRegionIterator< OutputImageType > newIt(outImage, outImage->GetLargestPossibleRegion());
newIt.GoToBegin();
typename InputImageType::Pointer inImage = const_cast<InputImageType*>(this->GetInput(0));
itk::ImageRegionIterator< InputImageType > oldIt(inImage, inImage->GetLargestPossibleRegion());
oldIt.GoToBegin();
// initial new value of voxel
OutputPixelType newVec;
newVec.SetSize( vecLength );
newVec.AllocateElements( vecLength );
// generate new pixel values
while(!newIt.IsAtEnd())
{
// init new vector with zeros
newVec.Fill(0.0);
InputPixelType oldVec = oldIt.Get();
int index = 0;
for(BValueMap::iterator it=manipulatedMap.begin(); it!=manipulatedMap.end(); it++)
for(unsigned int j=0; j<it->second.size(); j++)
{
newVec[index] = oldVec[it->second.at(j)];
index++;
}
newIt.Set(newVec);
++newIt;
++oldIt;
}
// set new gradient directions
m_GradientDirections = GradientDirectionContainerType::New();
int index = 0;
for(BValueMap::iterator it = manipulatedMap.begin(); it != manipulatedMap.end(); it++)
for(unsigned int j = 0; j < it->second.size(); j++)
{
m_GradientDirections->InsertElement(index, m_OriginalGradientDirections->at(it->second.at(j)));
index++;
}
this->SetNumberOfRequiredOutputs (1);
this->SetNthOutput (0, outImage);
MITK_INFO << "...done";
}
+template <class TInputScalarType, class TOutputScalarType>
+void
+ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
+::UpdateOutputInformation()
+{
+ Superclass::UpdateOutputInformation();
+ int vecLength = 0 ;
+ for(unsigned int index = 0; index < m_NumGradientDirections.size(); index++)
+ {
+ vecLength += m_NumGradientDirections[index];
+ }
+
+ this->GetOutput()->SetVectorLength( vecLength );
+}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h
index 5db210b559..54fcc4e434 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h
@@ -1,78 +1,77 @@
/*===================================================================
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.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkExtractDwiChannelFilter_h_
#define __itkExtractDwiChannelFilter_h_
#include "itkImageToImageFilter.h"
#include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
#include <itkImageRegionIteratorWithIndex.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
namespace itk{
/** \class ExtractDwiChannelFilter
- * \brief Remove spcified channels from diffusion-weighted image.
+ * \brief Remove specified channels from diffusion-weighted image.
*/
template< class TInPixelType >
class ExtractDwiChannelFilter :
public ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TInPixelType, 3 > >
{
public:
typedef ExtractDwiChannelFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TInPixelType, 3 > > Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(ExtractDwiChannelFilter, ImageToImageFilter)
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
itkSetMacro( ChannelIndex, unsigned int )
protected:
ExtractDwiChannelFilter();
~ExtractDwiChannelFilter() {}
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType );
unsigned int m_ChannelIndex;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkExtractDwiChannelFilter.txx"
#endif
#endif //__itkExtractDwiChannelFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h
index 878443938b..34cf4ef219 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h
@@ -1,147 +1,145 @@
/*===================================================================
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 __itkNonLocalMeansDenoisingFilter_h_
#define __itkNonLocalMeansDenoisingFilter_h_
#include "itkImageToImageFilter.h"
#include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
-
namespace itk{
/** @class NonLocalMeansDenoisingFilter
* @brief This class denoises a vectorimage according to the non-local means procedure.
*
* This Filter needs as an input a diffusion weigthed image, which will be denoised unsing the non-local means principle.
* An input mask is optional to denoise only inside the mask range. All other voxels will be set to 0.
*/
template< class TPixelType >
class NonLocalMeansDenoisingFilter :
public ImageToImageFilter< VectorImage < TPixelType, 3 >, VectorImage < TPixelType, 3 > >
{
public:
/** Typedefs */
typedef NonLocalMeansDenoisingFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< VectorImage < TPixelType, 3 >, VectorImage < TPixelType, 3 > > Superclass;
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef Image <TPixelType, 3> MaskImageType;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(NonLocalMeansDenoisingFilter, ImageToImageFilter)
/**
* @brief Set flag to use joint information
*/
itkSetMacro(UseJointInformation, bool)
/**
* @brief Set the searchradius
*
* The searchradius generates a neighborhood of size (2 * searchradius + 1)³.
* Default is 4.
*/
itkSetMacro(SearchRadius, int)
/**
* @brief Set the comparisonradius
*
* The comparisonradius generates neighborhoods of size (2 * comparisonradius +1)³.
* Default is 1.
*/
itkSetMacro(ComparisonRadius, int)
/**
* @brief Set the variance of the noise
*
* The variance of the noise needs to be estimated to use this filter properly.
* Default is 1.
*/
itkSetMacro(Variance, double)
/**
* @brief Set flag to use a rician adaption
*
* If this flag is true the filter uses a method which is optimized for Rician distributed noise.
*/
itkSetMacro(UseRicianAdaption, bool)
/**
* @brief Get the amount of calculated Voxels
*
* @return the number of calculated Voxels until yet, useful for the use of a progressbars.
*/
itkGetMacro(CurrentVoxelCount, unsigned int)
/** @brief Set the input image. **/
void SetInputImage(const InputImageType* image);
/**
* @brief Set a denoising mask
*
* optional
*
* Set a mask to denoise only the masked area, all voxel outside this area will be set to 0.
*/
void SetInputMask(MaskImageType* mask);
protected:
NonLocalMeansDenoisingFilter();
~NonLocalMeansDenoisingFilter() {}
/**
* @brief Calculations which need to be done before the denoising starts
*
* This method is called before the denoising starts. It calculates the ROI if a mask is used
* and sets the number of processed voxels to zero.
*/
void BeforeThreadedGenerateData();
/**
* @brief Denoising procedure
*
* This method calculates the denoised voxelvalue for each voxel in the image in multiple threads.
* If a mask is used, voxels outside the masked area will be set to 0.
*
* @param outputRegionForThread Region to denoise for each thread.
*/
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
private:
int m_SearchRadius; ///< Radius of the searchblock.
int m_ComparisonRadius; ///< Radius of the comparisonblock.
bool m_UseJointInformation; ///< Flag to use joint information.
bool m_UseRicianAdaption; ///< Flag to use rician adaption.
unsigned int m_CurrentVoxelCount; ///< Amount of processed voxels.
double m_Variance; ///< Estimated noise variance.
typename MaskImageType::Pointer m_Mask; ///< Pointer to the mask image.
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkNonLocalMeansDenoisingFilter.txx"
#endif
#endif //__itkNonLocalMeansDenoisingFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h
index 7e18435d36..168a92b5f8 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h
@@ -1,85 +1,84 @@
/*===================================================================
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.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkRemoveDwiChannelFilter_h_
#define __itkRemoveDwiChannelFilter_h_
#include "itkImageToImageFilter.h"
#include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
#include <itkImageRegionIteratorWithIndex.h>
-#include <mitkDiffusionImage.h>
+#include <mitkDiffusionPropertyHelper.h>
namespace itk{
/** \class RemoveDwiChannelFilter
* \brief Remove spcified channels from diffusion-weighted image.
*/
template< class TInPixelType >
class RemoveDwiChannelFilter :
public ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > >
{
public:
typedef RemoveDwiChannelFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > > Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(RemoveDwiChannelFilter, ImageToImageFilter)
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
- typedef typename mitk::DiffusionImage< TInPixelType >::GradientDirectionType DirectionType;
- typedef typename mitk::DiffusionImage< TInPixelType >::GradientDirectionContainerType DirectionContainerType;
+ typedef typename mitk::DiffusionPropertyHelper::GradientDirectionType DirectionType;
+ typedef typename mitk::DiffusionPropertyHelper::GradientDirectionsContainerType DirectionContainerType;
void SetChannelIndices( std::vector< unsigned int > indices ){ m_ChannelIndices = indices; }
void SetDirections( typename DirectionContainerType::Pointer directions ){ m_Directions = directions; }
typename DirectionContainerType::Pointer GetNewDirections(){ return m_NewDirections; }
protected:
RemoveDwiChannelFilter();
~RemoveDwiChannelFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType id );
std::vector< unsigned int > m_ChannelIndices;
typename DirectionContainerType::Pointer m_Directions;
typename DirectionContainerType::Pointer m_NewDirections;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRemoveDwiChannelFilter.txx"
#endif
#endif //__itkRemoveDwiChannelFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h
index 2bbaf13288..925d1ff77a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h
@@ -1,138 +1,146 @@
/*===================================================================
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.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkResampleDwiImageFilter.h $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef _itk_ResampleDwiImageFilter_h_
#define _itk_ResampleDwiImageFilter_h_
#include <itkImageToImageFilter.h>
#include <itkVectorImage.h>
#include <itkPointShell.h>
namespace itk
{
/**
* \brief Resample DWI channel by channel. */
template <class TScalarType>
class ResampleDwiImageFilter
: public ImageToImageFilter<itk::VectorImage<TScalarType,3>, itk::VectorImage<TScalarType,3> >
{
public:
enum Interpolation {
Interpolate_NearestNeighbour,
Interpolate_Linear,
Interpolate_BSpline,
Interpolate_WindowedSinc
};
typedef ResampleDwiImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< itk::VectorImage<TScalarType,3>, itk::VectorImage<TScalarType,3> >
Superclass;
typedef itk::Vector< double, 3 > DoubleVectorType;
typedef itk::VectorImage<TScalarType,3> DwiImageType;
typedef itk::Image<TScalarType,3> DwiChannelType;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(ResampleDwiImageFilter, ImageToImageFilter)
itkSetMacro( Interpolation, Interpolation )
void SetSamplingFactor(DoubleVectorType sampling)
{
m_NewSpacing = this->GetInput()->GetSpacing();
m_NewSpacing[0] /= sampling[0];
m_NewSpacing[1] /= sampling[1];
m_NewSpacing[2] /= sampling[2];
m_NewImageRegion = this->GetInput()->GetLargestPossibleRegion();
m_NewImageRegion.SetSize(0, m_NewImageRegion.GetSize(0)*sampling[0]);
m_NewImageRegion.SetSize(1, m_NewImageRegion.GetSize(1)*sampling[1]);
m_NewImageRegion.SetSize(2, m_NewImageRegion.GetSize(2)*sampling[2]);
}
void SetNewSpacing(DoubleVectorType spacing)
{
DoubleVectorType oldSpacing = this->GetInput()->GetSpacing();
DoubleVectorType sampling;
sampling[0] = oldSpacing[0]/spacing[0];
sampling[1] = oldSpacing[1]/spacing[1];
sampling[2] = oldSpacing[2]/spacing[2];
m_NewSpacing = spacing;
m_NewImageRegion = this->GetInput()->GetLargestPossibleRegion();
m_NewImageRegion.SetSize(0, m_NewImageRegion.GetSize(0)*sampling[0]);
m_NewImageRegion.SetSize(1, m_NewImageRegion.GetSize(1)*sampling[1]);
m_NewImageRegion.SetSize(2, m_NewImageRegion.GetSize(2)*sampling[2]);
}
void SetNewImageSize(ImageRegion<3> region)
{
ImageRegion<3> oldRegion = this->GetInput()->GetLargestPossibleRegion();
DoubleVectorType sampling;
sampling[0] = (double)region.GetSize(0)/oldRegion.GetSize(0);
sampling[1] = (double)region.GetSize(1)/oldRegion.GetSize(1);
sampling[2] = (double)region.GetSize(2)/oldRegion.GetSize(2);
m_NewImageRegion = region;
m_NewSpacing = this->GetInput()->GetSpacing();
m_NewSpacing[0] /= sampling[0];
m_NewSpacing[1] /= sampling[1];
m_NewSpacing[2] /= sampling[2];
}
+ virtual void UpdateOutputInformation();
+
+ virtual void PropagateRequestedRegion(){}
+
+ virtual void PropagateRequestedRegion(itk::DataObject *output){}
+
+ virtual void VerifyInputInformation(){}
+
protected:
ResampleDwiImageFilter();
~ResampleDwiImageFilter(){}
void GenerateData();
DoubleVectorType m_NewSpacing;
ImageRegion<3> m_NewImageRegion;
Interpolation m_Interpolation;
};
} // end of namespace
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkResampleDwiImageFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx
index 516c121104..b317f88f4d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx
@@ -1,166 +1,176 @@
/*===================================================================
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.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkResampleDwiImageFilter.txx $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef _itk_ResampleDwiImageFilter_txx_
#define _itk_ResampleDwiImageFilter_txx_
#endif
#define _USE_MATH_DEFINES
#include "itkResampleDwiImageFilter.h"
#include <itkImageRegionIterator.h>
#include <itkImageRegion.h>
#include <itkResampleImageFilter.h>
#include <itkBSplineInterpolateImageFunction.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <itkLinearInterpolateImageFunction.h>
#include <itkWindowedSincInterpolateImageFunction.h>
namespace itk
{
template <class TScalarType>
ResampleDwiImageFilter<TScalarType>
::ResampleDwiImageFilter()
: m_Interpolation(Interpolate_Linear)
{
this->SetNumberOfRequiredInputs( 1 );
}
template <class TScalarType>
void
ResampleDwiImageFilter<TScalarType>
::GenerateData()
{
// // initialize output image
// itk::Vector< double, 3 > spacing = this->GetInput()->GetSpacing();
// spacing[0] /= m_SamplingFactor[0];
// spacing[1] /= m_SamplingFactor[1];
// spacing[2] /= m_SamplingFactor[2];
// ImageRegion<3> region = this->GetInput()->GetLargestPossibleRegion();
// region.SetSize(0, region.GetSize(0)*m_SamplingFactor[0]);
// region.SetSize(1, region.GetSize(1)*m_SamplingFactor[1]);
// region.SetSize(2, region.GetSize(2)*m_SamplingFactor[2]);
itk::Point<double,3> origin = this->GetInput()->GetOrigin();
origin[0] -= this->GetInput()->GetSpacing()[0]/2;
origin[1] -= this->GetInput()->GetSpacing()[1]/2;
origin[2] -= this->GetInput()->GetSpacing()[2]/2;
origin[0] += m_NewSpacing[0]/2;
origin[1] += m_NewSpacing[1]/2;
origin[2] += m_NewSpacing[2]/2;
typename DwiImageType::Pointer outImage = DwiImageType::New();
outImage->SetSpacing( m_NewSpacing );
outImage->SetOrigin( origin );
outImage->SetDirection( this->GetInput()->GetDirection() );
outImage->SetLargestPossibleRegion( m_NewImageRegion );
outImage->SetBufferedRegion( m_NewImageRegion );
outImage->SetRequestedRegion( m_NewImageRegion );
outImage->SetVectorLength( this->GetInput()->GetVectorLength() );
outImage->Allocate();
typename itk::ResampleImageFilter<DwiChannelType, DwiChannelType>::Pointer resampler = itk::ResampleImageFilter<DwiChannelType, DwiChannelType>::New();
resampler->SetOutputParametersFromImage(outImage);
switch (m_Interpolation)
{
case Interpolate_NearestNeighbour:
{
typename itk::NearestNeighborInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<DwiChannelType>::New();
resampler->SetInterpolator(interp);
break;
}
case Interpolate_Linear:
{
typename itk::LinearInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::LinearInterpolateImageFunction<DwiChannelType>::New();
resampler->SetInterpolator(interp);
break;
}
case Interpolate_BSpline:
{
typename itk::BSplineInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::BSplineInterpolateImageFunction<DwiChannelType>::New();
resampler->SetInterpolator(interp);
break;
}
case Interpolate_WindowedSinc:
{
typename itk::WindowedSincInterpolateImageFunction<DwiChannelType, 3>::Pointer interp = itk::WindowedSincInterpolateImageFunction<DwiChannelType, 3>::New();
resampler->SetInterpolator(interp);
break;
}
default:
{
typename itk::LinearInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::LinearInterpolateImageFunction<DwiChannelType>::New();
resampler->SetInterpolator(interp);
}
}
for (unsigned int i=0; i<this->GetInput()->GetVectorLength(); i++)
{
typename DwiChannelType::Pointer channel = DwiChannelType::New();
channel->SetSpacing( this->GetInput()->GetSpacing() );
channel->SetOrigin( this->GetInput()->GetOrigin() );
channel->SetDirection( this->GetInput()->GetDirection() );
channel->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion() );
channel->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
channel->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
channel->Allocate();
ImageRegionIterator<DwiChannelType> it(channel, channel->GetLargestPossibleRegion());
while(!it.IsAtEnd())
{
typename DwiImageType::PixelType pix = this->GetInput()->GetPixel(it.GetIndex());
it.Set(pix[i]);
++it;
}
resampler->SetInput(channel);
resampler->Update();
channel = resampler->GetOutput();
ImageRegionIterator<DwiImageType> it2(outImage, outImage->GetLargestPossibleRegion());
while(!it2.IsAtEnd())
{
typename DwiImageType::PixelType pix = it2.Get();
pix[i] = channel->GetPixel(it2.GetIndex());
it2.Set(pix);
++it2;
}
}
this->SetNthOutput(0, outImage);
}
+template <class TScalarType>
+void
+ResampleDwiImageFilter<TScalarType>
+::UpdateOutputInformation()
+{
+ // Calls to superclass updateoutputinformation
+ //Superclass::UpdateOutputInformation();
+ this->GetOutput()->SetSpacing(m_NewSpacing);
+ this->GetOutput()->SetLargestPossibleRegion(m_NewImageRegion);
+}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
index 49715a1226..fb1c06a99a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
@@ -1,285 +1,285 @@
/*===================================================================
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.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef _itk_ResidualImageFilter_txx_
#define _itk_ResidualImageFilter_txx_
#endif
#include "itkResidualImageFilter.h"
#include <mitkCommon.h>
#include <cmath>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
void
ResidualImageFilter<TInputScalarType, TOutputScalarType>
::GenerateData()
{
typename InputImageType::SizeType size = this->GetInput()->GetLargestPossibleRegion().GetSize();
typename InputImageType::SizeType size2 = m_SecondDiffusionImage->GetLargestPossibleRegion().GetSize();
if(size != size2)
{
MITK_ERROR << "Sizes do not match";
return;
}
// Initialize output image
typename OutputImageType::Pointer outputImage =
static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
outputImage->SetSpacing( this->GetInput()->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( this->GetInput()->GetOrigin() ); // Set the image origin
outputImage->SetDirection( this->GetInput()->GetDirection() ); // Set the image direction
outputImage->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
outputImage->Allocate();
outputImage->FillBuffer(0.0);
std::vector< std::vector<double> > residuals;
// per slice, per volume
std::vector< std::vector <std::vector<double> > > residualsPerSlice;
// Detrmine number of B0 images
int numberB0=0;
for(unsigned int i=0; i<m_Gradients->Size(); i++)
{
GradientDirectionType grad = m_Gradients->ElementAt(i);
if(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001)
{
numberB0++;
}
}
residuals.resize(this->GetInput()->GetVectorLength()-numberB0);
// Calculate the standard residual image and for each volume put all residuals in a vector
for(unsigned int z=0; z<size[2]; z++)
{
std::vector< std::vector<double> > sliceResiduals; // residuals per volume for this slice
sliceResiduals.resize(this->GetInput()->GetVectorLength()-numberB0);
for(unsigned int y=0; y<size[1]; y++)
{
for(unsigned int x=0; x<size[0]; x++)
{
// Check if b0 exceeds threshold
itk::Index<3> ix;
ix[0] = x;
ix[1] = y;
ix[2] = z;
typename InputImageType::PixelType p1 = this->GetInput()->GetPixel(ix);
typename InputImageType::PixelType p2 = m_SecondDiffusionImage->GetPixel(ix);
if(p1.GetSize() != p2.GetSize())
{
MITK_ERROR << "Vector sizes do not match";
return;
}
if(p1.GetElement(m_B0Index) <= m_B0Threshold)
{
continue;
}
double res = 0;
int shift = 0; // correction for the skipped B0 images
for(unsigned int i = 0; i<p1.GetSize(); i++)
{
GradientDirectionType grad = m_Gradients->ElementAt(i);
if(!(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001))
{
double val1 = (double)p1.GetElement(i);
double val2 = (double)p2.GetElement(i);
res += abs(val1-val2);
residuals[i-shift].push_back(val1-val2);
sliceResiduals[i-shift].push_back(val1-val2);
}
else
{
shift++;
}
}
res = res/p1.GetSize();
outputImage->SetPixel(ix, res);
}
}
residualsPerSlice.push_back(sliceResiduals);
}
// for each dw volume: sort the the measured residuals (for each voxel) to enable determining Q1 and Q3; calculate means
// determine percentage of errors as described in QUALITY ASSESSMENT THROUGH ANALYSIS OF RESIDUALS OF DIFFUSION IMAGE FITTING
// Leemans et al 2008
double q1,q3, median;
std::vector< std::vector<double> >::iterator it = residuals.begin();
while(it != residuals.end())
{
std::vector<double> res = *it;
// sort
std::sort(res.begin(), res.end());
q1 = res[0.25*res.size()];
m_Q1.push_back(q1);
q3 = res[0.75*res.size()];
m_Q3.push_back(q3);
median = res[0.5*res.size()];
double iqr = q3-q1;
double outlierThreshold = median + 1.5*iqr;
double numberOfOutliers = 0.0;
std::vector<double>::iterator resIt = res.begin();
double mean = 0;
while(resIt != res.end())
{
double f = *resIt;
if(f>outlierThreshold)
{
numberOfOutliers++;
}
mean += f;
++resIt;
}
double percOfOutliers = 100 * numberOfOutliers / res.size();
m_PercentagesOfOutliers.push_back(percOfOutliers);
mean /= res.size();
m_Means.push_back(mean);
++it;
}
// Calculate for each slice the number of outliers per volume(dw volume)
std::vector< std::vector <std::vector<double> > >::iterator sliceIt = residualsPerSlice.begin();
while(sliceIt != residualsPerSlice.end())
{
std::vector< std::vector<double> > currentSlice = *sliceIt;
std::vector<double> percentages;
std::vector< std::vector<double> >::iterator volIt = currentSlice.begin();
while(volIt != currentSlice.end())
{
std::vector<double> currentVolume = *volIt;
//sort
std::sort(currentVolume.begin(), currentVolume.end());
q1 = currentVolume[0.25*currentVolume.size()];
q3 = currentVolume[0.75*currentVolume.size()];
median = currentVolume[0.5*currentVolume.size()];
double iqr = q3-q1;
double outlierThreshold = median + 1.5*iqr;
double numberOfOutliers = 0.0;
std::vector<double>::iterator resIt = currentVolume.begin();
- double mean;
+ double mean(0.0);
while(resIt != currentVolume.end())
{
double f = *resIt;
if(f>outlierThreshold)
{
numberOfOutliers++;
}
mean += f;
++resIt;
}
double percOfOutliers = 100 * numberOfOutliers / currentVolume.size();
percentages.push_back(percOfOutliers);
++volIt;
}
m_OutliersPerSlice.push_back(percentages);
++sliceIt;
}
}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
index 34cb1f08cb..ad119b1a73 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
@@ -1,145 +1,145 @@
/*===================================================================
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 __itkTensorDerivedMeasurementsFilter_txx
#define __itkTensorDerivedMeasurementsFilter_txx
-
+#include <itkImageRegionIterator.h>
namespace itk {
template <class TPixel>
TensorDerivedMeasurementsFilter<TPixel>::TensorDerivedMeasurementsFilter() : m_Measure(AD)
{
}
template <class TPixel>
void TensorDerivedMeasurementsFilter<TPixel>::GenerateData()
{
typename TensorImageType::Pointer tensorImage = static_cast< TensorImageType * >( this->ProcessObject::GetInput(0) );
typedef ImageRegionConstIterator< TensorImageType > TensorImageIteratorType;
typedef ImageRegionIterator< OutputImageType > OutputImageIteratorType;
typename OutputImageType::Pointer outputImage =
static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
typename TensorImageType::RegionType region = tensorImage->GetLargestPossibleRegion();
outputImage->SetSpacing( tensorImage->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( tensorImage->GetOrigin() ); // Set the image origin
outputImage->SetDirection( tensorImage->GetDirection() ); // Set the image direction
outputImage->SetRegions( tensorImage->GetLargestPossibleRegion());
outputImage->Allocate();
TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetLargestPossibleRegion());
OutputImageIteratorType outputIt(outputImage, outputImage->GetLargestPossibleRegion());
tensorIt.GoToBegin();
outputIt.GoToBegin();
while(!tensorIt.IsAtEnd() && !outputIt.IsAtEnd()){
TensorType tensor = tensorIt.Get();
switch(m_Measure)
{
case FA:
{
TPixel diffusionIndex = tensor.GetFractionalAnisotropy();
outputIt.Set(diffusionIndex);
break;
}
case RA:
{
TPixel diffusionIndex = tensor.GetRelativeAnisotropy();
outputIt.Set(diffusionIndex);
break;
}
case AD:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set(evs[2]);
break;
}
case RD:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set((evs[0]+evs[1])/2.0);
break;
}
case CA:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
if (evs[2] == 0)
{
outputIt.Set(0);
break;
}
outputIt.Set(1.0-(evs[0]+evs[1])/(2.0*evs[2]));
break;
}
case L2:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set(evs[1]);
break;
}
case L3:
{
// eigenvalues are sorted in ascending order by default because the
// itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set(evs[0]);
break;
}
case MD:
{
typename TensorType::EigenValuesArrayType evs;
tensor.ComputeEigenValues(evs);
outputIt.Set((evs[0]+evs[1]+evs[2])/3.0);
break;
}
}
++tensorIt;
++outputIt;
}
}
}
#endif // __itkTensorDerivedMeasurements_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
index cbed2d792b..b588be572a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
@@ -1,168 +1,171 @@
/*===================================================================
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.
===================================================================*/
/*=========================================================================
Program: Tensor ToolKit - TTK
Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.h $
Language: C++
Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
Version: $Revision: 68 $
Copyright (c) INRIA 2010. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef _itk_TensorImageToDiffusionImageFilter_h_
#define _itk_TensorImageToDiffusionImageFilter_h_
#include "itkImageToImageFilter.h"
#include <itkDiffusionTensor3D.h>
#include <itkVectorContainer.h>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
class TensorImageToDiffusionImageFilter
: public ImageToImageFilter<itk::Image<itk::DiffusionTensor3D<TInputScalarType>,3>, itk::VectorImage<TOutputScalarType,3> >
{
public:
typedef TInputScalarType InputScalarType;
typedef itk::DiffusionTensor3D<InputScalarType> InputPixelType;
typedef itk::Image<InputPixelType,3> InputImageType;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef TOutputScalarType OutputScalarType;
typedef itk::VectorImage<OutputScalarType,3> OutputImageType;
typedef typename OutputImageType::PixelType OutputPixelType;
typedef typename OutputImageType::RegionType OutputImageRegionType;
typedef OutputScalarType BaselineScalarType;
typedef BaselineScalarType BaselinePixelType;
typedef typename itk::Image<BaselinePixelType,3> BaselineImageType;
typedef typename BaselineImageType::RegionType BaselineImageRegionType;
typedef itk::Image< short, 3> MaskImageType;
typedef MaskImageType::RegionType MaskImageRegionType;
typedef TensorImageToDiffusionImageFilter Self;
typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
itkTypeMacro (TensorImageToDiffusionImageFilter, ImageToImageFilter);
itkStaticConstMacro (ImageDimension, unsigned int,
OutputImageType::ImageDimension);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
typedef vnl_vector_fixed<double,3> GradientType;
typedef VectorContainer<unsigned int, GradientType> GradientListType;
typedef GradientListType::Pointer GradientListPointerType;
/** Manually Set/Get a list of gradients */
void SetGradientList(const GradientListPointerType list)
{
m_GradientList = list;
this->Modified();
}
GradientListPointerType GetGradientList(void) const
{return m_GradientList;}
void SetBValue( const double& bval)
{ m_BValue = bval; }
void SetMaskImage( MaskImageType::Pointer maskimage )
{
m_MaskImage = maskimage;
}
/**
* @brief Set an external baseline image for signal generation (optional)
*
* An option to enforce a specific baseline image. If none provided (default) the filter uses
* the itk::TensorToL2NormImageFilter to generate the modelled baseline image.
*/
void SetExternalBaselineImage( typename BaselineImageType::Pointer bimage)
{
m_BaselineImage = bimage;
}
itkSetMacro(Min, OutputScalarType);
itkSetMacro(Max, OutputScalarType);
protected:
TensorImageToDiffusionImageFilter()
{
m_BValue = 1.0;
m_BaselineImage = 0;
m_Min = 0.0;
m_Max = 10000.0;
}
virtual ~TensorImageToDiffusionImageFilter(){}
void PrintSelf (std::ostream& os, Indent indent) const
{
Superclass::PrintSelf (os, indent);
}
virtual void BeforeThreadedGenerateData( void );
virtual void ThreadedGenerateData( const
OutputImageRegionType &outputRegionForThread, ThreadIdType);
//void GenerateData();
- GradientListPointerType m_GradientList;
+ virtual void UpdateOutputInformation();
+
+
+ private:
+
+ TensorImageToDiffusionImageFilter (const Self&);
+ void operator=(const Self&);
+
+ GradientListType::Pointer m_GradientList;
double m_BValue;
typename BaselineImageType::Pointer m_BaselineImage;
OutputScalarType m_Min;
OutputScalarType m_Max;
MaskImageType::Pointer m_MaskImage;
- private:
-
- TensorImageToDiffusionImageFilter (const Self&);
- void operator=(const Self&);
-
};
} // end of namespace
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTensorImageToDiffusionImageFilter.txx"
#endif
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
index e812dfb51a..67a9b355d2 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
@@ -1,235 +1,244 @@
/*===================================================================
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.
===================================================================*/
/*=========================================================================
2
3 Program: Tensor ToolKit - TTK
4 Module: $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
5 Language: C++
6 Date: $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
7 Version: $Revision: 68 $
8
9 Copyright (c) INRIA 2010. All rights reserved.
10 See LICENSE.txt for details.
11
12 This software is distributed WITHOUT ANY WARRANTY; without even
13 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 PURPOSE. See the above copyright notices for more information.
15
16 =========================================================================*/
#ifndef _itk_TensorImageToDiffusionImageFilter_txx_
#define _itk_TensorImageToDiffusionImageFilter_txx_
#endif
#include "itkTensorImageToDiffusionImageFilter.h"
#include "itkTensorToL2NormImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include <itkImageRegionIterator.h>
#include <itkImageRegionConstIterator.h>
namespace itk
{
template <class TInputScalarType, class TOutputScalarType>
void
TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
::BeforeThreadedGenerateData()
{
if( m_GradientList->Size()==0 )
{
throw itk::ExceptionObject (__FILE__,__LINE__,"Error: gradient list is empty, cannot generate DWI.");
}
if( m_BaselineImage.IsNull() )
{
// create a B0 image by taking the norm of the tensor field * scale:
typedef itk::TensorToL2NormImageFilter<InputImageType, itk::Image<InputScalarType,3> >
TensorToL2NormFilterType;
typename TensorToL2NormFilterType::Pointer myFilter1 = TensorToL2NormFilterType::New();
myFilter1->SetInput (this->GetInput());
try
{
myFilter1->Update();
}
catch (itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
typename itk::RescaleIntensityImageFilter< itk::Image<InputScalarType,3>, BaselineImageType>::Pointer rescaler=
itk::RescaleIntensityImageFilter<itk::Image<InputScalarType,3>, BaselineImageType>::New();
rescaler->SetOutputMinimum ( m_Min );
rescaler->SetOutputMaximum ( m_Max );
rescaler->SetInput ( myFilter1->GetOutput() );
try
{
rescaler->Update();
}
catch (itk::ExceptionObject &e)
{
std::cerr << e;
return;
}
m_BaselineImage = rescaler->GetOutput();
}
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( this->GetInput()->GetSpacing() ); // Set the image spacing
outImage->SetOrigin( this->GetInput()->GetOrigin() ); // Set the image origin
outImage->SetDirection( this->GetInput()->GetDirection() ); // Set the image direction
outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
outImage->SetVectorLength(m_GradientList->Size());
outImage->Allocate();
this->SetNumberOfRequiredOutputs (1);
this->SetNthOutput (0, outImage);
}
template <class TInputScalarType, class TOutputScalarType>
void TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
::ThreadedGenerateData (const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId )
{
typedef ImageRegionIterator<OutputImageType> IteratorOutputType;
typedef ImageRegionConstIterator<InputImageType> IteratorInputType;
typedef ImageRegionConstIterator<BaselineImageType> IteratorBaselineType;
unsigned long numPixels = outputRegionForThread.GetNumberOfPixels();
unsigned long step = numPixels/100;
unsigned long progress = 0;
IteratorOutputType itOut (this->GetOutput(), outputRegionForThread);
IteratorInputType itIn (this->GetInput(), outputRegionForThread);
IteratorBaselineType itB0 (m_BaselineImage, outputRegionForThread);
typedef ImageRegionConstIterator< MaskImageType > IteratorMaskImageType;
IteratorMaskImageType itMask;
if( m_MaskImage.IsNotNull() )
{
itMask = IteratorMaskImageType( m_MaskImage, outputRegionForThread);
itMask.GoToBegin();
}
if( threadId==0 )
{
this->UpdateProgress (0.0);
}
while(!itIn.IsAtEnd())
{
if( this->GetAbortGenerateData() )
{
throw itk::ProcessAborted(__FILE__,__LINE__);
}
InputPixelType T = itIn.Get();
BaselinePixelType b0 = itB0.Get();
OutputPixelType out;
out.SetSize(m_GradientList->Size());
out.Fill(0);
short maskvalue = 1;
if( m_MaskImage.IsNotNull() )
{
maskvalue = itMask.Get();
++itMask;
}
std::vector<unsigned int> b0_indices;
if( b0 > 0)
{
for( unsigned int i=0; i<m_GradientList->Size(); i++)
{
GradientType g = m_GradientList->at(i);
// normalize vector so the following computations work
const double twonorm = g.two_norm();
if( twonorm < vnl_math::eps )
{
b0_indices.push_back(i);
continue;
}
GradientType gn = g.normalize();
InputPixelType S;
S[0] = gn[0]*gn[0];
S[1] = gn[1]*gn[0];
S[2] = gn[2]*gn[0];
S[3] = gn[1]*gn[1];
S[4] = gn[2]*gn[1];
S[5] = gn[2]*gn[2];
const double res =
T[0]*S[0] +
2 * T[1]*S[1] + T[3]*S[3] +
2 * T[2]*S[2] + 2 * T[4]*S[4] + T[5]*S[5];
// check for corrupted tensor
if (res>=0)
{
// estimate the bvalue from the base value and the norm of the gradient
// - because of this estimation the vector have to be normalized beforehand
// otherwise the modelled signal is wrong ( i.e. not scaled properly )
const double bval = m_BValue * twonorm * twonorm;
out[i] = static_cast<OutputScalarType>( maskvalue * 1.0 * b0 * exp ( -1.0 * bval * res ) );
}
}
}
for(unsigned int idx = 0; idx < b0_indices.size(); idx++ )
{
out[b0_indices.at(idx)] = b0;
}
itOut.Set(out);
if( threadId==0 && step>0)
{
if( (progress%step)==0 )
{
this->UpdateProgress ( double(progress)/double(numPixels) );
}
}
++progress;
++itB0;
++itIn;
++itOut;
}
if( threadId==0 )
{
this->UpdateProgress (1.0);
}
}
+template <class TInputScalarType, class TOutputScalarType>
+void
+TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
+::UpdateOutputInformation()
+{
+ // Calls to superclass updateoutputinformation
+ Superclass::UpdateOutputInformation();
+ this->GetOutput()->SetVectorLength( m_GradientList->size() );
+}
} // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.cpp
deleted file mode 100644
index 69623e4da8..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*===================================================================
-
-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 _mitk_DiffusionImageToDiffusionImageFilter_cpp
-#define _mitk_DiffusionImageToDiffusionImageFilter_cpp
-
-#include "mitkDiffusionImageToDiffusionImageFilter.h"
-
-template <typename DiffusionPixelType>
-mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::DiffusionImageToDiffusionImageFilter()
-{
- this->SetNumberOfRequiredInputs(1);
- this->SetNumberOfRequiredOutputs(1);
-}
-
-template <typename DiffusionPixelType>
-void mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::SetInput(const InputImageType *input)
-{
- // call to the more general method
- this->SetInput(0, input);
-}
-
-template <typename DiffusionPixelType>
-void mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::SetInput(unsigned int index, const InputImageType *input)
-{
- if( index+1 > this->GetNumberOfInputs() )
- {
- this->SetNumberOfRequiredInputs( index + 1 );
- }
- // Process object is not const-correct so the const_cast is required here
- this->itk::ProcessObject::SetNthInput(index,
- const_cast< typename Self::InputImageType *>( input ) );
-}
-
-
-template <typename DiffusionPixelType>
-const typename mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>::InputImageType*
-mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::GetInput()
-{
- // call to the more general method
- return this->GetInput(0);
-}
-
-template <typename DiffusionPixelType>
-const typename mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>::InputImageType*
-mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::GetInput(unsigned int idx)
-{
- return static_cast< const typename Self::InputImageType * >
- (this->itk::ProcessObject::GetInput(idx));
-}
-
-
-
-
-#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.h
deleted file mode 100644
index 8108b9888d..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*===================================================================
-
-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 MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_H
-#define MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_H
-
-#include "mitkDiffusionImageSource.h"
-#include "mitkDiffusionImage.h"
-
-
-namespace mitk {
-/**
- * @class DiffusionImageToDiffusionImageFilter
- * @brief Base class for all DiffusionImage filters
- *
- * The class inherits the mitk::ImageToImageFilter to gain access to the filtering pipline.
- */
-template <typename DiffusionPixelType>
-class DiffusionImageToDiffusionImageFilter
- : public DiffusionImageSource< DiffusionPixelType >
-{
-public:
- /** typedefs for compatibility */
- typedef mitk::DiffusionImage< DiffusionPixelType > InputImageType;
- typedef typename InputImageType::Pointer InputImagePointerType;
-
- mitkClassMacro( DiffusionImageToDiffusionImageFilter,
- DiffusionImageSource<DiffusionPixelType> )
-
- itkFactorylessNewMacro(Self)
- itkCloneMacro(Self)
-
- typedef typename Superclass::OutputType OutputImageType;
- typedef typename OutputImageType::Pointer OutputImagePointerType;
-
- using itk::ProcessObject::SetInput;
- virtual void SetInput( const InputImageType* image);
- virtual void SetInput( unsigned int, const InputImageType* image);
-
- const InputImageType* GetInput(void);
- const InputImageType* GetInput(unsigned int);
-
-
-protected:
- DiffusionImageToDiffusionImageFilter();
- virtual ~DiffusionImageToDiffusionImageFilter() {}
-
- virtual void PrintSelf(std::ostream &os, itk::Indent indent) const {}
- virtual void GenerateInputRequestedRegion() {}
-
-private:
- // purposely not implemented
- void operator=(const Self&);
-};
-
-} // end namespace mitk
-
-#include "mitkDiffusionImageToDiffusionImageFilter.cpp"
-
-#endif // MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt
index b0ee596bbe..1629e3cd19 100644
--- a/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt
+++ b/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt
@@ -1,19 +1,19 @@
# With apple gcc 4.2.1 the following waring leads to an build error if boost is enabled
if(APPLE)
mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=empty-body" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
MITK_CREATE_MODULE(
SUBPROJECTS MITK-DTI
- INCLUDE_DIRS Algorithms Algorithms/Reconstruction Algorithms/Registration Algorithms/Reconstruction/MultishellProcessing DicomImport IODataStructures/DiffusionWeightedImages IODataStructures/QBallImages IODataStructures/TensorImages IODataStructures Rendering ${CMAKE_CURRENT_BINARY_DIR}
+ INCLUDE_DIRS Algorithms Algorithms/Reconstruction Algorithms/Registration Algorithms/Reconstruction/MultishellProcessing DicomImport IODataStructures/DiffusionWeightedImages IODataStructures/Properties IODataStructures/QBallImages IODataStructures/TensorImages IODataStructures Rendering ${CMAKE_CURRENT_BINARY_DIR}
DEPENDS MitkMapperExt MitkPlanarFigure MitkImageExtraction MitkSceneSerializationBase MitkDICOMReader
PACKAGE_DEPENDS VTK|vtkFiltersProgrammable ITK|ITKDistanceMap+ITKRegistrationCommon+ITKLabelVoting+ITKVTK Boost
ITK|ITKMetricsv4+ITKRegistrationMethodsv4
WARNINGS_AS_ERRORS
)
if(MSVC)
mitkFunctionCheckCAndCXXCompilerFlags("/wd4005" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
add_subdirectory(Testing)
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp
index b4fb13c110..93dc5802af 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp
@@ -1,306 +1,311 @@
/*===================================================================
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 "mitkDiffusionDICOMFileReader.h"
#include "mitkDiffusionDICOMFileReaderHelper.h"
#include "mitkDiffusionHeaderSiemensDICOMFileReader.h"
#include "mitkDiffusionHeaderSiemensMosaicDICOMFileReader.h"
#include "mitkDiffusionHeaderGEDICOMFileReader.h"
#include "mitkDiffusionHeaderPhilipsDICOMFileReader.h"
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
#include "mitkStringProperty.h"
+#include <mitkImageCast.h>
static void PerformHeaderAnalysis( mitk::DiffusionHeaderDICOMFileReader::DICOMHeaderListType headers )
{
unsigned int images = headers.size();
unsigned int unweighted_images = 0;
unsigned int weighted_images = 0;
mitk::DiffusionHeaderDICOMFileReader::DICOMHeaderListType::const_iterator c_iter = headers.begin();
while( c_iter != headers.end() )
{
const mitk::DiffusionImageDICOMHeaderInformation h = *c_iter;
if( h.baseline ) unweighted_images++;
if( h.b_value > 0 ) weighted_images++;
++c_iter;
}
MITK_INFO << " :: Analyzed volumes " << images << "\n"
<< " :: \t"<< unweighted_images << " b = 0" << "\n"
<< " :: \t"<< weighted_images << " b > 0";
}
mitk::DiffusionDICOMFileReader::DiffusionDICOMFileReader()
{
}
mitk::DiffusionDICOMFileReader::~DiffusionDICOMFileReader()
{
}
bool mitk::DiffusionDICOMFileReader
::LoadImages()
{
unsigned int numberOfOutputs = this->GetNumberOfOutputs();
bool success = true;
for(unsigned int o = 0; o < numberOfOutputs; ++o)
{
success &= this->LoadSingleOutputImage( this->m_OutputHeaderContainer.at(o),
this->InternalGetOutput(o), this->m_IsMosaicData.at(o) );
}
return success;
}
bool mitk::DiffusionDICOMFileReader
::LoadSingleOutputImage( DiffusionHeaderDICOMFileReader::DICOMHeaderListType retrievedHeader,
DICOMImageBlockDescriptor& block, bool is_mosaic)
{
// prepare data reading
DiffusionDICOMFileReaderHelper helper;
DiffusionDICOMFileReaderHelper::VolumeFileNamesContainer filenames;
const DICOMImageFrameList& frames = block.GetImageFrameList();
int numberOfDWImages = block.GetIntProperty("timesteps", 1);
int numberOfFramesPerDWImage = frames.size() / numberOfDWImages;
assert( int( double((double) frames.size() / (double) numberOfDWImages)) == numberOfFramesPerDWImage );
for( int idx = 0; idx < numberOfDWImages; idx++ )
{
std::vector< std::string > FileNamesPerVolume;
DICOMImageFrameList::const_iterator timeStepStart = frames.begin() + idx * numberOfFramesPerDWImage;
DICOMImageFrameList::const_iterator timeStepEnd = frames.begin() + (idx+1) * numberOfFramesPerDWImage;
for (DICOMImageFrameList::const_iterator frameIter = timeStepStart;
frameIter != timeStepEnd;
++frameIter)
{
FileNamesPerVolume.push_back( (*frameIter)->Filename );
}
filenames.push_back( FileNamesPerVolume );
}
// TODO : only prototyping to test loading of diffusion images
// we need some solution for the different types
- typedef mitk::DiffusionImage<short> DiffusionImageType;
- DiffusionImageType::Pointer output_image = DiffusionImageType::New();
+ mitk::Image::Pointer output_image = mitk::Image::New();
- DiffusionImageType::GradientDirectionContainerType::Pointer directions =
- DiffusionImageType::GradientDirectionContainerType::New();
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer directions =
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
double max_bvalue = 0;
for( int idx = 0; idx < numberOfDWImages; idx++ )
{
DiffusionImageDICOMHeaderInformation header = retrievedHeader.at(idx);
if( max_bvalue < header.b_value )
max_bvalue = header.b_value;
}
// normalize the retrieved gradient directions according to the set b-value (maximal one)
for( int idx = 0; idx < numberOfDWImages; idx++ )
{
DiffusionImageDICOMHeaderInformation header = retrievedHeader.at(idx);
- DiffusionImageType::GradientDirectionType grad = header.g_vector;
+ mitk::DiffusionPropertyHelper::GradientDirectionType grad = header.g_vector;
grad.normalize();
grad *= sqrt( header.b_value / max_bvalue );
directions->push_back( grad );
}
// initialize the output image
- output_image->SetReferenceBValue( max_bvalue );
- output_image->SetDirections( directions );
+ output_image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( directions ) );
+ output_image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( max_bvalue ) );
if( is_mosaic && this->m_ResolveMosaic )
{
mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::Pointer mosaic_reader =
mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::New();
// retrieve the remaining meta-information needed for mosaic reconstruction
// it suffices to get it exemplatory from the first file in the file list
mosaic_reader->RetrieveMosaicInformation( filenames.at(0).at(0) );
mitk::MosaicDescriptor mdesc = mosaic_reader->GetMosaicDescriptor();
- output_image->SetVectorImage( helper.LoadMosaicToVector<short, 3>( filenames, mdesc ) );
+ mitk::CastToMitkImage( helper.LoadMosaicToVector<short, 3>( filenames, mdesc ), output_image );
}
else
{
- output_image->SetVectorImage( helper.LoadToVector<short, 3>( filenames ) );
+ mitk::CastToMitkImage( helper.LoadToVector<short, 3>( filenames ), output_image );
}
- output_image->InitializeFromVectorImage();
+
+ mitk::DiffusionPropertyHelper propertyHelper( output_image );
+ propertyHelper.InitializeImage();
+
output_image->SetProperty("diffusion.dicom.importname", mitk::StringProperty::New( helper.GetOutputName(filenames) ) );
block.SetMitkImage( (mitk::Image::Pointer) output_image );
return block.GetMitkImage().IsNotNull();
}
void mitk::DiffusionDICOMFileReader
::AnalyzeInputFiles()
{
this->SetGroup3DandT(true);
Superclass::AnalyzeInputFiles();
// collect output from superclass
size_t number_of_outputs = this->GetNumberOfOutputs();
if(number_of_outputs == 0)
{
MITK_ERROR << "Failed to parse input, retrieved 0 outputs from SeriesGDCMReader ";
}
MITK_INFO("diffusion.dicomreader") << "Retrieved " << number_of_outputs << "outputs.";
for( unsigned int outputidx = 0; outputidx < this->GetNumberOfOutputs(); outputidx++ )
{
DICOMImageBlockDescriptor block_0 = this->GetOutput(outputidx);
// collect vendor ID from the first output, first image
StringList inputFilename;
DICOMImageFrameInfo::Pointer frame_0 = block_0.GetImageFrameList().at(0);
inputFilename.push_back( frame_0->Filename );
mitk::DiffusionHeaderDICOMFileReader::Pointer headerReader;
bool isMosaic = false;
gdcm::Scanner gdcmScanner;
gdcm::Tag t_vendor(0x008, 0x0070);
gdcm::Tag t_imagetype(0x008, 0x008);
// add DICOM Tag for vendor
gdcmScanner.AddTag( t_vendor );
// add DICOM Tag for image type
gdcmScanner.AddTag( t_imagetype );
if( gdcmScanner.Scan( inputFilename ) )
{
// retrieve both vendor and image type
std::string vendor = gdcmScanner.GetValue( frame_0->Filename.c_str(), t_vendor );
std::string image_type = gdcmScanner.GetValue( frame_0->Filename.c_str(), t_imagetype );
MITK_INFO("diffusion.dicomreader") << "Output " << outputidx+1 << " Got vendor: " << vendor << " image type " << image_type;
// parse vendor tag
if( vendor.find("SIEMENS") != std::string::npos )
//&& image_type.find("DIFFUSION") != std::string::npos )
{
if( image_type.find("MOSAIC") != std::string::npos )
{
headerReader = mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::New();
isMosaic = true;
}
else
{
headerReader = mitk::DiffusionHeaderSiemensDICOMFileReader::New();
}
}
else if( vendor.find("GE") != std::string::npos )
{
headerReader = mitk::DiffusionHeaderGEDICOMFileReader::New();
}
else if( vendor.find("Philips") != std::string::npos )
{
headerReader = mitk::DiffusionHeaderPhilipsDICOMFileReader::New();
}
else
{
// unknown vendor
}
if( headerReader.IsNull() )
{
MITK_ERROR << "No header reader for given vendor. ";
continue;
}
}
else
{
continue;
}
bool canread = false;
// iterate over the threeD+t block
int numberOfTimesteps = block_0.GetIntProperty("timesteps", 1);
int framesPerTimestep = block_0.GetImageFrameList().size() / numberOfTimesteps;
for( int idx = 0; idx < numberOfTimesteps; idx++ )
{
int access_idx = idx * framesPerTimestep;
DICOMImageFrameInfo::Pointer frame = this->GetOutput( outputidx ).GetImageFrameList().at( access_idx );
canread = headerReader->ReadDiffusionHeader( frame->Filename );
}
if( canread )
{
// collect the information
mitk::DiffusionHeaderDICOMFileReader::DICOMHeaderListType retrievedHeader = headerReader->GetHeaderInformation();
m_IsMosaicData.push_back(isMosaic);
m_OutputHeaderContainer.push_back( retrievedHeader );
m_OutputReaderContainer.push_back( headerReader );
}
}
this->SetNumberOfOutputs( this->m_OutputHeaderContainer.size() );
for( unsigned int outputidx = 0; outputidx < this->GetNumberOfOutputs(); outputidx++ )
{
// TODO : Analyze outputs + header information, i.e. for the loading confidence
MITK_INFO("diffusion.dicomreader") << "---- DICOM Analysis Report ---- :: Output " << outputidx+1 << " of " << this->GetNumberOfOutputs();
try{
PerformHeaderAnalysis( this->m_OutputHeaderContainer.at( outputidx) );
}
catch( const std::exception& se)
{
MITK_ERROR << "STD Exception " << se.what();
}
MITK_INFO("diffusion.dicomreader") << "===========================================";
}
}
bool mitk::DiffusionDICOMFileReader
::CanHandleFile(const std::string & /* filename */)
{
//FIXME :
return true;
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h
index 6cd30e36d7..e4da4b1849 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h
@@ -1,283 +1,281 @@
#ifndef MITKDIFFUSIONDICOMFILEREADERHELPER_H
#define MITKDIFFUSIONDICOMFILEREADERHELPER_H
-#include "mitkDiffusionImage.h"
-
#include "itkImageSeriesReader.h"
#include "itkVectorImage.h"
#include "itkImageRegionIteratorWithIndex.h"
namespace mitk
{
/**
* @brief The MosaicDescriptor struct is a help struct holding the necessary information for
* loading a mosaic DICOM file into an MITK file with correct geometry information
*/
struct MosaicDescriptor
{
unsigned int nimages;
bool slicenormalup;
itk::ImageBase<3>::SpacingType spacing;
itk::ImageBase<3>::DirectionType direction;
float origin[3];
};
class DiffusionDICOMFileReaderHelper
{
public:
typedef std::vector< std::string > StringContainer;
typedef std::vector< StringContainer > VolumeFileNamesContainer;
std::string GetOutputName(const VolumeFileNamesContainer& filenames)
{
typedef itk::Image< short, 3> InputImageType;
typedef itk::ImageSeriesReader< InputImageType > SeriesReaderType;
SeriesReaderType::Pointer probe_reader = SeriesReaderType::New();
probe_reader->SetFileNames( filenames.at(0) );
probe_reader->GenerateOutputInformation();
probe_reader->Update();
std::string seriesDescTag, seriesNumberTag, patientName;
SeriesReaderType::DictionaryArrayRawPointer inputDict = probe_reader->GetMetaDataDictionaryArray();
if( ! itk::ExposeMetaData< std::string > ( *(*inputDict)[0], "0008|103e", seriesDescTag ) )
seriesDescTag = "UNSeries";
if( ! itk::ExposeMetaData< std::string > ( *(*inputDict)[0], "0020|0011", seriesNumberTag ) )
seriesNumberTag = "00000";
if( ! itk::ExposeMetaData< std::string > ( *(*inputDict)[0], "0010|0010", patientName ) )
patientName = "UnknownName";
std::stringstream ss;
ss << seriesDescTag << "_" << seriesNumberTag << "_" << patientName;
return ss.str();
}
template< typename PixelType, unsigned int VecImageDimension>
typename itk::VectorImage< PixelType, VecImageDimension >::Pointer LoadToVector(
const VolumeFileNamesContainer& filenames
//const itk::ImageBase<3>::RegionType requestedRegion
)
{
typedef itk::Image< PixelType, 3> InputImageType;
typedef itk::ImageSeriesReader< InputImageType > SeriesReaderType;
typename SeriesReaderType::Pointer probe_reader = SeriesReaderType::New();
probe_reader->SetFileNames( filenames.at(0) );
probe_reader->GenerateOutputInformation();
const itk::ImageBase<3>::RegionType requestedRegion = probe_reader->GetOutput()->GetLargestPossibleRegion();
MITK_INFO << " --- Probe reader : \n" <<
" Retrieved LPR " << requestedRegion;
typedef itk::VectorImage< PixelType, 3 > VectorImageType;
typename VectorImageType::Pointer output_image = VectorImageType::New();
output_image->SetNumberOfComponentsPerPixel( filenames.size() );
output_image->SetSpacing( probe_reader->GetOutput()->GetSpacing() );
output_image->SetOrigin( probe_reader->GetOutput()->GetOrigin() );
output_image->SetDirection( probe_reader->GetOutput()->GetDirection() );
output_image->SetLargestPossibleRegion( probe_reader->GetOutput()->GetLargestPossibleRegion() );
output_image->SetBufferedRegion( requestedRegion );
output_image->Allocate();
itk::ImageRegionIterator< VectorImageType > vecIter(
output_image, requestedRegion );
VolumeFileNamesContainer::const_iterator volumesFileNamesIter = filenames.begin();
// iterate over the given volumes
unsigned int component = 0;
while( volumesFileNamesIter != filenames.end() )
{
MITK_INFO << " ======== Loading volume " << component+1 << " of " << filenames.size();
typename SeriesReaderType::Pointer volume_reader = SeriesReaderType::New();
volume_reader->SetFileNames( *volumesFileNamesIter );
try
{
volume_reader->UpdateLargestPossibleRegion();
}
catch( const itk::ExceptionObject &e)
{
mitkThrow() << " ITK Series reader failed : "<< e.what();
}
itk::ImageRegionConstIterator< InputImageType > iRCIter (
volume_reader->GetOutput(),
volume_reader->GetOutput()->GetLargestPossibleRegion() );
// transfer to vector image
iRCIter.GoToBegin();
vecIter.GoToBegin();
while( !iRCIter.IsAtEnd() )
{
typename VectorImageType::PixelType vector_pixel = vecIter.Get();
vector_pixel.SetElement( component, iRCIter.Get() );
vecIter.Set( vector_pixel );
++vecIter;
++iRCIter;
}
++volumesFileNamesIter;
component++;
}
return output_image;
}
/**
* Create the vector image for the resulting diffusion image from a mosaic DICOM image set,
* The method needs to be provided with the MosaicDescriptor struct to be able to compute the
* correct index and to set the geometry information of the image itself.
*/
template< typename PixelType, unsigned int VecImageDimension>
typename itk::VectorImage< PixelType, VecImageDimension >::Pointer LoadMosaicToVector(
const VolumeFileNamesContainer& filenames,
const MosaicDescriptor& mosaicInfo )
{
typedef itk::Image< PixelType, 3> MosaicImageType;
typedef itk::ImageFileReader< MosaicImageType > SingleImageReaderType;
// generate output
typedef itk::VectorImage< PixelType, 3 > VectorImageType;
VolumeFileNamesContainer::const_iterator volumesFileNamesIter = filenames.begin();
// probe the first file to retrieve the size of the 2d image
// we need this information to compute the index relation between mosaic and resulting 3d position
// but we need it only once
typename SingleImageReaderType::Pointer mosaic_probe = SingleImageReaderType::New();
mosaic_probe->SetFileName( (*volumesFileNamesIter).at(0) );
try
{
mosaic_probe->UpdateLargestPossibleRegion();
}
catch( const itk::ExceptionObject &e)
{
mitkThrow() << " ITK Image file reader failed : "<< e.what();
}
typename MosaicImageType::RegionType mosaic_lpr = mosaic_probe->GetOutput()->GetLargestPossibleRegion();
MITK_INFO << " == MOSAIC: " << mosaic_lpr;
itk::ImageBase<3>::SizeValueType images_per_row = ceil( sqrt( (float) mosaicInfo.nimages ) );
itk::ImageBase<3>::RegionType requestedRegion;
requestedRegion.SetSize( 0, mosaic_lpr.GetSize()[0]/images_per_row);
requestedRegion.SetSize( 1, mosaic_lpr.GetSize()[1]/images_per_row);
requestedRegion.SetSize( 2, mosaicInfo.nimages);
typename VectorImageType::Pointer output_image = VectorImageType::New();
output_image->SetNumberOfComponentsPerPixel( filenames.size() );
typename VectorImageType::DirectionType dmatrix;
dmatrix.SetIdentity();
std::vector<double> dirx = mosaic_probe->GetImageIO()->GetDirection(0);
std::vector<double> diry = mosaic_probe->GetImageIO()->GetDirection(1);
std::vector<double> dirz = mosaic_probe->GetImageIO()->GetDirection(2);
dmatrix.GetVnlMatrix().set_column( 0, &dirx[0] );
dmatrix.GetVnlMatrix().set_column( 1, &diry[0] );
dmatrix.GetVnlMatrix().set_column( 2, &dirz[0] );
/*
FIXME!!! The struct currently does not provide the geometry information
the loading works as required*/
output_image->SetSpacing( mosaicInfo.spacing );
output_image->SetOrigin( mosaic_probe->GetOutput()->GetOrigin() );
output_image->SetDirection( dmatrix );
output_image->SetLargestPossibleRegion( requestedRegion );
output_image->SetBufferedRegion( requestedRegion );
output_image->Allocate();
itk::ImageRegionIteratorWithIndex< VectorImageType > vecIter(
output_image, requestedRegion );
// hold the image sizes in an extra variable ( used very often )
typename MosaicImageType::SizeValueType dx = requestedRegion.GetSize()[0];
typename MosaicImageType::SizeValueType dy = requestedRegion.GetSize()[1];
// iterate over the given volumes
unsigned int component = 0;
while( volumesFileNamesIter != filenames.end() )
{
MITK_INFO << " ======== Loading volume " << component+1 << " of " << filenames.size();
typename SingleImageReaderType::Pointer mosaic_reader = SingleImageReaderType::New();
mosaic_reader->SetFileName( (*volumesFileNamesIter).at(0) );
try
{
mosaic_reader->UpdateLargestPossibleRegion();
}
catch( const itk::ExceptionObject &e)
{
mitkThrow() << " ITK Image file reader failed : "<< e.what();
}
typename MosaicImageType::Pointer current_mosaic = mosaic_reader->GetOutput();
vecIter.GoToBegin();
while( !vecIter.IsAtEnd() )
{
typename VectorImageType::PixelType vector_pixel = vecIter.Get();
typename VectorImageType::IndexType threeD_index = vecIter.GetIndex();
typename MosaicImageType::IndexType mosaic_index;
mosaic_index[2] = 0;
// first find the corresponding tile in the mosaic
// this is defined by the z-position of the vector (3D) image iterator
// in x : z_index % #images_in_grid
// in y : z_index / #images_in_grid
//
// the remaining is just computing the correct position in the mosaic, done by
// --------- index of (0,0,z) ----- + --- current 2d position ---
mosaic_index[0] = (threeD_index[2] % images_per_row) * dx + threeD_index[0];
mosaic_index[1] = (threeD_index[2] / images_per_row) * dy + threeD_index[1];
typename MosaicImageType::PixelType mosaic_pixel = current_mosaic->GetPixel( mosaic_index );
vector_pixel.SetElement( component, mosaic_pixel );
vecIter.Set( vector_pixel );
++vecIter;
}
++volumesFileNamesIter;
component++;
}
return output_image;
}
};
}
#endif // MITKDIFFUSIONDICOMFILEREADERHELPER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h
index ed62cf3f1e..7e1f348f36 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h
@@ -1,117 +1,120 @@
/*===================================================================
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 MITKDIFFUSIONHEADERFILEREADER_H
#define MITKDIFFUSIONHEADERFILEREADER_H
#include <MitkDiffusionCoreExports.h>
+#include <mitkCommon.h>
#include <itkLightObject.h>
-#include "mitkDiffusionImage.h"
+#include <itkObjectFactory.h>
#include "gdcmScanner.h"
#include "gdcmReader.h"
+#include <vnl/vnl_vector_fixed.h>
+
namespace mitk
{
/**
* @brief The DiffusionImageHeaderInformation struct
*/
struct DiffusionImageDICOMHeaderInformation
{
DiffusionImageDICOMHeaderInformation()
: b_value(0),
baseline(false),
isotropic(false)
{
g_vector.fill(0);
}
void Print()
{
MITK_INFO << " DiffusionImageHeaderInformation : \n"
<< " : b value : " << b_value << "\n"
<< " : gradient : " << g_vector << "\n"
<< " : isotropic : " << isotropic << "\n --- \n";
}
unsigned int b_value;
vnl_vector_fixed< double, 3> g_vector;
bool baseline;
bool isotropic;
};
struct DiffusionImageMosaicDICOMHeaderInformation
: public DiffusionImageDICOMHeaderInformation
{
unsigned long n_images;
bool slicenormalup;
};
/**
* @class DiffusionHeaderDICOMFileReader
*
* @brief Abstract class for all vendor specific diffusion file header reader
*
* To provide a diffusion header reader for a new vendor, reimplement the \sa ReadDiffusionHeader method.
*/
class MitkDiffusionCore_EXPORT DiffusionHeaderDICOMFileReader
: public itk::LightObject
{
public:
typedef std::vector< DiffusionImageDICOMHeaderInformation > DICOMHeaderListType;
mitkClassMacro( DiffusionHeaderDICOMFileReader, itk::LightObject )
itkSimpleNewMacro( Self )
/**
* @brief IsDiffusionHeader Parse the given dicom file and collect the special diffusion image information
* @return
*/
virtual bool ReadDiffusionHeader( std::string ){ return false; }
DICOMHeaderListType GetHeaderInformation();
protected:
DiffusionHeaderDICOMFileReader();
virtual ~DiffusionHeaderDICOMFileReader();
DICOMHeaderListType m_HeaderInformationList;
};
/**
* @brief Retrieve the value of a gdcm tag to the given string
*
* @param tag the gdcm::Tag to be search for
* @param dataset a gdcm::DataSet to look into
* @param target a string to store the value of the given tag if found
* @param verbose make some output
*
* @return true if a string was found, false otherwise
*/
bool RevealBinaryTag(const gdcm::Tag tag, const gdcm::DataSet& dataset, std::string& target);
bool RevealBinaryTagC(const gdcm::Tag tag, const gdcm::DataSet& dataset, char* target_array );
} // end namespace mitk
#endif // MITKDIFFUSIONHEADERFILEREADER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
index 04f552619e..e90e9b77a4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
@@ -1,101 +1,102 @@
#include "mitkDiffusionHeaderGEDICOMFileReader.h"
+#include <vnl/vnl_math.h>
mitk::DiffusionHeaderGEDICOMFileReader
::DiffusionHeaderGEDICOMFileReader()
{
}
mitk::DiffusionHeaderGEDICOMFileReader
::~DiffusionHeaderGEDICOMFileReader()
{
}
bool mitk::DiffusionHeaderGEDICOMFileReader
::ReadDiffusionHeader(std::string filename)
{
gdcm::Reader gdcmReader;
gdcmReader.SetFileName( filename.c_str() );
gdcmReader.Read();
gdcm::Tag ge_bvalue_tag( 0x0043, 0x1039 );
gdcm::Tag ge_gradient_x( 0x0019, 0x10bb );
gdcm::Tag ge_gradient_y( 0x0019, 0x10bc );
gdcm::Tag ge_gradient_z( 0x0019, 0x10bd );
bool success = true;
DiffusionImageDICOMHeaderInformation header_info;
std::string ge_tagvalue_string;
char* pEnd;
// start with b-value
success = RevealBinaryTag( ge_bvalue_tag, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string );
// b value stored in the first bytes
// typical example: "1000\8\0\0" for bvalue=1000
// "40\8\0\0" for bvalue=40
// so we need to cut off the last 6 elements
const char* bval_string = ge_tagvalue_string.substr(0,ge_tagvalue_string.length()-6).c_str();
header_info.b_value = static_cast<unsigned int>(strtod( bval_string, &pEnd ));
// now retrieve the gradient direction
if(success &&
RevealBinaryTag( ge_gradient_x, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string ) )
{
header_info.g_vector[0] = strtod( ge_tagvalue_string.c_str(), &pEnd );
}
else
{
success = false;
}
if( success &&
RevealBinaryTag( ge_gradient_y, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string ) )
{
header_info.g_vector[1] = strtod( ge_tagvalue_string.c_str(), &pEnd );
}
else
{
success = false;
}
if( success &&
RevealBinaryTag( ge_gradient_z, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string ) )
{
header_info.g_vector[2] = strtod( ge_tagvalue_string.c_str(), &pEnd );
}
else
{
success = false;
}
if( success )
{
// Fix for (0,0,0) direction in IVIM datasets
if( header_info.b_value > 0 &&
header_info.g_vector.two_norm() < vnl_math::eps )
{
header_info.g_vector.fill(1);
header_info.g_vector.normalize();
header_info.isotropic = true;
}
// mark baseline
if( header_info.b_value == 0 )
header_info.baseline = true;
this->m_HeaderInformationList.push_back( header_info );
header_info.Print();
}
return success;
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
index b037bbb3da..a9c8710521 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
@@ -1,95 +1,97 @@
/*===================================================================
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 "mitkDiffusionHeaderPhilipsDICOMFileReader.h"
#include <sstream>
+#include <vnl/vnl_math.h>
+
mitk::DiffusionHeaderPhilipsDICOMFileReader::DiffusionHeaderPhilipsDICOMFileReader()
{
}
mitk::DiffusionHeaderPhilipsDICOMFileReader::~DiffusionHeaderPhilipsDICOMFileReader()
{
}
bool mitk::DiffusionHeaderPhilipsDICOMFileReader::ReadDiffusionHeader(std::string filename)
{
gdcm::Reader gdcmReader;
gdcmReader.SetFileName( filename.c_str() );
gdcmReader.Read();
gdcm::Tag philips_bvalue_tag( 0x2001, 0x1003 );
//gdcm::Tag philips_gradient_direction( 0x2001, 0x1004 );
DiffusionImageDICOMHeaderInformation header_info;
//std::string tagvalue_string;
//char* pEnd;
// reveal b-value
float bvalue = 0;
if( RevealBinaryTagC( philips_bvalue_tag, gdcmReader.GetFile().GetDataSet(), (char*) &bvalue) )
{
header_info.b_value = std::ceil( bvalue );
if( header_info.b_value == 0)
header_info.baseline = true;
}
else
{
MITK_WARN("diffusion.dicomreader.philips") << "No b-value found. Most probably no diffusion-weighted image.";
return false;
}
gdcm::Tag philips_new_bvalue_tag( 0x0018,0x9087 );
double dbvalue = 0;
if( RevealBinaryTagC( philips_new_bvalue_tag, gdcmReader.GetFile().GetDataSet(), (char*) &dbvalue) )
{
MITK_INFO("philips.dicom.diffusion.bvalue") << dbvalue;
}
if( header_info.baseline )
{
// no direction in unweighted images
header_info.g_vector.fill(0);
}
else
{
MITK_INFO("philips.dicom.diffusion.gradientdir") << "Parsing gradient direction.";
gdcm::Tag philips_gradient_direction_new( 0x0018, 0x9089 );
double gr_dir_arr[3] = {1,0,-1};
if( RevealBinaryTagC( philips_gradient_direction_new, gdcmReader.GetFile().GetDataSet(), (char*) &gr_dir_arr ) )
{
MITK_INFO("philips.dicom.diffusion.gradient") << "(" << gr_dir_arr[0] <<"," << gr_dir_arr[1] <<"," <<gr_dir_arr[2] <<")";
}
header_info.g_vector.copy_in( &gr_dir_arr[0] );
if( header_info.g_vector.two_norm() < vnl_math::eps )
{
header_info.g_vector.fill(1);
header_info.isotropic = true;
}
}
this->m_HeaderInformationList.push_back( header_info );
return true;
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
index 043f5e94f2..d5e17f2e14 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
@@ -1,42 +1,42 @@
#include "mitkDiffusionHeaderSiemensDICOMFileHelper.h"
#include <cstdlib>
#include <cmath>
mitk::SiemensDiffusionHeaderType mitk::GetHeaderType( std::string header )
{
// The CSA2 format begins with the string ‘SV10’, the CSA1 format does not.
if( header.find("SV10") != std::string::npos )
{
return mitk::SIEMENS_CSA2;
}
else
{
return mitk::SIEMENS_CSA1;
}
}
bool mitk::ParseInputString( std::string input, std::vector<double>& values, Siemens_Header_Format format_specs )
{
-
// TODO : Compute offset based on the format_specs, where does the 84 come from???
int offset = 84;
int vm = *(input.c_str() + format_specs.NameLength );
for (int k = 0; k < vm; k++)
{
int itemLength = *(input.c_str() + offset + 4);
int strideSize = static_cast<int> (ceil(static_cast<double>(itemLength)/4) * 4);
std::string valueString = input.substr( offset+16, itemLength );
double value = atof( valueString.c_str() );
values.push_back( value );
offset += 16+strideSize;
}
- return true;
+ // If there are no values it is invalid
+ return (values.size() > 0 );
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
index 62416888ca..5cf26e5b8e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
@@ -1,151 +1,152 @@
/*===================================================================
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 "mitkDiffusionHeaderSiemensDICOMFileReader.h"
#include "mitkDiffusionHeaderSiemensDICOMFileHelper.h"
#include "gdcmScanner.h"
#include "gdcmReader.h"
+#include <vnl/vnl_math.h>
/**
* @brief Extract b value from the siemens diffusion tag
*/
bool mitk::DiffusionHeaderSiemensDICOMFileReader
::ExtractSiemensDiffusionTagInformation( std::string tag_value, mitk::DiffusionImageDICOMHeaderInformation& values)
{
SiemensDiffusionHeaderType hformat = mitk::GetHeaderType( tag_value );
Siemens_Header_Format specs = this->m_SiemensFormatsCollection.at( hformat );
MITK_DEBUG << " Header format: " << hformat;
MITK_DEBUG << " :: Retrieving b value. ";
std::string::size_type tag_position =
tag_value.find( "B_value", 0 );
if( tag_position == std::string::npos )
{
MITK_ERROR << "No b value information found. ";
return false;
}
std::string value_string = tag_value.substr( tag_position, tag_value.size() - tag_position + 1 );
std::vector<double> value_array;
if( ParseInputString(value_string, value_array, specs) )
{
values.b_value = value_array.at(0);
}
else
{
MITK_INFO("diffusion.dicomreader.siemens") << "No b-value tag found. ";
return false;
}
// search for GradientDirectionInformation if the bvalue is not null
if( values.b_value > 0 )
{
std::string::size_type tag_position = tag_value.find( "DiffusionGradientDirection", 0 );
// Possibly it is a IVIM dataset, i.e. the gradient direction is not relevant
// and possibly either not set or set to zero
if( tag_position == std::string::npos )
{
MITK_WARN << "No gradient direction information, but non-zero b-value. Possibly an IVIM dataset. " << "\n"
<< "Setting gradient to (1,1,1).";
values.isotropic = true;
values.g_vector.fill(1);
return false;
}
value_array.clear();
std::string gradient_direction_str = tag_value.substr( tag_position, tag_value.size() - tag_position + 1 );
if( ParseInputString(gradient_direction_str, value_array, specs) )
{
if( value_array.size() != 3 )
{
MITK_ERROR << " Retrieved gradient information of length " << value_array.size();
return false;
}
for( unsigned int i=0; i<value_array.size(); i++)
{
values.g_vector[i] = value_array.at(i);
}
// Test for isotropic data (i.e. IVIM)
if( values.g_vector.two_norm() < vnl_math::eps )
{
values.g_vector.fill(1);
values.isotropic = true;
}
}
}
else
{
values.baseline = true;
}
return true;
}
mitk::DiffusionHeaderSiemensDICOMFileReader
::DiffusionHeaderSiemensDICOMFileReader()
{
Siemens_Header_Format Siemens_CSA1_Format( 64, sizeof(int32_t), 4, sizeof(int32_t), sizeof(int32_t) );
Siemens_Header_Format Siemens_CSA2_Format( 64, sizeof(int32_t), 4, sizeof(int32_t), sizeof(int32_t) );
m_SiemensFormatsCollection.push_back( Siemens_CSA1_Format );
m_SiemensFormatsCollection.push_back( Siemens_CSA2_Format );
}
mitk::DiffusionHeaderSiemensDICOMFileReader
::~DiffusionHeaderSiemensDICOMFileReader()
{
}
bool mitk::DiffusionHeaderSiemensDICOMFileReader
::ReadDiffusionHeader(std::string filename)
{
gdcm::Reader gdcmReader;
gdcmReader.SetFileName( filename.c_str() );
gdcmReader.Read();
MITK_INFO << " -- Analyzing: " << filename;
const gdcm::DataSet& dataset = gdcmReader.GetFile().GetDataSet();
const gdcm::Tag t_sie_diffusion( 0x0029,0x1010 );
//const gdcm::Tag t_sie_diffusion_vec( 0x0029,0x100e );
//const gdcm::Tag t_sie_diffusion2( 0x0029,0x100c );
std::string siemens_diffusionheader_str;
if( RevealBinaryTag( t_sie_diffusion, dataset, siemens_diffusionheader_str ) )
{
DiffusionImageDICOMHeaderInformation values;
this->ExtractSiemensDiffusionTagInformation( siemens_diffusionheader_str, values );
m_HeaderInformationList.push_back( values );
}
return true;
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
deleted file mode 100644
index b5d61d4946..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*===================================================================
-
-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 __mitkDiffusionImage__h
-#define __mitkDiffusionImage__h
-
-#include "mitkImage.h"
-#include "itkVectorImage.h"
-#include "itkVectorImageToImageAdaptor.h"
-#include <itkImageDuplicator.h>
-#include "MitkDiffusionCoreExports.h"
-
-namespace mitk
-{
-
-/**
- * \brief this class encapsulates diffusion volumes (vectorimages not
- * yet supported by mitkImage)
- */
-template< class TPixelType >
-class MITK_EXPORT DiffusionImage : public Image
-{
-
-public:
- typedef typename itk::VectorImage<TPixelType, 3> ImageType;
- typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
- typedef itk::VectorContainer< unsigned int,GradientDirectionType > GradientDirectionContainerType;
- typedef GradientDirectionContainerType::Pointer GradientDirectionContainerTypePointer;
- typedef vnl_matrix_fixed< double, 3, 3 > MeasurementFrameType;
- typedef std::vector< unsigned int > IndicesVector;
- typedef itk::VectorImage< TPixelType, 3 > ItkDwiType;
- typedef itk::ImageDuplicator< ItkDwiType > DwiDuplicatorType;
-
- /**
- * \brief The BValueMap contains seperated IndicesVectors for each b value (index for GradientDirectionContainer)
- * key := b value
- * value := indicesVector
- */
- typedef std::map< unsigned int , IndicesVector > BValueMap;
-
- mitkClassMacro( DiffusionImage, Image )
- itkFactorylessNewMacro(Self)
- itkCloneMacro(Self)
- mitkCloneMacro(Self)
-
- /**
- * \brief Return the itkVectorImage as pointer
- */
- typename ImageType::Pointer GetVectorImage();
-
- /**
- * \brief Return the itkVectorImage as const pointer
- */
- const typename ImageType::Pointer GetVectorImage() const;
-
- /**
- * \brief Set the itkVectorImage
- *
- * \param SmartPointer ofitk::VectorImage
- */
- void SetVectorImage(typename ImageType::Pointer image );
-
- /**
- * \brief Initialize the mitkImage (base-class) using the first b-zero value of the itkVectorImage
- *
- * \warning First set itkVectorImage, GradientDirectionContainer and the b value of the image.
- * Has to be called.
- */
- void InitializeFromVectorImage();
-
- /**
- * \brief Return the directions as GradientDirectionContainer const pointer
- *
- * \warning MeasurementFrame already applied
- */
- GradientDirectionContainerType::Pointer GetDirections() const;
-
- /**
- * \brief Return the directions as GradientDirectionContainer const pointer
- *
- * \warning no MeasurmentFrame applied
- */
- GradientDirectionContainerType::Pointer GetDirectionsWithoutMeasurementFrame() const;
-
- /**
- * \brief Set the original and current GradientDirectionContainer
- * \param GradientdirectionContainer as pointer
- * \warning Replace the original (m_OriginalDirections) and current (m_Directions) GradientDirectionContainer.
- * For the current directions the MeasurmentFrame is applied. Remove existing GradientDirectionContainer observer
- * of m_Directions and add a new observer to it (observer update the m_B_ValueMap if modifications occours on the container)
- */
- void SetDirections( GradientDirectionContainerType::Pointer directions );
-
- /**
- * \brief Set the original and current GradientDirectionContainer
- * \param std::vector<itk::Vector<double,3> >
- * \warning Replace the original (m_OriginalDirections) and current (m_Directions) GradientDirectionContainer.
- * For the current directions the MeasurmentFrame is applied.
- * Remove existing GradientDirectionContainer observer of m_Directions and add a new observer to it
- * (observer update the m_B_ValueMap if modifications occours on the container).
- * Calls the overloaded GradientDirectionContainer pointer version of the method.
- */
- void SetDirections( const std::vector<itk::Vector<double,3> > & directions );
-
- /**
- * \brief Return a copy of the MeasurmentFrame (m_MeasurementFrame)
- */
- MeasurementFrameType GetMeasurementFrame() const;
-
- /**
- * \brief Set the MeasurementFrame
- *
- * \param Const reference of MeasurementFrameType
- */
- void SetMeasurementFrame( const MeasurementFrameType & mFrame );
-
- /**
- * \brief Return true if gradients of with diffrent b-values exist
- */
- bool GetNumberOfBValues() const;
-
- /**
- * \brief Return a BValueMap (key: b value, Value: IndicesVector of the GradientDirectionContainer)
- */
- const BValueMap & GetBValueMap() const;
-
- /**
- * \brief Return the reference b value
- * GradientsLength * referenceBValue encoding the true b value of the corresponding GradientDirection
- */
- float GetReferenceBValue() const;
-
- /**
- * \brief Set the reference b value s
- */
- void SetReferenceBValue( float val );
-
- GradientDirectionContainerType::Pointer CalcAveragedDirectionSet(double precision, GradientDirectionContainerType::Pointer directions);
- void AverageRedundantGradients(double precision);
- void SetDisplayIndexForRendering(int displayIndex);
-
-protected:
- DiffusionImage();
- DiffusionImage(const DiffusionImage<TPixelType> &);
- virtual ~DiffusionImage();
-
- // Helper Methods
- bool AreAlike(GradientDirectionType g1, GradientDirectionType g2, double precision);
- float GetB_Value(unsigned int i);
-
- /**
- * \brief Apply the previouse set MeasurmentFrame to all gradients in the GradientsDirectionContainer (m_Directions)
- *
- * \warning first set the MeasurmentFrame
- */
- void ApplyMeasurementFrame();
-
- /**
- * \brief Update the BValueMap (m_B_ValueMap) using the current gradient directions (m_Directions)
- *
- * \warning Have to be called after each manipulation on the GradientDirectionContainer
- * !especially after manipulation of the m_Directions (GetDirections()) container via pointer access!
- */
- void UpdateBValueMap();
-
- typename ImageType::Pointer m_VectorImage;
- float m_B_Value;
- MeasurementFrameType m_MeasurementFrame;
- GradientDirectionContainerType::Pointer m_OriginalDirections;
- GradientDirectionContainerType::Pointer m_Directions;
- int m_DisplayIndex;
- BValueMap m_B_ValueMap;
-
-};
-
-/**
-* @brief Equal A function comparing two images for beeing equal in meta- and imagedata
-*
-* @ingroup MITKTestingAPI
-*
-* Following aspects are tested for equality:
-* - mitk image equal test
-* - GradientDirectionContainer
-* - MeasurementFrame
-* - reference BValue
-* - BValueMap
-* - itkVectorImage
-*
-* @param rightHandSide An image to be compared
-* @param leftHandSide An image to be compared
-* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
-* @param verbose Flag indicating if the user wants detailed console output or not.
-* @return true, if all subsequent comparisons are true, false otherwise
-*/
-
-template<class TPixelType>
-inline bool Equal(const mitk::DiffusionImage<TPixelType> &leftHandSide, const mitk::DiffusionImage<TPixelType> &rightHandSide, ScalarType eps, bool verbose );
-
-
-} // namespace mitk
-
-#include "mitkDiffusionImage.txx"
-
-#endif /* __mitkDiffusionImage__h */
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx
deleted file mode 100644
index 75baf432c6..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx
+++ /dev/null
@@ -1,631 +0,0 @@
-/*===================================================================
-
-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 "itkImageRegionIterator.h"
-#include "itkImageRegionConstIterator.h"
-#include "mitkImageCast.h"
-
-#include "mitkDiffusionImage.h"
-
-#include "itkImageDuplicator.h"
-#include "itkTestingComparisonImageFilter.h"
-
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::DiffusionImage()
- : m_VectorImage(0), m_B_Value(-1.0), m_OriginalDirections(0), m_Directions(0)
-{
- MeasurementFrameType mf;
- for(int i=0; i<3; i++)
- for(int j=0; j<3; j++)
- mf[i][j] = 0;
- for(int i=0; i<3; i++)
- mf[i][i] = 1;
- m_MeasurementFrame = mf;
-}
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::DiffusionImage(const DiffusionImage<TPixelType> & orig)
- : mitk::Image(orig),
- m_VectorImage( 0 ),
- m_B_Value(0),
- m_OriginalDirections(0),
- m_Directions(0)
-{
- // Deep copy VectorImage
- typename itk::ImageDuplicator<ImageType>::Pointer duplicator = itk::ImageDuplicator<ImageType>::New();
- duplicator->SetInputImage( orig.m_VectorImage );
- duplicator->Update();
-
- GradientDirectionContainerType::ConstIterator origIt;
- GradientDirectionContainerType::ConstIterator origItEnd;
-
- // Deep Copy OrignalDirectioncontainer
- GradientDirectionContainerType::Pointer OriginalDirectionscontainer = GradientDirectionContainerType::New();
- origIt = orig.GetDirectionsWithoutMeasurementFrame()->Begin();
- origItEnd = orig.GetDirectionsWithoutMeasurementFrame()->End();
-
- for(;origIt != origItEnd; ++origIt)
- OriginalDirectionscontainer->push_back(origIt.Value());
-
- // Deep Copy Directioncontainer
- GradientDirectionContainerType::Pointer DirectionsContainer = GradientDirectionContainerType::New();
- origIt = orig.GetDirections()->Begin();
- origItEnd = orig.GetDirections()->End();
-
- for(;origIt != origItEnd; ++origIt)
- DirectionsContainer->push_back(origIt.Value());
-
- // Set member of the new clone
- m_VectorImage = duplicator->GetOutput();
- m_B_Value = orig.GetReferenceBValue();
- m_OriginalDirections = OriginalDirectionscontainer;
- m_Directions = DirectionsContainer;
- m_MeasurementFrame = orig.GetMeasurementFrame();
- ApplyMeasurementFrame();
- UpdateBValueMap();
- InitializeFromVectorImage();
-
- // m_VectorImage = duplicator->GetOutput();
- // m_B_Value = orig.GetB_Value();
- // m_MeasurementFrame = orig.GetMeasurementFrame();
- // m_Directions = copyInContainer;
- // m_OriginalDirections = copyInContainer;
-
-
-}
-
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::~DiffusionImage()
-{
- // Remove Observer for m_Directions
- //RemoveObserver();
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>
-::InitializeFromVectorImage()
-{
- if(!m_VectorImage || !m_Directions || m_B_Value==-1.0)
- {
- MITK_INFO << "DiffusionImage could not be initialized. Set all members first!" << std::endl;
- // Fehjlermedlung updaten
- return;
- }
-
- // find bzero index
- int firstZeroIndex = -1;
- for(GradientDirectionContainerType::ConstIterator it = m_Directions->Begin();
- it != m_Directions->End(); ++it)
- {
- firstZeroIndex++;
- GradientDirectionType g = it.Value();
- if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
- break;
- }
-
- typedef itk::Image<TPixelType,3> ImgType;
- typename ImgType::Pointer img = ImgType::New();
- img->SetSpacing( m_VectorImage->GetSpacing() ); // Set the image spacing
- img->SetOrigin( m_VectorImage->GetOrigin() ); // Set the image origin
- img->SetDirection( m_VectorImage->GetDirection() ); // Set the image direction
- img->SetLargestPossibleRegion( m_VectorImage->GetLargestPossibleRegion());
- img->SetBufferedRegion( m_VectorImage->GetLargestPossibleRegion() );
- img->Allocate();
-
- int vecLength = m_VectorImage->GetVectorLength();
- InitializeByItk( img.GetPointer(), 1, vecLength );
-
- itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
- itw.GoToBegin();
-
- itk::ImageRegionConstIterator<ImageType> itr (m_VectorImage, m_VectorImage->GetLargestPossibleRegion() );
- itr.GoToBegin();
-
- while(!itr.IsAtEnd())
- {
- itw.Set(itr.Get().GetElement(firstZeroIndex));
- ++itr;
- ++itw;
- }
-
- // init
- SetImportVolume(img->GetBufferPointer());
-
- m_DisplayIndex = firstZeroIndex;
- MITK_INFO << "Diffusion-Image successfully initialized.";
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>
-::SetDisplayIndexForRendering(int displayIndex)
-{
- int index = displayIndex;
- int vecLength = m_VectorImage->GetVectorLength();
- index = index > vecLength-1 ? vecLength-1 : index;
- if( m_DisplayIndex != index )
- {
- typedef itk::Image<TPixelType,3> ImgType;
- typename ImgType::Pointer img = ImgType::New();
- CastToItkImage(this, img);
-
- itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
- itw.GoToBegin();
-
- itk::ImageRegionConstIterator<ImageType> itr (m_VectorImage, m_VectorImage->GetLargestPossibleRegion() );
- itr.GoToBegin();
-
- while(!itr.IsAtEnd())
- {
- itw.Set(itr.Get().GetElement(index));
- ++itr;
- ++itw;
- }
- }
-
- m_DisplayIndex = index;
-}
-
-template<typename TPixelType>
-bool mitk::DiffusionImage<TPixelType>::AreAlike(GradientDirectionType g1,
- GradientDirectionType g2,
- double precision)
-{
- GradientDirectionType diff = g1 - g2;
- GradientDirectionType diff2 = g1 + g2;
- return diff.two_norm() < precision || diff2.two_norm() < precision;
-}
-
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Pointer
-mitk::DiffusionImage<TPixelType>::CalcAveragedDirectionSet(double precision, GradientDirectionContainerType::Pointer directions)
-{
- // save old and construct new direction container
- GradientDirectionContainerType::Pointer newDirections = GradientDirectionContainerType::New();
-
- // fill new direction container
- for(GradientDirectionContainerType::ConstIterator gdcitOld = directions->Begin();
- gdcitOld != directions->End(); ++gdcitOld)
- {
- // already exists?
- bool found = false;
- for(GradientDirectionContainerType::ConstIterator gdcitNew = newDirections->Begin();
- gdcitNew != newDirections->End(); ++gdcitNew)
- {
- if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
- {
- found = true;
- break;
- }
- }
-
- // if not found, add it to new container
- if(!found)
- {
- newDirections->push_back(gdcitOld.Value());
- }
- }
-
- return newDirections;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::AverageRedundantGradients(double precision)
-{
-
- GradientDirectionContainerType::Pointer newDirs =
- CalcAveragedDirectionSet(precision, m_Directions);
-
- GradientDirectionContainerType::Pointer newOriginalDirs =
- CalcAveragedDirectionSet(precision, m_OriginalDirections);
-
- // if sizes equal, we do not need to do anything in this function
- if(m_Directions->size() == newDirs->size() || m_OriginalDirections->size() == newOriginalDirs->size())
- return;
-
- GradientDirectionContainerType::Pointer oldDirections = m_OriginalDirections;
- m_Directions = newDirs;
- m_OriginalDirections = newOriginalDirs;
-
- // new image
- typename ImageType::Pointer oldImage = m_VectorImage;
- m_VectorImage = ImageType::New();
- m_VectorImage->SetSpacing( oldImage->GetSpacing() ); // Set the image spacing
- m_VectorImage->SetOrigin( oldImage->GetOrigin() ); // Set the image origin
- m_VectorImage->SetDirection( oldImage->GetDirection() ); // Set the image direction
- m_VectorImage->SetLargestPossibleRegion( oldImage->GetLargestPossibleRegion() );
- m_VectorImage->SetVectorLength( m_Directions->size() );
- m_VectorImage->SetBufferedRegion( oldImage->GetLargestPossibleRegion() );
- m_VectorImage->Allocate();
-
- // average image data that corresponds to identical directions
- itk::ImageRegionIterator< ImageType > newIt(m_VectorImage, m_VectorImage->GetLargestPossibleRegion());
- newIt.GoToBegin();
- itk::ImageRegionIterator< ImageType > oldIt(oldImage, oldImage->GetLargestPossibleRegion());
- oldIt.GoToBegin();
-
- // initial new value of voxel
- typename ImageType::PixelType newVec;
- newVec.SetSize(m_Directions->size());
- newVec.AllocateElements(m_Directions->size());
-
- std::vector<std::vector<int> > dirIndices;
- for(GradientDirectionContainerType::ConstIterator gdcitNew = m_Directions->Begin();
- gdcitNew != m_Directions->End(); ++gdcitNew)
- {
- dirIndices.push_back(std::vector<int>(0));
- for(GradientDirectionContainerType::ConstIterator gdcitOld = oldDirections->Begin();
- gdcitOld != oldDirections->End(); ++gdcitOld)
- {
- if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
- {
- //MITK_INFO << gdcitNew.Value() << " " << gdcitOld.Value();
- dirIndices[gdcitNew.Index()].push_back(gdcitOld.Index());
- }
- }
- }
-
- //int ind1 = -1;
- while(!newIt.IsAtEnd())
- {
-
- // progress
- //typename ImageType::IndexType ind = newIt.GetIndex();
- //ind1 = ind.m_Index[2];
-
- // init new vector with zeros
- newVec.Fill(0.0);
-
- // the old voxel value with duplicates
- typename ImageType::PixelType oldVec = oldIt.Get();
-
- for(unsigned int i=0; i<dirIndices.size(); i++)
- {
- // do the averaging
- const unsigned int numavg = dirIndices[i].size();
- unsigned int sum = 0;
- for(unsigned int j=0; j<numavg; j++)
- {
- //MITK_INFO << newVec[i] << " << " << oldVec[dirIndices[i].at(j)];
- sum += oldVec[dirIndices[i].at(j)];
- }
- if(numavg == 0)
- {
- MITK_ERROR << "mitkDiffusionImage: Error on averaging. Possibly due to corrupted data";
- return;
- }
- newVec[i] = sum / numavg;
- }
-
- newIt.Set(newVec);
-
- ++newIt;
- ++oldIt;
- }
- ApplyMeasurementFrame();
- UpdateBValueMap();
- std::cout << std::endl;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::ApplyMeasurementFrame()
-{
- if(m_OriginalDirections.IsNull())
- {
- // original direction container was not set
- return;
- }
-
- m_Directions = GradientDirectionContainerType::New();
- int c = 0;
- for(GradientDirectionContainerType::ConstIterator gdcit = m_OriginalDirections->Begin();
- gdcit != m_OriginalDirections->End(); ++gdcit)
- {
- vnl_vector<double> vec = gdcit.Value();
- vec = vec.pre_multiply(m_MeasurementFrame);
- m_Directions->InsertElement(c, vec);
- c++;
- }
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::UpdateBValueMap()
-{
- if(!m_B_ValueMap.empty())
- m_B_ValueMap.clear();
-
- GradientDirectionContainerType::ConstIterator gdcit;
- for( gdcit = this->m_Directions->Begin(); gdcit != this->m_Directions->End(); ++gdcit)
- m_B_ValueMap[this->GetB_Value(gdcit.Index())].push_back(gdcit.Index());
-}
-
-template<typename TPixelType>
-float mitk::DiffusionImage<TPixelType>::GetB_Value(unsigned int i)
-{
- if(i > m_Directions->Size()-1)
- return -1;
-
- if(m_Directions->ElementAt(i).one_norm() <= 0.0)
- {
- return 0;
- }
- else
- {
- double twonorm = m_Directions->ElementAt(i).two_norm();
- double bval = m_B_Value*twonorm*twonorm;
-
- if (bval<0)
- bval = ceil(bval - 0.5);
- else
- bval = floor(bval + 0.5);
-
- return bval;
- }
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetDirections( GradientDirectionContainerType::Pointer directions )
-{
- this->m_OriginalDirections = directions;
- ApplyMeasurementFrame();
- UpdateBValueMap();
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetDirections(const std::vector<itk::Vector<double, 3> > &directions)
-{
- GradientDirectionContainerType::Pointer tempContainer = GradientDirectionContainerType::New();
- for(unsigned int i=0; i<directions.size(); i++)
- tempContainer->InsertElement( i, directions[i].GetVnlVector() );
- SetDirections(tempContainer);
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImage<TPixelType>::MeasurementFrameType mitk::DiffusionImage<TPixelType>::GetMeasurementFrame() const
-{
- return m_MeasurementFrame;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetMeasurementFrame( const MeasurementFrameType & mFrame )
-{
- m_MeasurementFrame = mFrame;
- ApplyMeasurementFrame();
-}
-
-template<typename TPixelType>
-bool mitk::DiffusionImage<TPixelType>::GetNumberOfBValues() const
-{
- return m_B_ValueMap.size();
-}
-
-template<typename TPixelType>
-const typename mitk::DiffusionImage<TPixelType>::BValueMap & mitk::DiffusionImage<TPixelType>::GetBValueMap() const
-{
- return m_B_ValueMap;
-}
-
-template<typename TPixelType>
-float mitk::DiffusionImage<TPixelType>::GetReferenceBValue() const
-{
- return m_B_Value;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetReferenceBValue( float val )
-{
- m_B_Value = val;
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerTypePointer mitk::DiffusionImage<TPixelType>::GetDirections() const
-{
- return m_Directions;
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerTypePointer mitk::DiffusionImage<TPixelType>::GetDirectionsWithoutMeasurementFrame() const
-{
- return m_OriginalDirections;
-}
-
-template<typename TPixelType>
-typename itk::VectorImage<TPixelType, 3>::Pointer mitk::DiffusionImage<TPixelType>::GetVectorImage()
-{
- return m_VectorImage;
-}
-
-template<typename TPixelType>
-const typename itk::VectorImage<TPixelType, 3>::Pointer mitk::DiffusionImage<TPixelType>::GetVectorImage() const
-{
- return m_VectorImage;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetVectorImage(typename ImageType::Pointer image )
-{
- m_VectorImage = image;
-}
-
-template<class TPixelType>
-inline bool mitk::Equal(const mitk::DiffusionImage<TPixelType>& leftHandSide, const mitk::DiffusionImage<TPixelType> &rightHandSide, ScalarType eps, bool verbose )
-{
-
- bool returnValue = true;
-
- if(leftHandSide.GetReferenceBValue() != rightHandSide.GetReferenceBValue())
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] Reference BValue is not Equal.";
- returnValue = false;
- }
-
- if(leftHandSide.GetMeasurementFrame() != rightHandSide.GetMeasurementFrame())
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] MeasurementFrame is not Equal.";
- returnValue = false;
- }
-
- if(leftHandSide.GetBValueMap().size() != rightHandSide.GetBValueMap().size())
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] BValue Map: Size is not Equal.";
- returnValue = false;
- }
-
- if(leftHandSide.GetNumberOfBValues() != rightHandSide.GetNumberOfBValues())
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] BValue Map (GetNumberOfBValues): Size is not Equal.";
- returnValue = false;
- }
-
- // Slow testing area
-
- const mitk::Image* img1 = dynamic_cast<const mitk::Image*>(&leftHandSide);
- const mitk::Image* img2 = dynamic_cast<const mitk::Image*>(&rightHandSide);
-
- if(mitk::Equal(*img1,*img2,eps,verbose) == false)
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] Base-Class (mitk::Image) is not Equal.";
- returnValue = false;
- }
-
- {
- typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsIt = leftHandSide.GetDirectionsWithoutMeasurementFrame()->Begin();
- typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsItEnd = leftHandSide.GetDirectionsWithoutMeasurementFrame()->End();
- typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator rhsIt = rightHandSide.GetDirectionsWithoutMeasurementFrame()->Begin();
-
- for(;lhsIt != lhsItEnd;)
- {
- bool vectorNotEqual = false;
- for(unsigned int i = 0 ; i < lhsIt.Value().size(); i++)
- vectorNotEqual |= !mitk::Equal(lhsIt.Value().get(i),rhsIt.Value().get(i),0.0001);
-
- if(vectorNotEqual)
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] Original GradientDirections are not Equal.";
- returnValue = false;
- break;
- }
- ++rhsIt;
- ++lhsIt;
- }
- }
-
- {
- typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsIt = leftHandSide.GetDirections()->Begin();
- typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsItEnd = leftHandSide.GetDirections()->End();
- typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator rhsIt = rightHandSide.GetDirections()->Begin();
-
- for(;lhsIt != lhsItEnd;)
- {
- bool vectorNotEqual = false;
- for(unsigned int i = 0 ; i < lhsIt.Value().size(); i++)
- vectorNotEqual |= !mitk::Equal(lhsIt.Value().get(i),rhsIt.Value().get(i),0.0001);
-
- if(vectorNotEqual)
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] GradientDirections are not Equal.";
- returnValue = false;
- break;
- }
- ++rhsIt;
- ++lhsIt;
- }
- }
-
- {
-
- typename mitk::DiffusionImage<TPixelType>::BValueMap rhsMap = rightHandSide.GetBValueMap();
- typename mitk::DiffusionImage<TPixelType>::BValueMap lhsMap = leftHandSide.GetBValueMap();
- typename mitk::DiffusionImage<TPixelType>::BValueMap::const_iterator lhsIt = lhsMap.begin();
- typename mitk::DiffusionImage<TPixelType>::BValueMap::const_iterator lhsItEnd = lhsMap.end();
- typename mitk::DiffusionImage<TPixelType>::BValueMap::const_iterator rhsIt = rhsMap.begin();
-
- for(;lhsIt != lhsItEnd;)
- {
- if(lhsIt->first != rhsIt->first)
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] BValue Map: lhsKey " << lhsIt->first << " != rhsKey " << rhsIt->first << " is not Equal.";
- returnValue = false;
- break;
- }
-
- if(lhsIt->second.size() != rhsIt->second.size())
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] BValue Map: Indices vector size is not Equal. (Key: " << lhsIt->first <<")";
- returnValue = false;
- break;
- }
-
-
- typename mitk::DiffusionImage<TPixelType>::IndicesVector::const_iterator lhsIndVecIt = lhsIt->second.begin();
- typename mitk::DiffusionImage<TPixelType>::IndicesVector::const_iterator lhsIndVecItEnd = lhsIt->second.end();
- typename mitk::DiffusionImage<TPixelType>::IndicesVector::const_iterator rhsIndVecIt = rhsIt->second.begin();
-
- for(;lhsIndVecIt != lhsIndVecItEnd;)
- {
- if(*lhsIndVecIt != *rhsIndVecIt)
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] BValue Map: Indices are not Equal. (Key: " << lhsIt->first <<")";
- returnValue = false;
- break;
- }
- ++rhsIndVecIt;
- ++lhsIndVecIt;
- }
-
- lhsIt++;
- rhsIt++;
- }
- }
-
-
- try{
- itk::ImageRegionIterator< itk::VectorImage< TPixelType, 3 > > it1(leftHandSide.GetVectorImage(), leftHandSide.GetVectorImage()->GetLargestPossibleRegion());
- itk::ImageRegionIterator< itk::VectorImage< TPixelType, 3 > > it2(rightHandSide.GetVectorImage(), rightHandSide.GetVectorImage()->GetLargestPossibleRegion());
- while(!it1.IsAtEnd())
- {
- if (it1.Get()!=it2.Get()){
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] Capsulated itk::VectorImage is not Equal.";
- returnValue = false;
- break;
- }
- ++it1;
- ++it2;
- }
- }
- catch(...)
- {
- if(verbose)
- MITK_INFO << "[( DiffusionImage )] Comparision of itk Vector image abort by exception.";
- returnValue = false;
- }
-
- return returnValue;
-}
-
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
index 2f909c5b73..d93af7cf2d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
@@ -1,117 +1,118 @@
/*===================================================================
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 MITKDIFFUSIONIMAGECORRECTIONFILTER_CPP
#define MITKDIFFUSIONIMAGECORRECTIONFILTER_CPP
#include "mitkDiffusionImageCorrectionFilter.h"
+#include <mitkDiffusionPropertyHelper.h>
#include <vnl/algo/vnl_symmetric_eigensystem.h>
#include <vnl/vnl_inverse.h>
-template< typename TPixelType >
-mitk::DiffusionImageCorrectionFilter<TPixelType>::DiffusionImageCorrectionFilter()
+
+mitk::DiffusionImageCorrectionFilter::DiffusionImageCorrectionFilter()
{
}
-template< typename TPixelType >
-typename mitk::DiffusionImageCorrectionFilter<TPixelType>::TransformMatrixType
-mitk::DiffusionImageCorrectionFilter<TPixelType>
+
+mitk::DiffusionImageCorrectionFilter::TransformMatrixType
+mitk::DiffusionImageCorrectionFilter
::GetRotationComponent(const TransformMatrixType &A)
{
TransformMatrixType B;
B = A * A.transpose();
// get the eigenvalues and eigenvectors
typedef double MType;
vnl_vector< MType > eigvals;
vnl_matrix< MType > eigvecs;
vnl_symmetric_eigensystem_compute< MType > ( B, eigvecs, eigvals );
vnl_matrix_fixed< MType, 3, 3 > eigvecs_fixed;
eigvecs_fixed.set_columns(0, eigvecs );
TransformMatrixType C;
C.set_identity();
vnl_vector_fixed< MType, 3 > eigvals_sqrt;
for(unsigned int i=0; i<3; i++)
{
C(i,i) = std::sqrt( eigvals[i] );
}
TransformMatrixType S = vnl_inverse( eigvecs_fixed * C * vnl_inverse( eigvecs_fixed )) * A;
return S;
}
-template< typename TPixelType >
-void mitk::DiffusionImageCorrectionFilter<TPixelType>
+
+void mitk::DiffusionImageCorrectionFilter
::CorrectDirections( const TransformsVectorType& transformations)
{
if( m_SourceImage.IsNull() )
{
mitkThrow() << " No diffusion image given! ";
}
- GradientDirectionContainerPointerType directions = m_SourceImage->GetDirections();
+ GradientDirectionContainerPointerType directions = static_cast<mitk::GradientDirectionsProperty*>( m_SourceImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
GradientDirectionContainerPointerType corrected_directions =
GradientDirectionContainerType::New();
unsigned int transformed = 0;
for(size_t i=0; i< directions->Size(); i++ )
{
// skip b-zero images
if( directions->ElementAt(i).one_norm() <= 0.0 )
{
corrected_directions->push_back( directions->ElementAt(i) );
continue;
}
GradientDirectionType corrected = GetRotationComponent(
transformations.at(transformed))
* directions->ElementAt(i);
// store the corrected direction
corrected_directions->push_back( corrected );
transformed++;
}
// replace the old directions with the corrected ones
- m_SourceImage->SetDirections( corrected_directions );
+ m_SourceImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( corrected_directions ) );
}
-template< typename TPixelType >
-void mitk::DiffusionImageCorrectionFilter<TPixelType>
+
+void mitk::DiffusionImageCorrectionFilter
::CorrectDirections( const TransformMatrixType& transformation)
{
if( m_SourceImage.IsNull() )
{
mitkThrow() << " No diffusion image given! ";
}
TransformsVectorType transfVec;
- for (unsigned int i=0; i< m_SourceImage->GetDirections()->Size();i++)
+ for (unsigned int i=0; i< static_cast<mitk::GradientDirectionsProperty*>( m_SourceImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size();i++)
{
transfVec.push_back(transformation);
}
this->CorrectDirections(transfVec);
}
#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h
index 7d6c3b3e59..405cea700d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h
@@ -1,97 +1,96 @@
/*===================================================================
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 MITKDIFFUSIONIMAGECORRECTIONFILTER_H
#define MITKDIFFUSIONIMAGECORRECTIONFILTER_H
-#include "mitkDiffusionImageSource.h"
+#include "mitkImageSource.h"
+#include <MitkDiffusionCoreExports.h>
namespace mitk
{
/**
* @class DiffusionImageCorrectionFilter
*/
-template< typename TPixelType >
-class DiffusionImageCorrectionFilter
- : public DiffusionImageSource< TPixelType >
+class MitkDiffusionCore_EXPORT DiffusionImageCorrectionFilter
+ : public ImageSource
{
public:
/** class macros */
mitkClassMacro( DiffusionImageCorrectionFilter,
- DiffusionImageSource<TPixelType> )
+ ImageSource )
itkSimpleNewMacro(Self)
+ typedef short DiffusionPixelType;
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
typedef vnl_matrix_fixed< double, 3, 3 > TransformMatrixType;
typedef itk::VectorContainer< unsigned int, GradientDirectionType >
GradientDirectionContainerType;
typedef GradientDirectionContainerType::Pointer GradientDirectionContainerPointerType;
typedef std::vector< TransformMatrixType > TransformsVectorType;
- typedef typename Superclass::OutputType DiffusionImageType;
- typedef typename DiffusionImageType::Pointer DiffusionImageTypePointer;
- typedef itk::VectorImage<TPixelType,3> ImageType;
+ typedef Superclass::OutputType DiffusionImageType;
+ typedef DiffusionImageType::Pointer DiffusionImageTypePointer;
+ typedef itk::VectorImage<DiffusionPixelType,3> ImageType;
/**
* @brief Set the mitk image ( a 3d+t image ) which is to be reinterpreted as dw image
* @param mitkImage
*/
void SetImage( DiffusionImageTypePointer input )
{
m_SourceImage = input;
}
/**
* @brief Correct each gradient direction according to the given transform
*
* The size of the input is expected to correspond to the count of gradient images in the image.
*/
void CorrectDirections( const TransformsVectorType& );
/**
* @brief Correct all gradient directions according to the given transform
*
* This will apply the same rotation to all directions.
*/
void CorrectDirections( const TransformMatrixType& );
protected:
DiffusionImageCorrectionFilter();
virtual ~DiffusionImageCorrectionFilter() {}
/**
* @brief Get the rotation component following the Finite Strain
*
* For a given transformation \f$A\f$ its rotation component is defined as \f$ (AA^{T})^{-1/2}\f$.
*
* The computation first computes \f$ B = AA^T \f$ and then estimates the square root. Square root of
* diagonal matrices is defined as
* \f$ S = Q * \sqrt{C} * Q^{-1} \f$ with \f$ C \f$ having the eigenvalues on the diagonal.
*
*/
TransformMatrixType GetRotationComponent( const TransformMatrixType& );
DiffusionImageTypePointer m_SourceImage;
};
}
-#include "mitkDiffusionImageCorrectionFilter.cpp"
-
#endif // MITKDIFFUSIONIMAGECORRECTIONFILTER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
deleted file mode 100644
index ce24a5b93e..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*===================================================================
-
-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 __MITK_DIFFUSIONIMAGE_SOURCE_CPP__
-#define __MITK_DIFFUSIONIMAGE_SOURCE_CPP__
-
-#include "mitkDiffusionImageSource.h"
-#include "mitkDiffusionImage.h"
-
-template<typename TPixelType>
-mitk::DiffusionImageSource<TPixelType>::DiffusionImageSource()
-{
- // Create the output. We use static_cast<> here because we know the default
- // output must be of type DiffusionImage
- typename mitk::DiffusionImage<TPixelType>::Pointer output
- = static_cast<typename mitk::DiffusionImage<TPixelType>*>(this->MakeOutput(0).GetPointer());
-
- Superclass::SetNumberOfRequiredOutputs(1);
- Superclass::SetNthOutput(0, output.GetPointer());
-}
-
-template<typename TPixelType>
-mitk::DiffusionImageSource<TPixelType>::~DiffusionImageSource()
-{
-}
-
-template<typename TPixelType>
-itk::DataObject::Pointer mitk::DiffusionImageSource<TPixelType>::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
-{
- return OutputType::New().GetPointer();
-}
-
-
-template<typename TPixelType>
-itk::DataObject::Pointer mitk::DiffusionImageSource<TPixelType>::MakeOutput( const DataObjectIdentifierType & name )
-{
- itkDebugMacro("MakeOutput(" << name << ")");
- if( this->IsIndexedOutputName(name) )
- {
- return this->MakeOutput( this->MakeIndexFromOutputName(name) );
- }
- return static_cast<itk::DataObject *>(OutputType::New().GetPointer());
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(void)
-{
- return itkDynamicCastInDebugMode<OutputType*>( this->GetPrimaryOutput() );
-}
-
-template<typename TPixelType>
-const typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(void) const
-{
- return itkDynamicCastInDebugMode<const OutputType*>( this->GetPrimaryOutput() );
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(DataObjectPointerArraySizeType idx)
-{
- OutputType* out = dynamic_cast<OutputType*>( this->ProcessObject::GetOutput(idx) );
- if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
- {
- itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( OutputType ).name () );
- }
- return out;
-}
-
-template<typename TPixelType>
-const typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(DataObjectPointerArraySizeType idx) const
-{
- const OutputType* out = dynamic_cast<const OutputType*>( this->ProcessObject::GetOutput(idx) );
- if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
- {
- itkWarningMacro (<< "Unable to convert output number " << idx << " to type " << typeid( OutputType ).name () );
- }
- return out;
-}
-
-#endif //__MITK_DIFFUSIONIMAGE_SOURCE_CPP__
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
deleted file mode 100644
index ae199534a9..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*===================================================================
-
-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 _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
-#define _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
-
-#include "mitkImageSource.h"
-
-namespace mitk {
-
- template<typename TPixelType>
- class DiffusionImage;
- /*class DiffusionImage<double>;
- class DiffusionImage<int>;
- class DiffusionImage<unsigned int>;
- class DiffusionImage<short>;
- class DiffusionImage<unsigned short>;
- class DiffusionImage<char>;
- class DiffusionImage<unsigned char>;
- class DiffusionImage<long>;
- class DiffusionImage<unsigned long>;*/
-
-//##Documentation
-//## @brief Superclass of all classes generating diffusion volumes (instances
-//## of class DiffusionImage) as output.
-//##
-//## @ingroup Process
-template<typename TPixelType>
-class DiffusionImageSource : public ImageSource
-{
-public:
- mitkClassMacro(DiffusionImageSource, BaseDataSource);
- itkFactorylessNewMacro(Self)
- itkCloneMacro(Self)
-
- typedef DiffusionImage<TPixelType> OutputType;
- typedef itk::DataObject::Pointer DataObjectPointer;
-
- /**
- * @brief Get the output data of the diffusion image source object.
- */
- mitkBaseDataSourceGetOutputDeclarations
-
- /**
- * Allocates a new output object and returns it. Currently the
- * index idx is not evaluated.
- * @param idx the index of the output for which an object should be created
- * @returns the new object
- */
- virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
-
- /**
- * This is a default implementation to make sure we have something.
- * Once all the subclasses of ProcessObject provide an appopriate
- * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
- * virtual.
- */
- virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
-
-protected:
- DiffusionImageSource();
-
- virtual ~DiffusionImageSource();
-};
-
-} // namespace mitk
-
-#include "mitkDiffusionImageSource.cpp"
-
-
-#endif /* _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp
deleted file mode 100644
index 6dcbfbba98..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*===================================================================
-
-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 __mitk_ImageToDiffusionImageSource_txx
-#define __mitk_ImageToDiffusionImageSource_txx
-
-#include "mitkImageToDiffusionImageSource.h"
-
-#include <itkComposeImageFilter.h>
-#include <itkExtractImageFilter.h>
-
-#include "mitkImageTimeSelector.h"
-
-#include <itkVectorImage.h>
-#include <itkImage.h>
-
-#include "mitkImageCast.h"
-
-#include "mitkException.h"
-
-template< typename TPixelType>
-mitk::ImageToDiffusionImageSource<TPixelType>::ImageToDiffusionImageSource()
- : m_SourceImage(0),
- m_GradientDirections(0)
-{
-
-}
-
-template< typename TPixelType>
-void mitk::ImageToDiffusionImageSource<TPixelType>
-::GenerateOutputInformation()
-{
- // sanity checks ( input not null, timesteps corresponds to number of directions specified )
- if( m_GradientDirections.IsNull() || m_GradientDirections->empty() )
- {
- mitkThrow() << "No gradient directions were set. Cannot proceed.";
- }
-
- if( m_SourceImage.IsNull() )
- {
- mitkThrow() << "No input image was set. Cannot proceed.";
- }
-
- if( m_GradientDirections->size() != m_SourceImage->GetTimeSteps() )
- {
- mitkThrow() << "Size mismatch between container size " << m_GradientDirections->size() <<
- "and image volumes."<< m_SourceImage->GetTimeSteps() <<" Cannot proceed.";
- }
-
-
- // already pass in the meta-data
- typename OutputType::Pointer metaImage = OutputType::New();
-
- // set identity as measurement frame
- vnl_matrix_fixed< double, 3, 3 > measurement_frame;
- measurement_frame.set_identity();
- metaImage->SetMeasurementFrame( measurement_frame );
-
- // set directions and bvalue
- metaImage->SetDirections(this->m_GradientDirections);
- metaImage->SetReferenceBValue(this->m_BValue);
-
- m_OutputCache = metaImage;
- m_CacheTime.Modified();
-
-}
-
-template< typename TPixelType>
-void mitk::ImageToDiffusionImageSource<TPixelType>
-::GenerateData()
-{
- if ( ( ! m_OutputCache ) || ( this->GetMTime( ) > m_CacheTime.GetMTime( ) ) )
- {
- this->GenerateOutputInformation();
- itkWarningMacro("Cache regenerated!");
- }
-
- // now cast the mitk image to the vector image and pass in as volume
- typedef itk::Image< TPixelType, 4 > InputItkType;
- typedef itk::Image< TPixelType, 3> SingleVolumeType;
- typedef itk::VectorImage< TPixelType, 3> VectorImageType;
-
- typedef itk::ComposeImageFilter< SingleVolumeType > ComposeFilterType;
- typename ComposeFilterType::Pointer vec_composer = ComposeFilterType::New();
-
- mitk::ImageTimeSelector::Pointer t_selector =
- mitk::ImageTimeSelector::New();
-
- t_selector->SetInput( m_SourceImage );
-
- for( unsigned int i=0; i< m_SourceImage->GetTimeSteps(); i++)
- {
- t_selector->SetTimeNr(i);
- t_selector->Update();
-
- typename SingleVolumeType::Pointer singleImageItk;
- mitk::CastToItkImage( t_selector->GetOutput(), singleImageItk );
-
- vec_composer->SetInput( i, singleImageItk );
-
- }
-
- try
- {
- vec_composer->Update();
- }
- catch( const itk::ExceptionObject& e)
- {
- MITK_ERROR << "Caugt exception while updating compose filter: " << e.what();
- }
-
-
- m_OutputCache->SetVectorImage( vec_composer->GetOutput() );
-
- // transfer to the output image
- static_cast<OutputType*>(this->GetOutput())
- ->SetVectorImage(m_OutputCache->GetVectorImage());
- static_cast<OutputType*>(this->GetOutput())
- ->SetReferenceBValue(m_OutputCache->GetReferenceBValue());
- static_cast<OutputType*>(this->GetOutput())
- ->SetMeasurementFrame(m_OutputCache->GetMeasurementFrame());
- static_cast<OutputType*>(this->GetOutput())
- ->SetDirections(m_OutputCache->GetDirections());
- static_cast<OutputType*>(this->GetOutput())
- ->InitializeFromVectorImage();
-
-
-}
-
-#endif //__mitk_ImageToDiffusionImageSource_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.h
deleted file mode 100644
index 0b31f3c261..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*===================================================================
-
-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 MITKIMAGETODIFFUSIONIMAGESOURCE_H
-#define MITKIMAGETODIFFUSIONIMAGESOURCE_H
-
-#include "mitkDiffusionImageSource.h"
-
-namespace mitk
-{
-/**
- * @class ImageToDiffusionImageSource
- * @brief The class requires a 3d+t image, list of gradient directions and a corresponding b-value
- * and reinterprets the input image as a diffusion-weighted image.
- *
- * The filter throws an mitk::Exception if
- * - no gradient list was set
- * - no input image was set
- * - the size of the gradient list and the count of timesteps do not match
- */
-template< typename TPixelType >
-class ImageToDiffusionImageSource
- : public DiffusionImageSource< TPixelType >
-{
-public:
-
- typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
- typedef vnl_matrix_fixed< double, 3, 3 > MeasurementFrameType;
- typedef itk::VectorContainer< unsigned int,
- GradientDirectionType >::Pointer GradientDirectionContainerType;
-
- mitkClassMacro( ImageToDiffusionImageSource,
- DiffusionImageSource<TPixelType> )
-
- itkSimpleNewMacro(Self)
-
- typedef typename Superclass::OutputType OutputType;
- typedef itk::VectorImage<TPixelType,3> ImageType;
-
- /**
- * @brief Set the mitk image ( a 3d+t image ) which is to be reinterpreted as dw image
- * @param mitkImage
- */
- void SetImage( mitk::Image::Pointer mitkImage )
- {
- m_SourceImage = mitkImage;
- }
-
- /**
- * @brief Set the gradient directions corresponding to the volumes of the input image
- * @param container the container with the gradient directions
- *
- * @note The gradient directions must correspond to the volumes stored in the 3d+t input
- */
- void SetGradientDirections( GradientDirectionContainerType container )
- {
- m_GradientDirections = container;
- }
-
- /**
- * @brief Set the b-value
- * @param bvalue the b-value associated with the gradient list
- */
- void SetBValue( float bvalue )
- {
- this->m_BValue = bvalue;
- }
-
-
-protected:
- ImageToDiffusionImageSource();
- virtual ~ImageToDiffusionImageSource(){}
-
- virtual void GenerateData();
-
- virtual void GenerateOutputInformation();
-
- mitk::Image::Pointer m_SourceImage;
- GradientDirectionContainerType m_GradientDirections;
-
- typename OutputType::Pointer m_OutputCache;
- itk::TimeStamp m_CacheTime;
-
- float m_BValue;
-};
-
-
-}
-
-#include "mitkImageToDiffusionImageSource.cpp"
-#endif // MITKIMAGETODIFFUSIONIMAGESOURCE_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.cpp
new file mode 100644
index 0000000000..3e364ab6e7
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.cpp
@@ -0,0 +1,103 @@
+/*===================================================================
+
+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 "mitkBValueMapProperty.h"
+
+mitk::BValueMapProperty::BValueMapProperty()
+ : m_BValueMap()
+{
+}
+
+mitk::BValueMapProperty::BValueMapProperty(const BValueMapProperty& other)
+ : mitk::BaseProperty(other)
+{
+ m_BValueMap = other.GetBValueMap();
+}
+
+mitk::BValueMapProperty::BValueMapProperty(const BValueMap& bValueMap)
+{
+ m_BValueMap = bValueMap;
+}
+
+mitk::BValueMapProperty::~BValueMapProperty()
+{
+}
+
+const mitk::BValueMapProperty::BValueMap & mitk::BValueMapProperty::GetBValueMap() const
+{
+ return m_BValueMap;
+}
+
+void mitk::BValueMapProperty::SetBValueMap(const BValueMap & map)
+{
+ this->m_BValueMap = map;
+}
+
+bool mitk::BValueMapProperty::IsEqual(const BaseProperty& property) const
+{
+ return this->m_BValueMap == static_cast<const Self&>(property).m_BValueMap;
+}
+
+bool mitk::BValueMapProperty::Assign(const BaseProperty& property)
+{
+ this->m_BValueMap = static_cast<const Self&>(property).m_BValueMap;
+ return true;
+}
+
+mitk::BValueMapProperty::BValueMap mitk::BValueMapProperty::CreateBValueMap(const mitk::BValueMapProperty::GradientDirectionsContainerType * gdc, float referenceBValue)
+{
+ mitk::BValueMapProperty::BValueMap map;
+
+ mitk::BValueMapProperty::GradientDirectionsContainerType::ConstIterator gdcit;
+ for( gdcit = gdc->Begin(); gdcit != gdc->End(); ++gdcit)
+ {
+ float keyBValue = mitk::BValueMapProperty::GetBValueOfGradientDirection(gdcit.Index(),referenceBValue, gdc);
+ map[keyBValue].push_back(gdcit.Index());
+ }
+
+ return map;
+}
+
+
+float mitk::BValueMapProperty::GetBValueOfGradientDirection(unsigned int i, float referenceBValue, const mitk::BValueMapProperty::GradientDirectionsContainerType * gdc)
+{
+ if(i > gdc->Size()-1)
+ return -1;
+
+ if(gdc->ElementAt(i).one_norm() <= 0.0)
+ {
+ return 0;
+ }
+ else
+ {
+ double twonorm = gdc->ElementAt(i).two_norm();
+ double bval = referenceBValue*twonorm*twonorm;
+
+ if (bval<0)
+ bval = ceil(bval - 0.5);
+ else
+ bval = floor(bval + 0.5);
+
+ return bval;
+ }
+}
+
+itk::LightObject::Pointer mitk::BValueMapProperty::InternalClone() const
+{
+ itk::LightObject::Pointer result(new Self(*this));
+ result->UnRegister();
+ return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.h
new file mode 100644
index 0000000000..6fee11e8e3
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.h
@@ -0,0 +1,74 @@
+/*===================================================================
+
+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 MITKBVALUEMAPPROPERTY_H
+#define MITKBVALUEMAPPROPERTY_H
+
+#include "mitkBaseProperty.h"
+#include <map>
+#include <vector>
+
+#include <MitkDiffusionCoreExports.h>
+#include <itkVectorContainer.h>
+#include <vnl/vnl_vector_fixed.h>
+namespace mitk
+{
+
+ /** This property will store the b value map */
+
+ class MitkDiffusionCore_EXPORT BValueMapProperty : public mitk::BaseProperty
+ {
+ public:
+ /**
+ * \brief The BValueMap contains seperated IndicesVectors for each b value (index for GradientDirectionContainer)
+ * key := b value
+ * value := indicesVector
+ */
+ typedef std::map< unsigned int , std::vector< unsigned int > > BValueMap;
+ typedef unsigned int IndexType;
+ typedef vnl_vector_fixed< double, 3 > ValueType;
+ typedef ValueType GradientDirectionType;
+ typedef itk::VectorContainer< IndexType, GradientDirectionType > GradientDirectionsContainerType;
+ mitkClassMacro(BValueMapProperty, BaseProperty)
+
+ itkFactorylessNewMacro(Self)
+ itkCloneMacro(Self)
+
+ mitkNewMacro1Param(BValueMapProperty, const BValueMapProperty&)
+ mitkNewMacro1Param(BValueMapProperty, const BValueMap&)
+
+ const BValueMap & GetBValueMap() const;
+ void SetBValueMap(const BValueMap & map);
+
+ static BValueMap CreateBValueMap(const GradientDirectionsContainerType * gdc, float referenceBValue);
+ static float GetBValueOfGradientDirection(unsigned int i, float referenceBValue, const GradientDirectionsContainerType *gdc);
+ protected:
+
+ BValueMapProperty();
+ ~BValueMapProperty();
+
+ BValueMapProperty(const BValueMapProperty& other);
+ BValueMapProperty(const BValueMap& bValueMap);
+
+ virtual bool IsEqual(const BaseProperty& property) const;
+ virtual bool Assign(const BaseProperty & property);
+
+ BValueMap m_BValueMap;
+
+ virtual itk::LightObject::Pointer InternalClone() const;
+ };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp
new file mode 100644
index 0000000000..f406a883e3
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp
@@ -0,0 +1,131 @@
+/*===================================================================
+
+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 mitkBValueMapPropertySerializer_h_included
+#define mitkBValueMapPropertySerializer_h_included
+
+#include "mitkBasePropertySerializer.h"
+
+#include "mitkBValueMapProperty.h"
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+class MitkDiffusionCore_EXPORT BValueMapPropertySerializer : public BasePropertySerializer
+{
+
+protected:
+
+
+ void split(const std::string &s, char delim, std::vector<unsigned int> &elems) {
+ std::stringstream ss(s);
+ std::string item;
+ while (std::getline(ss, item, delim)) {
+ elems.push_back(std::atoi(item.c_str()));
+ }
+ }
+
+ std::vector<unsigned int> split(const std::string &s, char delim) {
+ std::vector<unsigned int> elems;
+ split(s, delim, elems);
+ return elems;
+ }
+
+public:
+
+ mitkClassMacro( BValueMapPropertySerializer, BasePropertySerializer )
+ itkFactorylessNewMacro(Self)
+ itkCloneMacro(Self)
+
+ virtual TiXmlElement* Serialize()
+ {
+ if (const BValueMapProperty* prop = dynamic_cast<const BValueMapProperty*>(m_Property.GetPointer()))
+ {
+
+ BValueMapProperty::BValueMap map = prop->GetBValueMap();
+
+ if(map.empty()) return NULL;
+
+ BValueMapProperty::BValueMap::const_iterator it = map.begin();
+ BValueMapProperty::BValueMap::const_iterator end = map.end();
+
+ TiXmlElement* element = new TiXmlElement("bvaluemap");
+
+
+
+ while (it != end) {
+ TiXmlElement* child = new TiXmlElement("entry");
+ {
+ std::stringstream ss;
+ ss << it->first;
+ child->SetAttribute("key", ss.str());
+ }
+
+ {
+ std::stringstream ss;
+ for(unsigned int i = 0 ; i < it->second.size(); i++)
+ {
+
+ ss << it->second[i] << ",";
+ }
+ child->SetAttribute("value", ss.str());
+ }
+ element->InsertEndChild(*child);
+ ++it;
+ }
+
+ return element;
+ }
+ else return NULL;
+ }
+
+
+ virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
+ {
+ if (!element) return NULL;
+
+ BValueMapProperty::BValueMap map;
+
+ TiXmlElement* entry = element->FirstChildElement( "entry" )->ToElement();
+ while(entry != NULL){
+
+ std::string key, value;
+ entry->QueryStringAttribute("key",&key);
+ entry->QueryStringAttribute("value",&value);
+
+ std::vector<unsigned int> indices = split(value.c_str(), ',');
+
+ map[std::atoi(key.c_str())] = indices;
+ entry = entry->NextSiblingElement( "entry" );
+ }
+
+ return BValueMapProperty::New(map).GetPointer();
+ }
+
+protected:
+
+ BValueMapPropertySerializer(){}
+ virtual ~BValueMapPropertySerializer() {}
+};
+
+} // namespace
+
+// important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
+MITK_REGISTER_SERIALIZER(BValueMapPropertySerializer)
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp
new file mode 100644
index 0000000000..b1b0af9b03
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp
@@ -0,0 +1,387 @@
+/*===================================================================
+
+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 "mitkDiffusionPropertyHelper.h"
+#include <mitkITKImageImport.h>
+#include <mitkImageCast.h>
+#include <itkImageRegionIterator.h>
+#include <mitkProperties.h>
+
+const std::string mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME = "meta.GradientDirections";
+const std::string mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME = "meta.OriginalGradientDirections";
+const std::string mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME = "meta.MeasurementFrame";
+const std::string mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME = "meta.ReferenceBValue";
+const std::string mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME = "BValueMap";
+
+mitk::DiffusionPropertyHelper::DiffusionPropertyHelper()
+{
+}
+
+mitk::DiffusionPropertyHelper::DiffusionPropertyHelper( mitk::Image* inputImage)
+ : m_Image( inputImage )
+{
+ // Update props
+}
+
+mitk::DiffusionPropertyHelper::~DiffusionPropertyHelper()
+{
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
+ mitk::DiffusionPropertyHelper::CalcAveragedDirectionSet(double precision, GradientDirectionsContainerType::Pointer directions)
+{
+ // save old and construct new direction container
+ GradientDirectionsContainerType::Pointer newDirections = GradientDirectionsContainerType::New();
+
+ // fill new direction container
+ for(GradientDirectionsContainerType::ConstIterator gdcitOld = directions->Begin();
+ gdcitOld != directions->End(); ++gdcitOld)
+ {
+ // already exists?
+ bool found = false;
+ for(GradientDirectionsContainerType::ConstIterator gdcitNew = newDirections->Begin();
+ gdcitNew != newDirections->End(); ++gdcitNew)
+ {
+ if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
+ {
+ found = true;
+ break;
+ }
+ }
+
+ // if not found, add it to new container
+ if(!found)
+ {
+ newDirections->push_back(gdcitOld.Value());
+ }
+ }
+
+ return newDirections;
+}
+
+void mitk::DiffusionPropertyHelper::AverageRedundantGradients(double precision)
+{
+
+ mitk::GradientDirectionsProperty* DirectionsProperty = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() );
+ GradientDirectionsContainerType::Pointer oldDirs = DirectionsProperty->GetGradientDirectionsContainer();
+
+ GradientDirectionsContainerType::Pointer newDirs =
+ CalcAveragedDirectionSet(precision, oldDirs);
+
+ // if sizes equal, we do not need to do anything in this function
+ if(oldDirs->size() == newDirs->size())
+ return;
+
+ // new image
+ ImageType::Pointer oldImage = ImageType::New();
+ mitk::CastToItkImage( m_Image, oldImage);
+ ImageType::Pointer newITKImage = ImageType::New();
+ newITKImage->SetSpacing( oldImage->GetSpacing() ); // Set the image spacing
+ newITKImage->SetOrigin( oldImage->GetOrigin() ); // Set the image origin
+ newITKImage->SetDirection( oldImage->GetDirection() ); // Set the image direction
+ newITKImage->SetLargestPossibleRegion( oldImage->GetLargestPossibleRegion() );
+ newITKImage->SetVectorLength( newDirs->size() );
+ newITKImage->SetBufferedRegion( oldImage->GetLargestPossibleRegion() );
+ newITKImage->Allocate();
+
+ // average image data that corresponds to identical directions
+ itk::ImageRegionIterator< ImageType > newIt(newITKImage, newITKImage->GetLargestPossibleRegion());
+ newIt.GoToBegin();
+ itk::ImageRegionIterator< ImageType > oldIt(oldImage, oldImage->GetLargestPossibleRegion());
+ oldIt.GoToBegin();
+
+ // initial new value of voxel
+ ImageType::PixelType newVec;
+ newVec.SetSize(newDirs->size());
+ newVec.AllocateElements(newDirs->size());
+
+ // find which gradients should be averaged
+ GradientDirectionsContainerType::Pointer oldDirections = oldDirs;
+ std::vector<std::vector<int> > dirIndices;
+ for(GradientDirectionsContainerType::ConstIterator gdcitNew = newDirs->Begin();
+ gdcitNew != newDirs->End(); ++gdcitNew)
+ {
+ dirIndices.push_back(std::vector<int>(0));
+ for(GradientDirectionsContainerType::ConstIterator gdcitOld = oldDirs->Begin();
+ gdcitOld != oldDirections->End(); ++gdcitOld)
+ {
+ if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
+ {
+ //MITK_INFO << gdcitNew.Value() << " " << gdcitOld.Value();
+ dirIndices[gdcitNew.Index()].push_back(gdcitOld.Index());
+ }
+ }
+ }
+
+ //int ind1 = -1;
+ while(!newIt.IsAtEnd())
+ {
+
+ // progress
+ //typename ImageType::IndexType ind = newIt.GetIndex();
+ //ind1 = ind.m_Index[2];
+
+ // init new vector with zeros
+ newVec.Fill(0.0);
+
+ // the old voxel value with duplicates
+ ImageType::PixelType oldVec = oldIt.Get();
+
+ for(unsigned int i=0; i<dirIndices.size(); i++)
+ {
+ // do the averaging
+ const unsigned int numavg = dirIndices[i].size();
+ unsigned int sum = 0;
+ for(unsigned int j=0; j<numavg; j++)
+ {
+ //MITK_INFO << newVec[i] << " << " << oldVec[dirIndices[i].at(j)];
+ sum += oldVec[dirIndices[i].at(j)];
+ }
+ if(numavg == 0)
+ {
+ MITK_ERROR << "VectorImage: Error on averaging. Possibly due to corrupted data";
+ return;
+ }
+ newVec[i] = sum / numavg;
+ }
+
+ newIt.Set(newVec);
+
+ ++newIt;
+ ++oldIt;
+ }
+
+ mitk::GrabItkImageMemory( newITKImage, m_Image );
+
+ m_Image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) );
+ m_Image->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) );
+ ApplyMeasurementFrame();
+ UpdateBValueMap();
+ std::cout << std::endl;
+}
+
+void mitk::DiffusionPropertyHelper::ApplyMeasurementFrame()
+{
+
+ if( m_Image->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).IsNull() )
+ {
+ return;
+ }
+
+ GradientDirectionsContainerType::Pointer originalDirections = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer())->GetGradientDirectionsContainer();
+
+ MeasurementFrameType measurementFrame = static_cast<mitk::MeasurementFrameProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
+
+ GradientDirectionsContainerType::Pointer directions = GradientDirectionsContainerType::New();
+
+ if( originalDirections.IsNull() || ( originalDirections->size() == 0 ) )
+ {
+ // original direction container was not set
+ return;
+ }
+
+ GradientDirectionsContainerType::Pointer direction = GradientDirectionsContainerType::New();
+ int c = 0;
+ for(GradientDirectionsContainerType::ConstIterator gdcit = originalDirections->Begin();
+ gdcit != originalDirections->End(); ++gdcit)
+ {
+ vnl_vector<double> vec = gdcit.Value();
+ vec = vec.pre_multiply(measurementFrame);
+ directions->InsertElement(c, vec);
+ c++;
+ }
+
+ m_Image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( directions ) );
+}
+
+void mitk::DiffusionPropertyHelper::UpdateBValueMap()
+{
+ BValueMapType b_ValueMap;
+
+ if(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).IsNull())
+ {
+ }
+ else
+ {
+ b_ValueMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+ }
+
+ if(!b_ValueMap.empty())
+ {
+ b_ValueMap.clear();
+ }
+
+ if( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).IsNotNull() )
+ {
+ GradientDirectionsContainerType::Pointer directions = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+ GradientDirectionsContainerType::ConstIterator gdcit;
+ for( gdcit = directions->Begin(); gdcit != directions->End(); ++gdcit)
+ {
+ b_ValueMap[GetB_Value(gdcit.Index())].push_back(gdcit.Index());
+ }
+ }
+
+ m_Image->SetProperty( mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(), mitk::BValueMapProperty::New( b_ValueMap ) );
+}
+
+bool mitk::DiffusionPropertyHelper::AreAlike(GradientDirectionType g1,
+ GradientDirectionType g2,
+ double precision)
+{
+ GradientDirectionType diff = g1 - g2;
+ GradientDirectionType diff2 = g1 + g2;
+ return diff.two_norm() < precision || diff2.two_norm() < precision;
+}
+
+float mitk::DiffusionPropertyHelper::GetB_Value(unsigned int i)
+{
+ GradientDirectionsContainerType::Pointer directions = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+ float b_value = static_cast<mitk::FloatProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+
+ if(i > directions->Size()-1)
+ return -1;
+
+ if(directions->ElementAt(i).one_norm() <= 0.0)
+ {
+ return 0;
+ }
+ else
+ {
+ double twonorm = directions->ElementAt(i).two_norm();
+ double bval = b_value*twonorm*twonorm;
+
+ if (bval<0)
+ bval = ceil(bval - 0.5);
+ else
+ bval = floor(bval + 0.5);
+
+ return bval;
+ }
+}
+
+void mitk::DiffusionPropertyHelper::InitializeImage()
+{
+ this->ApplyMeasurementFrame();
+ this->UpdateBValueMap();
+
+ // initialize missing properties
+}
+
+
+bool mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(const mitk::Image * image)
+{
+ bool isDiffusionWeightedImage( true );
+
+ if( image == NULL )
+ {
+ isDiffusionWeightedImage = false;
+ }
+
+ if( isDiffusionWeightedImage )
+ {
+ mitk::FloatProperty::Pointer referenceBValue = dynamic_cast<mitk::FloatProperty *>(image->GetProperty(REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer());
+
+ if( referenceBValue.IsNull() )
+ {
+ isDiffusionWeightedImage = false;
+ }
+
+ }
+
+ unsigned int gradientDirections( 0 );
+ if( isDiffusionWeightedImage )
+ {
+ mitk::GradientDirectionsProperty::Pointer gradientDirectionsProperty = dynamic_cast<mitk::GradientDirectionsProperty *>(image->GetProperty(GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer());
+
+ if( gradientDirectionsProperty.IsNull() )
+ {
+ isDiffusionWeightedImage = false;
+ }
+ else
+ {
+ gradientDirections = gradientDirectionsProperty->GetGradientDirectionsContainer()->size();
+ }
+ }
+
+ if( isDiffusionWeightedImage )
+ {
+ unsigned int components = image->GetPixelType().GetNumberOfComponents();
+
+ if( components != gradientDirections )
+ {
+ isDiffusionWeightedImage = false;
+ }
+ }
+
+ return isDiffusionWeightedImage;
+}
+
+const mitk::DiffusionPropertyHelper::BValueMapType & mitk::DiffusionPropertyHelper::GetBValueMap(const mitk::Image *image)
+{
+ return dynamic_cast<mitk::BValueMapProperty *>(image->GetProperty(BVALUEMAPPROPERTYNAME.c_str()).GetPointer())->GetBValueMap();
+}
+
+float mitk::DiffusionPropertyHelper::GetReferenceBValue(const mitk::Image *image)
+{
+ return dynamic_cast<mitk::FloatProperty *>(image->GetProperty(REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer())->GetValue();
+}
+
+const mitk::DiffusionPropertyHelper::MeasurementFrameType & mitk::DiffusionPropertyHelper::GetMeasurementFrame(const mitk::Image *image)
+{
+ return dynamic_cast<mitk::MeasurementFrameProperty *>(image->GetProperty(MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer())->GetMeasurementFrame();
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(const mitk::Image *image)
+{
+ return dynamic_cast<mitk::GradientDirectionsProperty *>(image->GetProperty(ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer())->GetGradientDirectionsContainer();
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetGradientContainer(const mitk::Image *image)
+{
+ return dynamic_cast<mitk::GradientDirectionsProperty *>(image->GetProperty(GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer())->GetGradientDirectionsContainer();
+}
+
+bool mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage() const
+{
+ return IsDiffusionWeightedImage(m_Image);
+}
+
+const mitk::DiffusionPropertyHelper::BValueMapType &mitk::DiffusionPropertyHelper::GetBValueMap() const
+{
+ return GetBValueMap(m_Image);
+}
+
+float mitk::DiffusionPropertyHelper::GetReferenceBValue() const
+{
+ return GetReferenceBValue(m_Image);
+}
+
+const mitk::DiffusionPropertyHelper::MeasurementFrameType & mitk::DiffusionPropertyHelper::GetMeasurementFrame() const
+{
+ return GetMeasurementFrame(m_Image);
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetOriginalGradientContainer() const
+{
+ return GetOriginalGradientContainer(m_Image);
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetGradientContainer() const
+{
+ return GetGradientContainer(m_Image);
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.h
new file mode 100644
index 0000000000..0e599e2950
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.h
@@ -0,0 +1,128 @@
+/*===================================================================
+
+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 MITKDIFFUSIONPROPERTYHELPER_H
+#define MITKDIFFUSIONPROPERTYHELPER_H
+
+#include <MitkDiffusionCoreExports.h>
+
+#include <mitkImage.h>
+#include <mitkBValueMapProperty.h>
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkMeasurementFrameProperty.h>
+
+namespace mitk
+{
+ /** \brief Helper class for mitk::Images containing diffusion weighted data
+ *
+ * This class takes a pointer to a mitk::Image containing diffusion weighted information and provides
+ * functions to manipulate the diffusion meta-data. Will log an error if required information is
+ * missing.
+ */
+
+ class MitkDiffusionCore_EXPORT DiffusionPropertyHelper
+ {
+ public:
+
+ typedef short DiffusionPixelType;
+
+ typedef mitk::BValueMapProperty::BValueMap BValueMapType;
+ typedef GradientDirectionsProperty::GradientDirectionType GradientDirectionType;
+ typedef GradientDirectionsProperty::GradientDirectionsContainerType GradientDirectionsContainerType;
+ typedef mitk::MeasurementFrameProperty::MeasurementFrameType MeasurementFrameType;
+ typedef itk::VectorImage< DiffusionPixelType, 3> ImageType;
+
+ static const std::string GRADIENTCONTAINERPROPERTYNAME;
+ static const std::string ORIGINALGRADIENTCONTAINERPROPERTYNAME;
+ static const std::string MEASUREMENTFRAMEPROPERTYNAME;
+ static const std::string REFERENCEBVALUEPROPERTYNAME;
+ static const std::string BVALUEMAPPROPERTYNAME;
+
+ /// Public constructor, takes a mitk::Image pointer as argument
+ DiffusionPropertyHelper( mitk::Image* inputImage );
+ ~DiffusionPropertyHelper();
+
+ /** \brief Decide whether a provided image is a valid diffusion weighted image
+ *
+ * An image will be considered a valid diffusion weighted image if the following are true
+ * - It has a reference b value
+ * - It has a gradient directions property
+ * - The number of gradients directions matches the number of components of the image
+ *
+ * This does not guarantee that the data is sensible or accurate, it just verfies that it
+ * meets the formal requirements to possibly be a valid diffusion weighted image.
+ */
+ static bool IsDiffusionWeightedImage(const mitk::Image *);
+
+ /// Convenience method to get the BValueMap
+ static const BValueMapType & GetBValueMap(const mitk::Image *);
+ /// Convenience method to get the BValue
+ static float GetReferenceBValue(const mitk::Image *);
+ /// Convenience method to get the measurement frame
+ static const MeasurementFrameType & GetMeasurementFrame(const mitk::Image *);
+ /// Convenience method to get the original gradient directions
+ static GradientDirectionsContainerType::Pointer GetOriginalGradientContainer(const mitk::Image *);
+ /// Convenience method to get the gradient directions
+ static GradientDirectionsContainerType::Pointer GetGradientContainer(const mitk::Image *);
+
+ const BValueMapType & GetBValueMap() const;
+ float GetReferenceBValue() const;
+ const MeasurementFrameType & GetMeasurementFrame() const;
+ GradientDirectionsContainerType::Pointer GetOriginalGradientContainer() const;
+ GradientDirectionsContainerType::Pointer GetGradientContainer() const;
+
+ bool IsDiffusionWeightedImage() const;
+
+ void AverageRedundantGradients(double precision);
+
+ /** \brief Make certain the owned image is up to date with all necessary properties
+ *
+ * This function will generate the B Value map and copy all properties to the owned image.
+ */
+ void InitializeImage();
+
+ GradientDirectionsContainerType::Pointer CalcAveragedDirectionSet(double precision, GradientDirectionsContainerType::Pointer directions);
+
+ protected:
+
+ DiffusionPropertyHelper();
+
+ /**
+ * \brief Apply the previouse set MeasurementFrame to all gradients in the GradientsDirectionContainer (m_Directions)
+ *
+ * \warning first set the MeasurementFrame
+ */
+ void ApplyMeasurementFrame();
+
+ /**
+ * \brief Update the BValueMap (m_B_ValueMap) using the current gradient directions (m_Directions)
+ *
+ * \warning Have to be called after each manipulation on the GradientDirectionContainer
+ * !especially after manipulation of the m_Directions (GetDirections()) container via pointer access!
+ */
+ void UpdateBValueMap();
+
+ /// Determines whether gradients can be considered to be equal
+ bool AreAlike(GradientDirectionType g1, GradientDirectionType g2, double precision);
+
+ /// Get the b value belonging to an index
+ float GetB_Value(unsigned int i);
+
+ mitk::Image* m_Image;
+
+ };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.cpp
new file mode 100644
index 0000000000..1ef0d3e495
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.cpp
@@ -0,0 +1,83 @@
+/*===================================================================
+
+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 "mitkGradientDirectionsProperty.h"
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty()
+{
+ m_GradientDirectionsContainer = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+}
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty(const GradientDirectionsProperty& other)
+ : mitk::BaseProperty(other)
+{
+ m_GradientDirectionsContainer = other.GetGradientDirectionsContainer();
+}
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty(const GradientDirectionsContainerType::Pointer gradientDirectionsContainer)
+{
+ m_GradientDirectionsContainer = gradientDirectionsContainer;
+}
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty(const AlternativeGradientDirectionsContainerType gradientDirectionsContainer)
+{
+ m_GradientDirectionsContainer = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+ for(unsigned int index(0); index < gradientDirectionsContainer.size(); index++)
+ {
+ GradientDirectionType newDirection = gradientDirectionsContainer.at(index).GetVnlVector();
+ m_GradientDirectionsContainer->InsertElement( index, newDirection);
+ }
+}
+
+mitk::GradientDirectionsProperty::~GradientDirectionsProperty()
+{
+}
+
+const mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer mitk::GradientDirectionsProperty::GetGradientDirectionsContainer() const
+{
+ return m_GradientDirectionsContainer;
+}
+
+bool mitk::GradientDirectionsProperty::IsEqual(const BaseProperty& property) const
+{
+
+ GradientDirectionsContainerType::Pointer lhs = this->m_GradientDirectionsContainer;
+ GradientDirectionsContainerType::Pointer rhs = static_cast<const Self&>(property).m_GradientDirectionsContainer;
+
+ if(lhs->Size() != rhs->Size()) return false;
+
+ GradientDirectionsContainerType::Iterator lhsit = lhs->Begin();
+ GradientDirectionsContainerType::Iterator rhsit = rhs->Begin();
+
+ bool equal = true;
+ for(unsigned int i = 0 ; i < lhs->Size(); i++, ++lhsit, ++rhsit)
+ equal |= lhsit.Value() == rhsit.Value();
+
+ return equal;
+}
+
+bool mitk::GradientDirectionsProperty::Assign(const BaseProperty& property)
+{
+ this->m_GradientDirectionsContainer = static_cast<const Self&>(property).m_GradientDirectionsContainer;
+ return true;
+}
+
+itk::LightObject::Pointer mitk::GradientDirectionsProperty::InternalClone() const
+{
+ itk::LightObject::Pointer result(new Self(*this));
+ result->UnRegister();
+ return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.h
new file mode 100644
index 0000000000..4fb765388a
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.h
@@ -0,0 +1,68 @@
+/*===================================================================
+
+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 MITKGRADIENTDIRECTIONSPROPERTY_H
+#define MITKGRADIENTDIRECTIONSPROPERTY_H
+
+#include "mitkBaseProperty.h"
+#include <vnl/vnl_vector_fixed.h>
+#include <itkVectorContainer.h>
+#include <itkVector.h>
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+ /** This property will store the gradients directions and the original gradient directions */
+ class MitkDiffusionCore_EXPORT GradientDirectionsProperty : public mitk::BaseProperty
+ {
+ public:
+ typedef unsigned int IndexType;
+ typedef vnl_vector_fixed< double, 3 > ValueType;
+ typedef ValueType GradientDirectionType;
+ typedef itk::VectorContainer< IndexType, GradientDirectionType > GradientDirectionsContainerType;
+ typedef std::vector< itk::Vector<double,3> > AlternativeGradientDirectionsContainerType;
+
+ mitkClassMacro(GradientDirectionsProperty, BaseProperty)
+
+ itkFactorylessNewMacro(Self)
+ itkCloneMacro(Self)
+
+ mitkNewMacro1Param(GradientDirectionsProperty, const GradientDirectionsProperty&);
+ mitkNewMacro1Param(GradientDirectionsProperty, const GradientDirectionsContainerType::Pointer);
+ mitkNewMacro1Param(GradientDirectionsProperty, const AlternativeGradientDirectionsContainerType );
+
+ const GradientDirectionsContainerType::Pointer GetGradientDirectionsContainer() const;
+
+ protected:
+
+ GradientDirectionsProperty();
+ ~GradientDirectionsProperty();
+
+ GradientDirectionsProperty(const GradientDirectionsProperty& other);
+ GradientDirectionsProperty(const GradientDirectionsContainerType::Pointer gradientDirectionsContainer);
+ GradientDirectionsProperty(const AlternativeGradientDirectionsContainerType gradientDirectionsContainer);
+
+ virtual bool IsEqual(const BaseProperty& property) const;
+ virtual bool Assign(const BaseProperty & property);
+
+ GradientDirectionsContainerType::Pointer m_GradientDirectionsContainer;
+
+ virtual itk::LightObject::Pointer InternalClone() const;
+ };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp
new file mode 100644
index 0000000000..4c540ff733
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp
@@ -0,0 +1,106 @@
+/*===================================================================
+
+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 mitkGradientDirectionPropertySerializer_h_included
+#define mitkGradientDirectionPropertySerializer_h_included
+
+#include "mitkBasePropertySerializer.h"
+
+#include "mitkGradientDirectionsProperty.h"
+
+#include "MitkDiffusionCoreExports.h"
+
+namespace mitk
+{
+
+class MitkDiffusionCore_EXPORT GradientDirectionsPropertySerializer : public BasePropertySerializer
+{
+ public:
+
+ mitkClassMacro( GradientDirectionsPropertySerializer, BasePropertySerializer )
+ itkFactorylessNewMacro(Self)
+ itkCloneMacro(Self)
+
+ virtual TiXmlElement* Serialize()
+ {
+ if (const GradientDirectionsProperty* prop = dynamic_cast<const GradientDirectionsProperty*>(m_Property.GetPointer()))
+ {
+
+ typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType GradientDirectionsContainerType;
+ GradientDirectionsContainerType::Pointer gdc = prop->GetGradientDirectionsContainer().GetPointer();
+
+ if(gdc.IsNull() || gdc->Size() == 0) return NULL;
+
+
+ GradientDirectionsContainerType::Iterator it = gdc->Begin();
+ GradientDirectionsContainerType::Iterator end = gdc->End();
+
+ TiXmlElement* element = new TiXmlElement("gradientdirections");
+
+ while (it != end) {
+ TiXmlElement* child = new TiXmlElement("entry");
+ std::stringstream ss;
+ ss << it.Value();
+ child->SetAttribute("value", ss.str());
+ element->InsertEndChild(*child);
+
+ ++it;
+ }
+
+ return element;
+ }
+ else return NULL;
+ }
+
+ virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
+ {
+ if (!element) return NULL;
+
+ mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer gdc;
+ gdc = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+
+ TiXmlElement* entry = element->FirstChildElement( "entry" )->ToElement();
+ while(entry != NULL){
+
+ std::stringstream ss;
+ std::string value;
+
+ entry->QueryStringAttribute("value",&value);
+ ss << value;
+
+ vnl_vector_fixed<double, 3> vector;
+ vector.read_ascii(ss);
+
+ gdc->push_back(vector);
+
+ entry = entry->NextSiblingElement( "entry" );
+ }
+
+ return GradientDirectionsProperty::New(gdc).GetPointer();
+ }
+
+ protected:
+
+ GradientDirectionsPropertySerializer() {}
+ virtual ~GradientDirectionsPropertySerializer() {}
+};
+
+} // namespace
+
+// important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
+MITK_REGISTER_SERIALIZER(GradientDirectionsPropertySerializer)
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.cpp
new file mode 100644
index 0000000000..dea5153be0
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.cpp
@@ -0,0 +1,65 @@
+/*===================================================================
+
+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 "mitkMeasurementFrameProperty.h"
+
+mitk::MeasurementFrameProperty::MeasurementFrameProperty()
+ : m_MeasurementFrame()
+{
+}
+
+mitk::MeasurementFrameProperty::MeasurementFrameProperty(const MeasurementFrameProperty& other)
+ : mitk::BaseProperty(other)
+{
+ m_MeasurementFrame = other.GetMeasurementFrame();
+}
+
+mitk::MeasurementFrameProperty::MeasurementFrameProperty(const MeasurementFrameType& measurementFrame)
+{
+ m_MeasurementFrame = measurementFrame;
+}
+
+mitk::MeasurementFrameProperty::~MeasurementFrameProperty()
+{
+}
+
+const mitk::MeasurementFrameProperty::MeasurementFrameType & mitk::MeasurementFrameProperty::GetMeasurementFrame() const
+{
+ return m_MeasurementFrame;
+}
+
+void mitk::MeasurementFrameProperty::SetMeasurementFrame(const MeasurementFrameType & frame)
+{
+ m_MeasurementFrame = frame;
+}
+
+bool mitk::MeasurementFrameProperty::IsEqual(const BaseProperty& property) const
+{
+ return this->m_MeasurementFrame == static_cast<const Self&>(property).m_MeasurementFrame;
+}
+
+bool mitk::MeasurementFrameProperty::Assign(const BaseProperty& property)
+{
+ this->m_MeasurementFrame = static_cast<const Self&>(property).m_MeasurementFrame;
+ return true;
+}
+
+itk::LightObject::Pointer mitk::MeasurementFrameProperty::InternalClone() const
+{
+ itk::LightObject::Pointer result(new Self(*this));
+ result->UnRegister();
+ return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.h
new file mode 100644
index 0000000000..c892bba7a3
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.h
@@ -0,0 +1,60 @@
+/*===================================================================
+
+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 MITKMEASUREMENTFRAMEPROPERTY_H
+#define MITKMEASUREMENTFRAMEPROPERTY_H
+
+#include "mitkBaseProperty.h"
+#include <vnl/vnl_matrix_fixed.h>
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+ /** This property will store the measurement frame */
+ class MitkDiffusionCore_EXPORT MeasurementFrameProperty : public mitk::BaseProperty
+ {
+ public:
+ typedef vnl_matrix_fixed< double, 3, 3 > MeasurementFrameType;
+ mitkClassMacro(MeasurementFrameProperty, BaseProperty)
+
+ itkFactorylessNewMacro(Self)
+ itkCloneMacro(Self)
+
+ mitkNewMacro1Param(MeasurementFrameProperty, const MeasurementFrameProperty&);
+ mitkNewMacro1Param(MeasurementFrameProperty, const MeasurementFrameType&);
+
+ const MeasurementFrameType &GetMeasurementFrame() const;
+ void SetMeasurementFrame(const MeasurementFrameType & frame);
+
+ protected:
+
+ MeasurementFrameProperty();
+ ~MeasurementFrameProperty();
+
+ MeasurementFrameProperty(const MeasurementFrameProperty& other);
+ MeasurementFrameProperty(const MeasurementFrameType& measurementFrame);
+
+ virtual bool IsEqual(const BaseProperty& property) const;
+ virtual bool Assign(const BaseProperty & property);
+
+ MeasurementFrameType m_MeasurementFrame;
+
+ virtual itk::LightObject::Pointer InternalClone() const;
+ };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp
new file mode 100644
index 0000000000..60c17f8f59
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp
@@ -0,0 +1,89 @@
+/*===================================================================
+
+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 mitkMeasurementFramePropertySerializer_h_included
+#define mitkMeasurementFramePropertySerializer_h_included
+
+#include "mitkBasePropertySerializer.h"
+
+#include "mitkMeasurementFrameProperty.h"
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+class MitkDiffusionCore_EXPORT MeasurementFramePropertySerializer : public BasePropertySerializer
+{
+ public:
+
+ mitkClassMacro( MeasurementFramePropertySerializer, BasePropertySerializer )
+ itkFactorylessNewMacro(Self)
+ itkCloneMacro(Self)
+
+ virtual TiXmlElement* Serialize()
+ {
+ if (const MeasurementFrameProperty* prop = dynamic_cast<const MeasurementFrameProperty*>(m_Property.GetPointer()))
+ {
+
+ typedef mitk::MeasurementFrameProperty::MeasurementFrameType MeasurementFrameType;
+ const MeasurementFrameType & mft = prop->GetMeasurementFrame();
+
+ if(mft.is_zero()) return NULL;
+
+ TiXmlElement* element = new TiXmlElement("measurementframe");
+
+ TiXmlElement* child = new TiXmlElement("entry");
+ std::stringstream ss;
+ ss << mft;
+ child->SetAttribute("value", ss.str());
+ element->InsertEndChild(*child);
+
+ return element;
+ }
+ else return NULL;
+ }
+
+ virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
+ {
+ if (!element) return NULL;
+
+ TiXmlElement* entry = element->FirstChildElement( "entry" )->ToElement();
+
+ std::stringstream ss;
+ std::string value;
+
+ entry->QueryStringAttribute("value",&value);
+ ss << value;
+
+ MeasurementFrameProperty::MeasurementFrameType matrix;
+ matrix.read_ascii(ss);
+
+ return MeasurementFrameProperty::New(matrix).GetPointer();
+ }
+
+ protected:
+
+ MeasurementFramePropertySerializer() {}
+ virtual ~MeasurementFramePropertySerializer() {}
+};
+
+} // namespace
+
+// important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
+MITK_REGISTER_SERIALIZER(MeasurementFramePropertySerializer)
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.cpp
new file mode 100644
index 0000000000..7afb4abc04
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.cpp
@@ -0,0 +1,39 @@
+/*===================================================================
+
+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 "mitkNodePredicateIsDWI.h"
+#include "mitkDataNode.h"
+#include <mitkDiffusionPropertyHelper.h>
+
+mitk::NodePredicateIsDWI::NodePredicateIsDWI()
+: NodePredicateBase()
+{
+}
+
+mitk::NodePredicateIsDWI::~NodePredicateIsDWI()
+{
+}
+
+
+bool mitk::NodePredicateIsDWI::CheckNode(const mitk::DataNode* node) const
+{
+ if (node == NULL)
+ throw std::invalid_argument("NodePredicateIsDWI: invalid node");
+
+ mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
+
+ return mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( image );
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.h
new file mode 100644
index 0000000000..7ca6f29d70
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.h
@@ -0,0 +1,56 @@
+/*===================================================================
+
+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 MITKNODEPREDICATEISDWI_H_HEADER_INCLUDED_
+#define MITKNODEPREDICATEISDWI_H_HEADER_INCLUDED_
+
+#include <MitkDiffusionCoreExports.h>
+
+#include "mitkNodePredicateBase.h"
+#include "mitkBaseProperty.h"
+#include "mitkBaseData.h"
+
+namespace mitk {
+
+ /**Documentation
+ * @brief Predicate that evaluates whether a given node contains a diffusion weighted image
+ * @ingroup DataStorage
+ */
+
+ class MitkDiffusionCore_EXPORT NodePredicateIsDWI : public NodePredicateBase
+ {
+ public:
+ mitkClassMacro(NodePredicateIsDWI, NodePredicateBase);
+ itkFactorylessNewMacro(NodePredicateIsDWI)
+
+ //##Documentation
+ //## @brief Standard Destructor
+ virtual ~NodePredicateIsDWI();
+
+ //##Documentation
+ //## @brief Checks, if the node's data contains a property that is equal to m_ValidProperty
+ virtual bool CheckNode(const mitk::DataNode* node) const;
+
+ protected:
+ //##Documentation
+ //## @brief Constructor to check for a named property
+ NodePredicateIsDWI();
+ };
+
+} // namespace mitk
+
+#endif /* MITKNODEPREDICATEISDWI_H_HEADER_INCLUDED_ */
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.cpp b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.cpp
deleted file mode 100644
index dd8b9888ce..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*===================================================================
-
-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 DiffusionImageMapper_txx_HEADER_INCLUDED
-#define DiffusionImageMapper_txx_HEADER_INCLUDED
-
-#include "mitkProperties.h"
-#include "mitkDiffusionImage.h"
-
-template<class TPixelType>
-mitk::DiffusionImageMapper<TPixelType>::DiffusionImageMapper()
-{
-
-}
-
-template<class TPixelType>
-mitk::DiffusionImageMapper<TPixelType>::~DiffusionImageMapper()
-{
-
-}
-
-template<class TPixelType>
-void
-mitk::DiffusionImageMapper<TPixelType>::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
-{
- int displayIndex(0);
-
-
- this->GetDataNode()->GetIntProperty( "DisplayChannel", displayIndex, renderer );
- mitk::Image *input = const_cast< mitk::Image* >(
- this->GetInput()
- );
- mitk::DiffusionImage<TPixelType> *input2 = dynamic_cast< mitk::DiffusionImage<TPixelType>* >(
- input
- );
-
- input2->SetDisplayIndexForRendering(displayIndex);
- Superclass::GenerateDataForRenderer(renderer);
-}
-
-template<class TPixelType>
-void mitk::DiffusionImageMapper<TPixelType>::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
-{
- node->AddProperty( "DisplayChannel", mitk::IntProperty::New( 0 ), renderer, overwrite );
- Superclass::SetDefaultProperties(node, renderer, overwrite);
-}
-
-#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.h b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.h
deleted file mode 100644
index fa53102f1d..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*===================================================================
-
-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 DiffusionImageMapper_H_HEADER_INCLUDED
-#define DiffusionImageMapper_H_HEADER_INCLUDED
-
-#include "mitkImageVtkMapper2D.h"
-
-namespace mitk {
-
- //##Documentation
- //## @brief Mapper for raw diffusion weighted images
- //## @ingroup Mapper
- template<class TPixelType>
- class DiffusionImageMapper : public ImageVtkMapper2D
- {
- public:
-
- mitkClassMacro(DiffusionImageMapper,ImageVtkMapper2D);
- itkFactorylessNewMacro(Self)
- itkCloneMacro(Self)
-
- void GenerateDataForRenderer( mitk::BaseRenderer *renderer );
-
- static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
-
- protected:
-
- DiffusionImageMapper();
- virtual ~DiffusionImageMapper();
-
- };
-
-} // namespace mitk
-
-#include "mitkDiffusionImageMapper.cpp"
-
-
-#endif /* COMPOSITEMAPPER_H_HEADER_INCLUDED */
-
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake b/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake
index 4a2a9d22b0..9e87b8b605 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake
@@ -1,16 +1,15 @@
set(MODULE_TESTS
- mitkDiffusionImageEqualTest.cpp
mitkNonLocalMeansDenoisingTest.cpp
- mitkDiffusionImageEqualTest.cpp
+ mitkDiffusionPropertySerializerTest.cpp
)
set(MODULE_CUSTOM_TESTS
mitkPyramidImageRegistrationMethodTest.cpp
mitkDWHeadMotionCorrectionTest.cpp
mitkImageReconstructionTest.cpp
mitkConvertDWITypeTest.cpp
mitkExtractSingleShellTest.cpp
mitkNonLocalMeansDenoisingTest.cpp
mitkDiffusionDICOMFileReaderTest.cpp
)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp
index c157efef62..101143f9d9 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp
@@ -1,109 +1,108 @@
/*===================================================================
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 "mitkTestingMacros.h"
#include "itkVectorImage.h"
#include "mitkBaseData.h"
#include "mitkBaseDataIOFactory.h"
#include "mitkImageWriter.h"
#include "itkImageFileWriter.h"
#include "itkB0ImageExtractionToSeparateImageFilter.h"
-#include "mitkDiffusionImage.h"
#include "mitkDiffusionCoreObjectFactory.h"
/** Documentation
* Test for factory registration
*/
int mitkB0ExtractionToSeparateImagesFilterTest(int argc , char* argv[])
{
// always start with this!
MITK_TEST_BEGIN("mitkB0ExtractionToSeparateImagesFilterTest");
MITK_TEST_CONDITION_REQUIRED(argc > 2, "Test image is specified. ");
typedef short DiffusionPixelType;
- typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
+ typedef mitk::Image DiffusionImageType;
typedef mitk::NrrdDiffusionImageReader< DiffusionPixelType> DiffusionNrrdReaderType;
RegisterDiffusionImagingObjectFactory();
std::string inputFileName( argv[1] );
std::vector<mitk::BaseData::Pointer> inputBaseDataVector = mitk::BaseDataIO::LoadBaseDataFromFile( inputFileName, "","",false);
MITK_TEST_CONDITION_REQUIRED( inputBaseDataVector.size() > 0, "BaseDataIO returned non-empty vector.");
mitk::BaseData::Pointer baseData = inputBaseDataVector.at(0);
MITK_TEST_CONDITION_REQUIRED( baseData.IsNotNull(), "BaseData is not null")
DiffusionImageType* vols = dynamic_cast< DiffusionImageType* >(baseData.GetPointer());
MITK_TEST_CONDITION_REQUIRED( vols != NULL, "Casting basedata to diffusion image successfull." );
// filter
typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
typename FilterType::Pointer filter = FilterType::New();
MITK_TEST_CONDITION_REQUIRED(filter.IsNotNull(), "Filter instance created. ");
filter->SetInput(vols->GetVectorImage());
filter->SetDirections(vols->GetDirections());
filter->Update();
// output
mitk::Image::Pointer mitkImage = mitk::Image::New();
MITK_TEST_CONDITION_REQUIRED( mitkImage.IsNotNull(), "mitkImage not null." );
mitkImage->InitializeByItk( filter->GetOutput() );
MITK_TEST_CONDITION_REQUIRED( mitkImage->GetDimension()==4, "Output image is a 4D image.");
mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
typedef itk::ImageFileWriter< FilterType::OutputImageType > itkImageWriterType;
typename itkImageWriterType::Pointer itkWriter = itkImageWriterType::New();
itkWriter->SetFileName( argv[2] );
itkWriter->SetInput( filter->GetOutput() );
try
{
itkWriter->Update();
}
catch(itk::ExceptionObject &e)
{
MITK_ERROR << "Catched exception from image writer. " << e.what();
}
/*
// write output
mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
MITK_TEST_CONDITION_REQUIRED( writer.IsNotNull(), "Writer instance created. ");
writer->SetInput( mitkImage );
writer->SetExtension(".nrrd");
writer->SetFileName( "/localdata/hering/_Images/TestB0Extraction" );
writer->Update();
*/
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp
index aeae0f8536..4e6449576a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp
@@ -1,51 +1,46 @@
/*===================================================================
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 "mitkTestingMacros.h"
#include "mitkIOUtil.h"
#include "mitkDWIHeadMotionCorrectionFilter.h"
-typedef short DiffusionPixelType;
-typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
-
/**
* @brief Custom test to provide CMD-line access to the mitk::DWIHeadMotionCorrectionFilter
*
* @param argv : Input and Output image full path
*/
int mitkConvertDWITypeTest( int argc, char* argv[] )
{
MITK_TEST_BEGIN("mitkConvertDWITypeTest");
MITK_TEST_CONDITION_REQUIRED( argc > 2, "Specify input and output.");
mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( argv[1] );
- DiffusionImageType* dwimage =
- static_cast<DiffusionImageType*>( inputImage.GetPointer() );
try
{
- mitk::IOUtil::Save(dwimage, argv[2]);
+ mitk::IOUtil::Save(inputImage, argv[2]);
}
catch( const itk::ExceptionObject& e)
{
- MITK_ERROR << "Catched exception: " << e.what();
+ MITK_ERROR << "Caught exception: " << e.what();
mitkThrow() << "Failed with exception from subprocess!";
}
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp
index 7805c72b3c..e19fc61f9c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp
@@ -1,60 +1,60 @@
/*===================================================================
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 "mitkTestingMacros.h"
#include "mitkIOUtil.h"
-#include "mitkDWIHeadMotionCorrectionFilter.h"
+#include <mitkDWIHeadMotionCorrectionFilter.h>
typedef short DiffusionPixelType;
-typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
+typedef mitk::Image DiffusionImageType;
/**
* @brief Custom test to provide CMD-line access to the mitk::DWIHeadMotionCorrectionFilter
*
* @param argv : Input and Output image full path
*/
int mitkDWHeadMotionCorrectionTest( int argc, char* argv[] )
{
MITK_TEST_BEGIN("mitkDWHeadMotionCorrectionTest");
MITK_TEST_CONDITION_REQUIRED( argc > 2, "Specify input and output.");
// itk::MultiThreader::SetGlobalMaximumNumberOfThreads(1);
mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( argv[1] );
DiffusionImageType* dwimage =
static_cast<DiffusionImageType*>( inputImage.GetPointer() );
- mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>::Pointer corrfilter =
- mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>::New();
+ mitk::DWIHeadMotionCorrectionFilter::Pointer corrfilter =
+ mitk::DWIHeadMotionCorrectionFilter::New();
corrfilter->SetInput( dwimage );
corrfilter->SetAverageUnweighted(false);
corrfilter->Update();
try
{
mitk::IOUtil::SaveBaseData(corrfilter->GetOutput(), argv[2]);
}
catch( const itk::ExceptionObject& e)
{
MITK_ERROR << "Catched exception: " << e.what();
mitkThrow() << "Failed with exception from subprocess!";
}
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp
index 1b18949742..bfdd73c944 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp
@@ -1,115 +1,113 @@
/*===================================================================
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 "mitkDiffusionDICOMFileReader.h"
#include "mitkDiffusionDICOMFileReaderTestHelper.h"
#include "mitkDICOMTagBasedSorter.h"
#include "mitkDICOMSortByTag.h"
#include <mitkIOUtil.h>
#include "mitkTestingMacros.h"
using mitk::DICOMTag;
int mitkDiffusionDICOMFileReaderTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkDiffusionDICOMFileReaderTest");
mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New();
MITK_TEST_CONDITION_REQUIRED(gdcmReader.IsNotNull(), "DICOMITKSeriesGDCMReader can be instantiated.");
std::string output_filename = "/tmp/dicom_out.dwi";
if( argc > 3)
{
mitk::DICOMFileReaderTestHelper::SetTestInputFilenames( argc-1,argv );
output_filename = std::string( argv[argc-1] );
}
else
{
mitk::DICOMFileReaderTestHelper::SetTestInputFilenames( argc,argv );
}
// check the Set/GetInput function
mitk::DICOMFileReaderTestHelper::TestInputFilenames( gdcmReader );
MITK_INFO << "Test input filenanems";
// check that output is a good reproduction of input (no duplicates, no new elements)
mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
MITK_INFO << "Test output";
// repeat test with some more realistic sorting
gdcmReader = mitk::DiffusionDICOMFileReader::New(); // this also tests destruction
mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
// Use tags as in Qmitk
// 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) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
// TODO handle as real vectors! cluster with configurable errors!
//tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x000e) ); // Series Instance UID
//tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0010) );
tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x0050) ); // Slice Thickness
tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0008) ); // Number of Frames
tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
// gdcmReader->AddSortingElement( tagSorter );
//mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
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(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 );
MITK_INFO << "Created sort";
gdcmReader->AddSortingElement( tagSorter );
mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
MITK_INFO << "Created sort";
//gdcmReader->PrintOutputs(std::cout, true);
// really load images
//mitk::DICOMFileReaderTestHelper::TestMitkImagesAreLoaded( gdcmReader );
gdcmReader->LoadImages();
mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(0).GetMitkImage();
- mitk::DiffusionImage<short>::Pointer d_img = static_cast<mitk::DiffusionImage<short>*>( loaded_image.GetPointer() );
-
try
{
- mitk::IOUtil::Save(d_img, output_filename.c_str());
+ mitk::IOUtil::Save(loaded_image, output_filename.c_str());
}
catch( const itk::ExceptionObject& e)
{
MITK_TEST_FAILED_MSG( << "Writer failed : " << e.what() );
}
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionImageEqualTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionImageEqualTest.cpp
deleted file mode 100644
index 8f33698338..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionImageEqualTest.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/*===================================================================
-
-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 "mitkDiffusionImage.h"
-#include "mitkIOUtil.h"
-#include "mitkTestingMacros.h"
-#include "mitkTestFixture.h"
-#include "itkDwiGradientLengthCorrectionFilter.h"
-
-class mitkDiffusionImageEqualTestSuite : public mitk::TestFixture
-{
-
- CPPUNIT_TEST_SUITE(mitkDiffusionImageEqualTestSuite);
- MITK_TEST(Equal_CloneAndOriginal_ReturnsTrue);
- MITK_TEST(Equal_DifferentGradientContainerElements_ReturnsFalse);
- MITK_TEST(Equal_DifferentBValue_ReturnsFalse);
- MITK_TEST(Equal_DifferentVectorImagePixel_ReturnFalse);
- MITK_TEST(Equal_GetNumberOfBValues_ReturnFalse);
- MITK_TEST(Equal_DifferentMeasurmentFrame_ReturnFalse);
- //MITK_TEST(Equal_DifferentChannels_ReturnFalse);
-
-
- CPPUNIT_TEST_SUITE_END();
-
-private:
-
- /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
- mitk::DiffusionImage<short>::Pointer m_Image;
- mitk::DiffusionImage<short>::Pointer m_AnotherImage;
-
-public:
-
- /**
-* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
-*/
- void setUp()
- {
- //generate a gradient test image
- std::string imagePath = GetTestDataFilePath("DiffusionImaging/ImageReconstruction/test_multi.dwi");
- m_Image = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(imagePath).GetPointer());
- m_AnotherImage = m_Image->Clone();
- }
-
- void tearDown()
- {
- m_Image = NULL;
- m_AnotherImage = NULL;
- }
-
- void Equal_CloneAndOriginal_ReturnsTrue()
- {
- MITK_ASSERT_EQUAL( m_Image, m_AnotherImage, "A clone should be equal to its original.");
- }
-
- void Equal_DifferentGradientContainerElements_ReturnsFalse()
- {
- mitk::DiffusionImage<short>::GradientDirectionType dummyVec;
- dummyVec.fill(std::numeric_limits<double>::max());
- mitk::DiffusionImage<short>::GradientDirectionContainerType::ElementIdentifier mid_pos(m_AnotherImage->GetDirections()->Size()*0.5);
- m_AnotherImage->GetDirections()->SetElement(mid_pos, dummyVec);
- MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "GradientDirectionContainer Elements are not equal.");
- }
-
- void Equal_DifferentBValue_ReturnsFalse()
- {
- m_AnotherImage->SetReferenceBValue(std::numeric_limits<unsigned int>::max());
- MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "BValue is not equal.");
- }
-
- void Equal_DifferentVectorImagePixel_ReturnFalse()
- {
- mitk::DiffusionImage<short>::ImageType::IndexType indx;
- indx.Fill(0);
- mitk::DiffusionImage<short>::ImageType::PixelType pix;
- short* val = new short[pix.Size()];
- pix.SetData(val);
- pix.Fill(std::numeric_limits<short>::min());
- m_AnotherImage->GetVectorImage()->SetPixel(indx,pix);
- MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "itkVectorImage voxel at pos [0,0,0] should be different.");
- }
-
- void Equal_DifferentMeasurmentFrame_ReturnFalse()
- {
- mitk::DiffusionImage<short>::MeasurementFrameType null_measurementframe;
- null_measurementframe.fill(0);
- m_AnotherImage->SetMeasurementFrame(null_measurementframe);
- MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "MeasurementFrame is an empty matrix. Result should be false.");
- }
-
- void Equal_GetNumberOfBValues_ReturnFalse()
- {
- itk::DwiGradientLengthCorrectionFilter::Pointer lengthCorrectionFilter = itk::DwiGradientLengthCorrectionFilter::New();
- lengthCorrectionFilter->SetReferenceBValue(m_AnotherImage->GetReferenceBValue());
- lengthCorrectionFilter->SetReferenceGradientDirectionContainer(m_AnotherImage->GetDirections());
- lengthCorrectionFilter->SetRoundingValue(10000);
- lengthCorrectionFilter->Update();
- m_AnotherImage->SetDirections(lengthCorrectionFilter->GetOutputGradientDirectionContainer());
- MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "NumberOfBValues should different.");
- }
-
-};
-
-MITK_TEST_SUITE_REGISTRATION(mitkDiffusionImageEqual)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionPropertySerializerTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionPropertySerializerTest.cpp
new file mode 100644
index 0000000000..436646692c
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionPropertySerializerTest.cpp
@@ -0,0 +1,184 @@
+/*===================================================================
+
+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 "mitkIOUtil.h"
+#include "mitkTestingMacros.h"
+#include "mitkTestFixture.h"
+
+#include <mitkBasePropertySerializer.h>
+
+#include <mitkBValueMapProperty.h>
+
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkMeasurementFrameProperty.h>
+
+#include <mitkDiffusionPropertyHelper.h>
+
+class mitkDiffusionPropertySerializerTestSuite : public mitk::TestFixture
+{
+
+ CPPUNIT_TEST_SUITE(mitkDiffusionPropertySerializerTestSuite);
+ MITK_TEST(Equal_SerializeandDeserialize_ReturnsTrue);
+
+ //MITK_TEST(Equal_DifferentChannels_ReturnFalse);
+
+
+ CPPUNIT_TEST_SUITE_END();
+
+private:
+
+ /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
+ mitk::PropertyList::Pointer propList; //represet image propertylist
+ mitk::BValueMapProperty::Pointer bvaluemap_prop;
+ mitk::GradientDirectionsProperty::Pointer gradientdirection_prop;
+ mitk::MeasurementFrameProperty::Pointer measurementframe_prop;
+
+public:
+
+ /**
+* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
+*/
+ void setUp()
+ {
+
+ propList = mitk::PropertyList::New();
+
+ mitk::BValueMapProperty::BValueMap map;
+ std::vector<unsigned int> indices1;
+ indices1.push_back(1);
+ indices1.push_back(2);
+ indices1.push_back(3);
+ indices1.push_back(4);
+
+ map[0] = indices1;
+ std::vector<unsigned int> indices2;
+ indices2.push_back(4);
+ indices2.push_back(3);
+ indices2.push_back(2);
+ indices2.push_back(1);
+
+ map[1000] = indices2;
+ bvaluemap_prop = mitk::BValueMapProperty::New(map).GetPointer();
+ propList->SetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(),bvaluemap_prop);
+
+
+ mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer gdc;
+ gdc = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+
+ double a[3] = {3.0,4.0,1.4};
+ vnl_vector_fixed<double,3> vec1;
+ vec1.set(a);
+ gdc->push_back(vec1);
+
+ double b[3] = {1.0,5.0,123.4};
+ vnl_vector_fixed<double,3> vec2;
+ vec2.set(b);
+ gdc->push_back(vec2);
+
+ double c[3] = {13.0,84.02,13.4};
+ vnl_vector_fixed<double,3> vec3;
+ vec3.set(c);
+ gdc->push_back(vec3);
+
+
+ gradientdirection_prop = mitk::GradientDirectionsProperty::New(gdc.GetPointer()).GetPointer();
+ propList->SetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), gradientdirection_prop);
+
+ mitk::MeasurementFrameProperty::MeasurementFrameType mft;
+
+ double row0[3] = {1,0,0};
+ double row1[3] = {0,1,0};
+ double row2[3] = {0,0,1};
+
+ mft.set_row(0,row0);
+ mft.set_row(1,row1);
+ mft.set_row(2,row2);
+
+ measurementframe_prop = mitk::MeasurementFrameProperty::New(mft).GetPointer();
+ propList->SetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), measurementframe_prop);
+ }
+
+ void tearDown()
+ {
+
+ }
+
+ void Equal_SerializeandDeserialize_ReturnsTrue()
+ {
+
+ assert(propList);
+
+ /* try to serialize each property in the list, then deserialize again and check for equality */
+ for (mitk::PropertyList::PropertyMap::const_iterator it = propList->GetMap()->begin(); it != propList->GetMap()->end(); ++it)
+ {
+ const mitk::BaseProperty* prop = it->second;
+ // construct name of serializer class
+ std::string serializername = std::string(prop->GetNameOfClass()) + "Serializer";
+ std::list<itk::LightObject::Pointer> allSerializers = itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
+ MITK_TEST_CONDITION(allSerializers.size() > 0, std::string("Creating serializers for ") + serializername);
+ if (allSerializers.size() == 0)
+ {
+ MITK_TEST_OUTPUT( << "serialization not possible, skipping " << prop->GetNameOfClass());
+ continue;
+ }
+ if (allSerializers.size() > 1)
+ {
+ MITK_TEST_OUTPUT (<< "Warning: " << allSerializers.size() << " serializers found for " << prop->GetNameOfClass() << "testing only the first one.");
+ }
+ mitk::BasePropertySerializer* serializer = dynamic_cast<mitk::BasePropertySerializer*>( allSerializers.begin()->GetPointer());
+ MITK_TEST_CONDITION(serializer != NULL, serializername + std::string(" is valid"));
+ if (serializer != NULL)
+ {
+ serializer->SetProperty(prop);
+ TiXmlElement* valueelement = NULL;
+ try
+ {
+ valueelement = serializer->Serialize();
+// TiXmlPrinter p;
+// valueelement->Accept(&p);
+// MITK_INFO << p.CStr();
+ }
+ catch (...)
+ {
+ }
+ MITK_TEST_CONDITION(valueelement != NULL, std::string("Serialize property with ") + serializername);
+
+ if (valueelement == NULL)
+ {
+ MITK_TEST_OUTPUT( << "serialization failed, skipping deserialization");
+ continue;
+ }
+
+ mitk::BaseProperty::Pointer deserializedProp = serializer->Deserialize( valueelement );
+ MITK_TEST_CONDITION(deserializedProp.IsNotNull(), "serializer created valid property");
+ if (deserializedProp.IsNotNull())
+ {
+ MITK_TEST_CONDITION(*(deserializedProp.GetPointer()) == *prop, "deserialized property equals initial property for type " << prop->GetNameOfClass());
+ }
+
+ }
+ else
+ {
+ MITK_TEST_OUTPUT( << "created serializer object is of class " << allSerializers.begin()->GetPointer()->GetNameOfClass())
+ }
+ } // for all properties
+
+ }
+
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkDiffusionPropertySerializer)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp
index f2b1ae2338..43686ea03e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp
@@ -1,96 +1,103 @@
/*===================================================================
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 "mitkTestingMacros.h"
#include "mitkIOUtil.h"
#include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
#include "mitkDWIHeadMotionCorrectionFilter.h"
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkProperties.h>
typedef short DiffusionPixelType;
-typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
int mitkExtractSingleShellTest( int argc, char* argv[] )
{
MITK_TEST_BEGIN("mitkExtractSingleShellTest");
MITK_TEST_CONDITION_REQUIRED( argc > 3, "Specify input and output and the shell to be extracted");
/*
1. Get input data
*/
- mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( argv[1] );
- DiffusionImageType* dwimage =
- static_cast<DiffusionImageType*>( inputImage.GetPointer() );
+ mitk::Image::Pointer dwimage = mitk::IOUtil::LoadImage( argv[1] );
- MITK_TEST_CONDITION_REQUIRED( dwimage != NULL, "Input is a dw-image");
+ mitk::GradientDirectionsProperty::Pointer gradientsProperty = static_cast<mitk::GradientDirectionsProperty *>( dwimage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() );
+
+ MITK_TEST_CONDITION_REQUIRED( gradientsProperty.IsNotNull(), "Input is a dw-image");
unsigned int extract_value = 0;
std::istringstream input(argv[3]);
input >> extract_value;
typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
- typedef DiffusionImageType::BValueMap BValueMap;
+ typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMap;
// GetShellSelection from GUI
BValueMap shellSelectionMap;
- BValueMap originalShellMap = dwimage->GetBValueMap();
+ BValueMap originalShellMap = static_cast<mitk::BValueMapProperty*>(dwimage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
std::vector<unsigned int> newNumGradientDirections;
shellSelectionMap[extract_value] = originalShellMap[extract_value];
newNumGradientDirections.push_back( originalShellMap[extract_value].size() ) ;
- DiffusionImageType::GradientDirectionContainerType::Pointer gradientContainer = dwimage->GetDirections();
+ itk::VectorImage< short, 3 >::Pointer itkVectorImagePointer = itk::VectorImage< short, 3 >::New();
+ mitk::CastToItkImage(dwimage, itkVectorImagePointer);
+ itk::VectorImage< short, 3 > *vectorImage = itkVectorImagePointer.GetPointer();
+
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( dwimage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
FilterType::Pointer filter = FilterType::New();
- filter->SetInput(dwimage->GetVectorImage());
+ filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetNumGradientDirections(newNumGradientDirections);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetShellSelectionBValueMap(shellSelectionMap);
try
{
filter->Update();
}
catch( const itk::ExceptionObject& e)
{
MITK_TEST_FAILED_MSG( << "Failed due to ITK exception: " << e.what() );
}
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue(dwimage->GetReferenceBValue());
- image->SetDirections(filter->GetGradientDirections());
- image->SetMeasurementFrame(dwimage->GetMeasurementFrame());
- image->InitializeFromVectorImage();
+ mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetGradientDirections() ) );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(dwimage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(dwimage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( outImage );
+ propertyHelper.InitializeImage();
+
/*
* 3. Write output data
**/
try
{
- mitk::IOUtil::Save(image, argv[2]);
+ mitk::IOUtil::Save(outImage, argv[2]);
}
catch( const itk::ExceptionObject& e)
{
MITK_ERROR << "Catched exception: " << e.what();
mitkThrow() << "Failed with exception from subprocess!";
}
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
index e1f16dcca7..33bfd4cd53 100755
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
@@ -1,152 +1,158 @@
/*===================================================================
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 <mitkImageCast.h>
#include <mitkTensorImage.h>
#include <mitkQBallImage.h>
-#include <mitkDiffusionImage.h>
#include <mitkIOUtil.h>
#include <mitkBaseDataIOFactory.h>
#include <itkDiffusionTensor3D.h>
#include <mitkTestingMacros.h>
#include <itkDiffusionTensor3DReconstructionImageFilter.h>
#include <itkDiffusionTensor3D.h>
#include <itkDiffusionQballReconstructionImageFilter.h>
#include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
using namespace std;
int mitkImageReconstructionTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkImageReconstructionTest");
MITK_TEST_CONDITION_REQUIRED(argc>1,"check for input data")
try
{
- mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
+ mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
+ itk::VectorImage<short,3>::Pointer itkVectorImagePointer = itk::VectorImage<short,3>::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
+ float b_value = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradients = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
{
MITK_INFO << "Tensor reconstruction " << argv[2];
mitk::TensorImage::Pointer tensorImage = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, float > TensorReconstructionImageFilterType;
TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( gradients, itkVectorImagePointer );
+ filter->SetBValue( b_value );
filter->Update();
mitk::TensorImage::Pointer testImage = mitk::TensorImage::New();
testImage->InitializeByItk( filter->GetOutput() );
testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *tensorImage, 0.0001, true), "tensor reconstruction test.");
}
{
MITK_INFO << "Numerical Q-ball reconstruction " << argv[3];
mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
typedef itk::DiffusionQballReconstructionImageFilter<short, short, float, QBALL_ODFSIZE> QballReconstructionImageFilterType;
QballReconstructionImageFilterType::Pointer filter = QballReconstructionImageFilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( gradients, itkVectorImagePointer );
+ filter->SetBValue( b_value );
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
filter->Update();
mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
testImage->InitializeByItk( filter->GetOutput() );
testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "Numerical Q-ball reconstruction test.");
}
{
MITK_INFO << "Standard Q-ball reconstruction " << argv[4];
mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( gradients, itkVectorImagePointer );
+ filter->SetBValue( b_value );
filter->SetLambda(0.006);
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
filter->Update();
mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
testImage->InitializeByItk( filter->GetOutput() );
testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "Standard Q-ball reconstruction test.");
}
{
MITK_INFO << "CSA Q-ball reconstruction " << argv[5];
mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( gradients, itkVectorImagePointer );
+ filter->SetBValue( b_value );
filter->SetLambda(0.006);
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
filter->Update();
mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
testImage->InitializeByItk( filter->GetOutput() );
testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "CSA Q-ball reconstruction test.");
}
{
MITK_INFO << "ADC profile reconstruction " << argv[6];
mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( gradients, itkVectorImagePointer );
+ filter->SetBValue( b_value );
filter->SetLambda(0.006);
filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
filter->Update();
mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
testImage->InitializeByItk( filter->GetOutput() );
testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "ADC profile reconstruction test.");
}
{
MITK_INFO << "Raw signal modeling " << argv[7];
mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( gradients, itkVectorImagePointer );
+ filter->SetBValue( b_value );
filter->SetLambda(0.006);
filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
filter->Update();
mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
testImage->InitializeByItk( filter->GetOutput() );
testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "Raw signal modeling test.");
}
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp
index 680b5c6295..62a7941cb4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp
@@ -1,176 +1,169 @@
/*===================================================================
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 "mitkDiffusionImage.h"
#include "mitkIOUtil.h"
#include "mitkTestingMacros.h"
#include "mitkTestFixture.h"
#include "itkNonLocalMeansDenoisingFilter.h"
+#include "mitkGradientDirectionsProperty.h"
+#include "mitkITKImageImport.h"
+#include <mitkImageCast.h>
class mitkNonLocalMeansDenoisingTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkNonLocalMeansDenoisingTestSuite);
MITK_TEST(Denoise_NLMg_shouldReturnTrue);
MITK_TEST(Denoise_NLMr_shouldReturnTrue);
MITK_TEST(Denoise_NLMv_shouldReturnTrue);
MITK_TEST(Denoise_NLMvr_shouldReturnTrue);
CPPUNIT_TEST_SUITE_END();
private:
+ typedef itk::VectorImage<short,3> VectorImagetType;
+
/** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
- mitk::DiffusionImage<short>::Pointer m_Image;
- mitk::DiffusionImage<short>::Pointer m_ReferenceImage;
- mitk::DiffusionImage<short>::Pointer m_DenoisedImage;
+ mitk::Image::Pointer m_Image;
+ mitk::Image::Pointer m_ReferenceImage;
+ mitk::Image::Pointer m_DenoisedImage;
itk::Image<short, 3>::Pointer m_ImageMask;
itk::NonLocalMeansDenoisingFilter<short>::Pointer m_DenoisingFilter;
public:
/**
* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
*/
void setUp()
{
//generate test images
std::string imagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi.dwi");
-// std::string maskPath = GetTestDataFilePath("DiffusionImaging/Denoising/denoising_mask.nrrd");
- m_Image = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(imagePath).GetPointer());
-// mitk::Image::Pointer imageMask = static_cast<mitk::Image*>( mitk::IOUtil::LoadImage(maskPath).GetPointer());
-// mitk::CastToItkImage(imageMask, m_ImageMask);
+ m_Image = mitk::IOUtil::LoadImage(imagePath);
m_ReferenceImage = NULL;
- m_DenoisedImage = mitk::DiffusionImage<short>::New();
+ m_DenoisedImage = mitk::Image::New();
//initialise Filter
m_DenoisingFilter = itk::NonLocalMeansDenoisingFilter<short>::New();
- m_DenoisingFilter->SetInputImage(m_Image->GetVectorImage());
-// m_DenoisingFilter->SetInputMask(m_ImageMask);
+ VectorImagetType::Pointer vectorImage;
+ mitk::CastToItkImage(m_Image,vectorImage);
+ m_DenoisingFilter->SetInputImage(vectorImage);
m_DenoisingFilter->SetNumberOfThreads(1);
m_DenoisingFilter->SetComparisonRadius(1);
m_DenoisingFilter->SetSearchRadius(1);
m_DenoisingFilter->SetVariance(500);
}
void tearDown()
{
m_Image = NULL;
m_ImageMask = NULL;
m_ReferenceImage = NULL;
m_DenoisingFilter = NULL;
m_DenoisedImage = NULL;
}
void Denoise_NLMg_shouldReturnTrue()
{
std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMg.dwi");
- m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
+ m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
m_DenoisingFilter->SetUseRicianAdaption(false);
m_DenoisingFilter->SetUseJointInformation(false);
try
{
m_DenoisingFilter->Update();
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
- m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
- m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
- m_DenoisedImage->SetDirections(m_Image->GetDirections());
- m_DenoisedImage->InitializeFromVectorImage();
+ mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+ m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMg should always return the same result.");
}
void Denoise_NLMr_shouldReturnTrue()
{
std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMr.dwi");
- m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
+ m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
m_DenoisingFilter->SetUseRicianAdaption(true);
m_DenoisingFilter->SetUseJointInformation(false);
try
{
m_DenoisingFilter->Update();
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
- m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
- m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
- m_DenoisedImage->SetDirections(m_Image->GetDirections());
- m_DenoisedImage->InitializeFromVectorImage();
+ mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+ m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMr should always return the same result.");
}
void Denoise_NLMv_shouldReturnTrue()
{
std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMv.dwi");
- m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
-
+ m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
m_DenoisingFilter->SetUseRicianAdaption(false);
m_DenoisingFilter->SetUseJointInformation(true);
try
{
m_DenoisingFilter->Update();
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
- m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
- m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
- m_DenoisedImage->SetDirections(m_Image->GetDirections());
- m_DenoisedImage->InitializeFromVectorImage();
+ mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+ m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMv should always return the same result.");
}
void Denoise_NLMvr_shouldReturnTrue()
{
std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMvr.dwi");
- m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
+ m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
m_DenoisingFilter->SetUseRicianAdaption(true);
m_DenoisingFilter->SetUseJointInformation(true);
try
{
m_DenoisingFilter->Update();
}
catch(std::exception& e)
{
MITK_ERROR << e.what();
}
- m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
- m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
- m_DenoisedImage->SetDirections(m_Image->GetDirections());
- m_DenoisedImage->InitializeFromVectorImage();
+ mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+ m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMvr should always return the same result.");
}
};
MITK_TEST_SUITE_REGISTRATION(mitkNonLocalMeansDenoising)
diff --git a/Modules/DiffusionImaging/DiffusionCore/files.cmake b/Modules/DiffusionImaging/DiffusionCore/files.cmake
index f9995fbe3d..dae157948b 100644
--- a/Modules/DiffusionImaging/DiffusionCore/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionCore/files.cmake
@@ -1,138 +1,149 @@
set(CPP_FILES
# DicomImport
DicomImport/mitkDicomDiffusionImageReader.cpp
# DicomImport/mitkGroupDiffusionHeadersFilter.cpp
DicomImport/mitkDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkGEDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkPhilipsDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkSiemensDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkSiemensMosaicDicomDiffusionImageHeaderReader.cpp
DicomImport/mitkDiffusionDICOMFileReader.cpp
DicomImport/mitkDiffusionHeaderDICOMFileReader.cpp
DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
DicomImport/mitkDiffusionHeaderSiemensMosaicDICOMFileReader.cpp
DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
# DataStructures -> DWI
IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
- IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
-
- IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp
IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
+ # Properties
+ IODataStructures/Properties/mitkBValueMapProperty.cpp
+ IODataStructures/Properties/mitkGradientDirectionsProperty.cpp
+ IODataStructures/Properties/mitkMeasurementFrameProperty.cpp
+ IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp
+ IODataStructures/Properties/mitkNodePredicateIsDWI.cpp
+
+ # Serializer
+ IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp
+ IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp
+ IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp
+
# DataStructures -> QBall
IODataStructures/QBallImages/mitkQBallImageSource.cpp
IODataStructures/QBallImages/mitkQBallImage.cpp
# DataStructures -> Tensor
IODataStructures/TensorImages/mitkTensorImage.cpp
Rendering/vtkMaskedProgrammableGlyphFilter.cpp
Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
Rendering/vtkOdfSource.cxx
Rendering/vtkThickPlane.cxx
Rendering/mitkOdfNormalizationMethodProperty.cpp
Rendering/mitkOdfScaleByProperty.cpp
# Algorithms
Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
Algorithms/itkDwiGradientLengthCorrectionFilter.cpp
Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
# Registration Algorithms & Co.
Algorithms/Registration/mitkRegistrationWrapper.cpp
Algorithms/Registration/mitkPyramidImageRegistrationMethod.cpp
# Algorithms/Registration/mitkRegistrationMethodITK4.cpp
+ Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
# MultishellProcessing
Algorithms/Reconstruction/MultishellProcessing/itkADCAverageFunctor.cpp
Algorithms/Reconstruction/MultishellProcessing/itkADCFitFunctor.cpp
Algorithms/Reconstruction/MultishellProcessing/itkKurtosisFitFunctor.cpp
Algorithms/Reconstruction/MultishellProcessing/itkBiExpFitFunctor.cpp
# Function Collection
mitkDiffusionFunctionCollection.cpp
)
set(H_FILES
# function Collection
mitkDiffusionFunctionCollection.h
# Rendering
- Rendering/mitkDiffusionImageMapper.h
Rendering/mitkOdfVtkMapper2D.h
# Reconstruction
Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
Algorithms/Reconstruction/itkPointShell.h
Algorithms/Reconstruction/itkOrientationDistributionFunction.h
Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
# MultishellProcessing
Algorithms/Reconstruction/MultishellProcessing/itkRadialMultishellToSingleshellImageFilter.h
Algorithms/Reconstruction/MultishellProcessing/itkDWIVoxelFunctor.h
Algorithms/Reconstruction/MultishellProcessing/itkADCAverageFunctor.h
Algorithms/Reconstruction/MultishellProcessing/itkKurtosisFitFunctor.h
Algorithms/Reconstruction/MultishellProcessing/itkBiExpFitFunctor.h
Algorithms/Reconstruction/MultishellProcessing/itkADCFitFunctor.h
- # IO Datastructures
- IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
+ # Properties
+ IODataStructures/Properties/mitkBValueMapProperty.h
+ IODataStructures/Properties/mitkGradientDirectionsProperty.h
+ IODataStructures/Properties/mitkMeasurementFrameProperty.h
+ IODataStructures/Properties/mitkDiffusionPropertyHelper.h
# Algorithms
Algorithms/itkDiffusionQballGeneralizedFaImageFilter.h
Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.h
Algorithms/itkTensorDerivedMeasurementsFilter.h
Algorithms/itkBrainMaskExtractionImageFilter.h
Algorithms/itkB0ImageExtractionImageFilter.h
Algorithms/itkB0ImageExtractionToSeparateImageFilter.h
Algorithms/itkTensorImageToDiffusionImageFilter.h
Algorithms/itkTensorToL2NormImageFilter.h
Algorithms/itkGaussianInterpolateImageFunction.h
Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.h
Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
Algorithms/itkCartesianToPolarVectorImageFilter.h
Algorithms/itkPolarToCartesianVectorImageFilter.h
Algorithms/itkDistanceMapFilter.h
Algorithms/itkProjectionFilter.h
Algorithms/itkResidualImageFilter.h
Algorithms/itkExtractChannelFromRgbaImageFilter.h
Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
Algorithms/itkMergeDiffusionImagesFilter.h
Algorithms/itkDwiPhantomGenerationFilter.h
Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
Algorithms/itkMrtrixPeakImageConverter.h
Algorithms/itkFslPeakImageConverter.h
Algorithms/itkShCoefficientImageImporter.h
Algorithms/itkShCoefficientImageExporter.h
Algorithms/itkOdfMaximaExtractionFilter.h
Algorithms/itkResampleDwiImageFilter.h
Algorithms/itkDwiGradientLengthCorrectionFilter.h
Algorithms/itkAdcImageFilter.h
Algorithms/itkDwiNormilzationFilter.h
Algorithms/itkSplitDWImageFilter.h
Algorithms/itkRemoveDwiChannelFilter.h
Algorithms/itkExtractDwiChannelFilter.h
Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
- Algorithms/mitkDiffusionImageToDiffusionImageFilter.h
Algorithms/itkNonLocalMeansDenoisingFilter.h
Algorithms/itkVectorImageToImageFilter.h
)
set( TOOL_FILES
)
diff --git a/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt
index 134852a470..fd6007c431 100644
--- a/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt
+++ b/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt
@@ -1,7 +1,8 @@
MITK_CREATE_MODULE(
SUBPROJECTS MITK-DTI
+ INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}
DEPENDS MitkConnectomics MitkQuantification MitkFiberTracking
AUTOLOAD_WITH MitkCore
WARNINGS_AS_ERRORS
)
diff --git a/Modules/DiffusionImaging/DiffusionIO/files.cmake b/Modules/DiffusionImaging/DiffusionIO/files.cmake
index 8d8f04bd0d..5686192842 100644
--- a/Modules/DiffusionImaging/DiffusionIO/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionIO/files.cmake
@@ -1,39 +1,39 @@
set(CPP_FILES
mitkDiffusionModuleActivator.cpp
mitkNrrdTbssImageWriterFactory.cpp
#mitkFiberBundleXIOFactory.cpp
mitkConnectomicsNetworkReader.cpp
mitkConnectomicsNetworkWriter.cpp
mitkConnectomicsNetworkSerializer.cpp
mitkConnectomicsNetworkDefinitions.cpp
mitkNrrdTbssRoiImageIOFactory.cpp
#mitkFiberBundleXWriterFactory.cpp
mitkNrrdTbssRoiImageWriterFactory.cpp
mitkNrrdTensorImageReader.cpp
mitkNrrdTensorImageWriter.cpp
mitkTensorImageSerializer.cpp
mitkTensorImageSource.cpp
mitkFiberTrackingObjectFactory.cpp
mitkConnectomicsObjectFactory.cpp
mitkQuantificationObjectFactory.cpp
mitkNrrdTbssImageIOFactory.cpp
mitkDiffusionCoreObjectFactory.cpp
mitkDiffusionIOMimeTypes.cpp
mitkNrrdDiffusionImageReader.cpp
mitkNrrdDiffusionImageWriter.cpp
- mitkDiffusionImageSerializer.cpp
mitkNrrdQBallImageReader.cpp
mitkNrrdQBallImageWriter.cpp
mitkQBallImageSerializer.cpp
mitkFiberBundleXReader.cpp
mitkFiberBundleXWriter.cpp
mitkFiberBundleXSerializer.cpp
mitkFiberBundleXMapper2D.cpp
mitkFiberBundleXMapper3D.cpp
mitkCompositeMapper.cpp
+
)
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
index 6a33ecfd0e..9282a2e9d3 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
@@ -1,181 +1,159 @@
/*===================================================================
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 "mitkDiffusionCoreObjectFactory.h"
#include "mitkProperties.h"
#include "mitkBaseRenderer.h"
#include "mitkDataNode.h"
#include "mitkNrrdDiffusionImageWriter.h"
-#include "mitkDiffusionImage.h"
#include "mitkCompositeMapper.h"
-#include "mitkDiffusionImageMapper.h"
#include "mitkGPUVolumeMapper3D.h"
#include "mitkVolumeDataVtkMapper3D.h"
typedef short DiffusionPixelType;
-typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
typedef std::multimap<std::string, std::string> MultimapType;
mitk::DiffusionCoreObjectFactory::DiffusionCoreObjectFactory()
: CoreObjectFactoryBase()
{
static bool alreadyDone = false;
if (!alreadyDone)
{
MITK_DEBUG << "DiffusionCoreObjectFactory c'tor" << std::endl;
CreateFileExtensionsMap();
alreadyDone = true;
}
}
mitk::DiffusionCoreObjectFactory::~DiffusionCoreObjectFactory()
{
}
mitk::Mapper::Pointer mitk::DiffusionCoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
{
mitk::Mapper::Pointer newMapper=NULL;
if ( id == mitk::BaseRenderer::Standard2D )
{
std::string classname("QBallImage");
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
newMapper = mitk::CompositeMapper::New();
newMapper->SetDataNode(node);
node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
}
classname = "TensorImage";
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
newMapper = mitk::CompositeMapper::New();
newMapper->SetDataNode(node);
node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
}
- classname = "DiffusionImage";
- if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
- {
- newMapper = mitk::DiffusionImageMapper<short>::New();
- newMapper->SetDataNode(node);
- }
-
}
else if ( id == mitk::BaseRenderer::Standard3D )
{
std::string classname("QBallImage");
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
newMapper = mitk::GPUVolumeMapper3D::New();
newMapper->SetDataNode(node);
}
classname = "TensorImage";
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
newMapper = mitk::GPUVolumeMapper3D::New();
newMapper->SetDataNode(node);
}
- classname = "DiffusionImage";
- if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
- {
- newMapper = mitk::GPUVolumeMapper3D::New();
- newMapper->SetDataNode(node);
- }
}
return newMapper;
}
void mitk::DiffusionCoreObjectFactory::SetDefaultProperties(mitk::DataNode* node)
{
std::string classname = "QBallImage";
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
mitk::CompositeMapper::SetDefaultProperties(node);
mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
}
classname = "TensorImage";
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
mitk::CompositeMapper::SetDefaultProperties(node);
mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
}
- classname = "DiffusionImage";
- if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
- {
- mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
- mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
- }
}
const char* mitk::DiffusionCoreObjectFactory::GetFileExtensions()
{
std::string fileExtension;
this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
return fileExtension.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionCoreObjectFactory::GetFileExtensionsMap()
{
return m_FileExtensionsMap;
}
const char* mitk::DiffusionCoreObjectFactory::GetSaveFileExtensions()
{
std::string fileExtension;
this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
return fileExtension.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionCoreObjectFactory::GetSaveFileExtensionsMap()
{
return m_SaveFileExtensionsMap;
}
void mitk::DiffusionCoreObjectFactory::CreateFileExtensionsMap()
{
}
struct RegisterDiffusionCoreObjectFactory{
RegisterDiffusionCoreObjectFactory()
: m_Factory( mitk::DiffusionCoreObjectFactory::New() )
{
mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
}
~RegisterDiffusionCoreObjectFactory()
{
mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
}
mitk::DiffusionCoreObjectFactory::Pointer m_Factory;
};
static RegisterDiffusionCoreObjectFactory registerDiffusionCoreObjectFactory;
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
index bb2494355f..3969ba1da0 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
@@ -1,161 +1,225 @@
/*===================================================================
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 "mitkDiffusionIOMimeTypes.h"
#include "mitkIOMimeTypes.h"
+#include <itksys/SystemTools.hxx>
+#include <itkNrrdImageIO.h>
+#include <itkMetaDataDictionary.h>
+#include <itkMetaDataObject.h>
namespace mitk
{
std::vector<CustomMimeType*> DiffusionIOMimeTypes::Get()
{
std::vector<CustomMimeType*> mimeTypes;
// order matters here (descending rank for mime types)
mimeTypes.push_back(DWI_MIMETYPE().Clone());
mimeTypes.push_back(DTI_MIMETYPE().Clone());
mimeTypes.push_back(QBI_MIMETYPE().Clone());
mimeTypes.push_back(FIBERBUNDLE_MIMETYPE().Clone());
mimeTypes.push_back(CONNECTOMICS_MIMETYPE().Clone());
return mimeTypes;
}
// Mime Types
CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE()
{
CustomMimeType mimeType(FIBERBUNDLE_MIMETYPE_NAME());
std::string category = "Fiber Bundle File";
mimeType.SetComment("Fiber Bundles");
mimeType.SetCategory(category);
mimeType.AddExtension("fib");
mimeType.AddExtension("trk");
//mimeType.AddExtension("vtk");
return mimeType;
}
-CustomMimeType DiffusionIOMimeTypes::DWI_MIMETYPE()
+DiffusionIOMimeTypes::DwiMimeType::DwiMimeType()
+ : CustomMimeType(DWI_MIMETYPE_NAME())
{
- CustomMimeType mimeType(DWI_MIMETYPE_NAME());
std::string category = "Diffusion Weighted Image";
- mimeType.SetComment("Diffusion Weighted Images");
- mimeType.SetCategory(category);
- mimeType.AddExtension("dwi");
- mimeType.AddExtension("hdwi");
- mimeType.AddExtension("fsl");
- mimeType.AddExtension("fslgz");
- return mimeType;
+ this->SetCategory(category);
+ this->SetComment("Diffusion Weighted Images");
+
+ this->AddExtension("dwi");
+ this->AddExtension("hdwi");
+ this->AddExtension("fsl");
+ this->AddExtension("fslgz");
+ this->AddExtension("nrrd");
+}
+
+bool DiffusionIOMimeTypes::DwiMimeType::AppliesTo(const std::string &path) const
+{
+ bool canRead( CustomMimeType::AppliesTo(path) );
+
+ // fix for bug 18572
+ // Currently this function is called for writing as well as reading, in that case
+ // the image information can of course not be read
+ // This is a bug, this function should only be called for reading.
+ if( ! itksys::SystemTools::FileExists( path.c_str() ) )
+ {
+ return canRead;
+ }
+ //end fix for bug 18572
+
+ std::string ext = itksys::SystemTools::GetFilenameLastExtension( path );
+ ext = itksys::SystemTools::LowerCase( ext );
+
+ // Simple NRRD files should only be considered for this mime type if they contain
+ // corresponding tags
+ if( ext == ".nrrd" )
+ {
+ itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+ io->SetFileName(path);
+ io->ReadImageInformation();
+
+ itk::MetaDataDictionary imgMetaDictionary = io->GetMetaDataDictionary();
+ std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+ std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+ std::string metaString;
+
+ for (; itKey != imgMetaKeys.end(); itKey ++)
+ {
+ itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+ if (itKey->find("modality") != std::string::npos)
+ {
+ if (metaString.find("DWMRI") != std::string::npos)
+ {
+ return canRead;
+ }
+ }
+ }
+
+ canRead = false;
+ }
+
+ return canRead;
+}
+
+DiffusionIOMimeTypes::DwiMimeType* DiffusionIOMimeTypes::DwiMimeType::Clone() const
+{
+ return new DwiMimeType(*this);
+}
+
+
+DiffusionIOMimeTypes::DwiMimeType DiffusionIOMimeTypes::DWI_MIMETYPE()
+{
+ return DwiMimeType();
}
CustomMimeType DiffusionIOMimeTypes::DTI_MIMETYPE()
{
CustomMimeType mimeType(DTI_MIMETYPE_NAME());
std::string category = "Tensor Images";
mimeType.SetComment("Diffusion Tensor Images");
mimeType.SetCategory(category);
mimeType.AddExtension("dti");
mimeType.AddExtension("hdti");
return mimeType;
}
CustomMimeType DiffusionIOMimeTypes::QBI_MIMETYPE()
{
CustomMimeType mimeType(QBI_MIMETYPE_NAME());
std::string category = "Q-Ball Images";
mimeType.SetComment("Diffusion Q-Ball Images");
mimeType.SetCategory(category);
mimeType.AddExtension("qbi");
mimeType.AddExtension("hqbi");
return mimeType;
}
CustomMimeType DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE()
{
CustomMimeType mimeType(CONNECTOMICS_MIMETYPE_NAME());
std::string category = "Connectomics Networks";
mimeType.SetComment("Connectomics Networks");
mimeType.SetCategory(category);
mimeType.AddExtension("cnf");
return mimeType;
}
// Names
std::string DiffusionIOMimeTypes::DWI_MIMETYPE_NAME()
{
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dwi";
return name;
}
std::string DiffusionIOMimeTypes::DTI_MIMETYPE_NAME()
{
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dti";
return name;
}
std::string DiffusionIOMimeTypes::QBI_MIMETYPE_NAME()
{
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".qbi";
return name;
}
std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_NAME()
{
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fib";
return name;
}
std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_NAME()
{
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".cnf";
return name;
}
// Descriptions
std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION()
{
static std::string description = "Fiberbundles";
return description;
}
std::string DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION()
{
static std::string description = "Diffusion Weighted Images";
return description;
}
std::string DiffusionIOMimeTypes::DTI_MIMETYPE_DESCRIPTION()
{
static std::string description = "Diffusion Tensor Images";
return description;
}
std::string DiffusionIOMimeTypes::QBI_MIMETYPE_DESCRIPTION()
{
static std::string description = "Q-Ball Images";
return description;
}
std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_DESCRIPTION()
{
static std::string description = "Connectomics Networks";
return description;
}
}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
index fa4b3c02fa..5caa50bd8c 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
@@ -1,72 +1,81 @@
/*===================================================================
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 MITKDIFFUSIONIOMIMETYPES_H
#define MITKDIFFUSIONIOMIMETYPES_H
#include "mitkCustomMimeType.h"
+#include <MitkDiffusionIOExports.h>
#include <string>
namespace mitk {
class DiffusionIOMimeTypes
{
public:
+ class MitkDiffusionIO_EXPORT DwiMimeType : public CustomMimeType
+ {
+ public:
+ DwiMimeType();
+ virtual bool AppliesTo(const std::string &path) const;
+ virtual DwiMimeType* Clone() const;
+ };
+
// Get all Diffusion Mime Types
static std::vector<CustomMimeType*> Get();
// ------------------------------ VTK formats ----------------------------------
static CustomMimeType FIBERBUNDLE_MIMETYPE(); // fib
static std::string FIBERBUNDLE_MIMETYPE_NAME();
static std::string FIBERBUNDLE_MIMETYPE_DESCRIPTION();
// ------------------------- Image formats (ITK based) --------------------------
- static CustomMimeType DWI_MIMETYPE(); // dwi, hdwi
+ static DwiMimeType DWI_MIMETYPE(); // dwi, hdwi
static CustomMimeType DTI_MIMETYPE(); // dti, hdti
static CustomMimeType QBI_MIMETYPE(); // qbi, hqbi
static std::string DWI_MIMETYPE_NAME();
static std::string DTI_MIMETYPE_NAME();
static std::string QBI_MIMETYPE_NAME();
static std::string DWI_MIMETYPE_DESCRIPTION();
static std::string DTI_MIMETYPE_DESCRIPTION();
static std::string QBI_MIMETYPE_DESCRIPTION();
// ------------------------------ MITK formats ----------------------------------
static CustomMimeType CONNECTOMICS_MIMETYPE(); // cnf
static std::string CONNECTOMICS_MIMETYPE_NAME();
static std::string CONNECTOMICS_MIMETYPE_DESCRIPTION();
private:
// purposely not implemented
DiffusionIOMimeTypes();
DiffusionIOMimeTypes(const DiffusionIOMimeTypes&);
};
}
#endif // MITKDIFFUSIONIOMIMETYPES_H
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.cpp
deleted file mode 100644
index 5e67c079e7..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*===================================================================
-
-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 "mitkDiffusionImageSerializer.h"
-#include "mitkDiffusionImage.h"
-#include "mitkNrrdDiffusionImageWriter.h"
-
-#include <itksys/SystemTools.hxx>
-
-
-MITK_REGISTER_SERIALIZER(DiffusionImageSerializer)
-
-
-mitk::DiffusionImageSerializer::DiffusionImageSerializer()
-{
-}
-
-
-mitk::DiffusionImageSerializer::~DiffusionImageSerializer()
-{
-}
-
-
-std::string mitk::DiffusionImageSerializer::Serialize()
-{
- const DiffusionImage<short>* image = dynamic_cast<const DiffusionImage<short>*>( m_Data.GetPointer() );
- if (image == NULL)
- {
- MITK_ERROR << " Object at " << (const void*) this->m_Data
- << " is not an mitk::DiffusionImage. Cannot serialize as DiffusionImage.";
- return "";
- }
-
- std::string filename( this->GetUniqueFilenameInWorkingDirectory() );
- filename += "_";
- filename += m_FilenameHint;
- filename += ".dwi";
-
- std::string fullname(m_WorkingDirectory);
- fullname += "/";
- fullname += itksys::SystemTools::ConvertToOutputPath(filename.c_str());
-
- try
- {
- NrrdDiffusionImageWriter writer;
- writer.SetOutputLocation(fullname);
- writer.SetInput(const_cast<DiffusionImage<short>*>(image));
- writer.Write();
- }
- catch (std::exception& e)
- {
- MITK_ERROR << " Error serializing object at " << (const void*) this->m_Data
- << " to "
- << fullname
- << ": "
- << e.what();
- return "";
- }
- return filename;
-}
-
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.h
deleted file mode 100644
index d1b4a593d0..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*===================================================================
-
-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 mitkDiffusionImageSerializer_h_included
-#define mitkDiffusionImageSerializer_h_included
-
-#include "mitkBaseDataSerializer.h"
-
-namespace mitk
-{
-/**
- \brief Serializes mitk::Surface for mitk::SceneIO
-*/
-class DiffusionImageSerializer : public BaseDataSerializer
-{
- public:
- mitkClassMacro( DiffusionImageSerializer, BaseDataSerializer );
- itkFactorylessNewMacro(Self)
- itkCloneMacro(Self)
- virtual std::string Serialize();
- protected:
- DiffusionImageSerializer();
- virtual ~DiffusionImageSerializer();
-};
-} // namespace
-#endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
index fd381448fa..bd86415a15 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
@@ -1,420 +1,434 @@
/*===================================================================
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 __mitkNrrdDiffusionImageReader_cpp
#define __mitkNrrdDiffusionImageReader_cpp
#include "mitkNrrdDiffusionImageReader.h"
+#include <iostream>
+#include <fstream>
+
+
+// Diffusion properties
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkBValueMapProperty.h>
+#include <mitkMeasurementFrameProperty.h>
+#include <mitkProperties.h>
+
+// ITK includes
+#include <itkImageRegionIterator.h>
+#include <itkMetaDataObject.h>
+#include "itksys/SystemTools.hxx"
#include "itkImageFileReader.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
#include "itkNiftiImageIO.h"
-#include <iostream>
-#include <fstream>
-
-#include "itksys/SystemTools.hxx"
#include "mitkCustomMimeType.h"
#include "mitkDiffusionIOMimeTypes.h"
-namespace mitk
-{
-
-NrrdDiffusionImageReader::
-NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other)
- : AbstractFileReader(other)
-{
-}
+#include <mitkITKImageImport.h>
+#include <mitkItkImageFileReader.h>
+#include <mitkImageWriteAccessor.h>
+#include <mitkImageDataItem.h>
+#include "mitkIOUtil.h"
-NrrdDiffusionImageReader* NrrdDiffusionImageReader::Clone() const
+namespace mitk
{
- return new NrrdDiffusionImageReader(*this);
-}
-
-NrrdDiffusionImageReader::
-~NrrdDiffusionImageReader()
-{}
+ NrrdDiffusionImageReader::
+ NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other)
+ : AbstractFileReader(other)
+ {
+ }
-NrrdDiffusionImageReader::
-NrrdDiffusionImageReader()
- : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION() )
-{
- m_ServiceReg = this->RegisterService();
-}
+ NrrdDiffusionImageReader* NrrdDiffusionImageReader::Clone() const
+ {
+ return new NrrdDiffusionImageReader(*this);
+ }
-std::vector<itk::SmartPointer<mitk::BaseData> >
-NrrdDiffusionImageReader::
-Read()
-{
- std::vector<itk::SmartPointer<mitk::BaseData> > result;
- // Since everything is completely read in GenerateOutputInformation() it is stored
- // in a cache variable. A timestamp is associated.
- // If the timestamp of the cache variable is newer than the MTime, we only need to
- // assign the cache variable to the DataObject.
- // Otherwise, the tree must be read again from the file and OuputInformation must
- // be updated!
+ NrrdDiffusionImageReader::
+ ~NrrdDiffusionImageReader()
+ {}
- if(m_OutputCache.IsNull()) InternalRead();
+ NrrdDiffusionImageReader::
+ NrrdDiffusionImageReader()
+ : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION() )
+ {
+ m_ServiceReg = this->RegisterService();
+ }
- OutputType::Pointer resultImage = OutputType::New();
- resultImage->SetVectorImage(m_OutputCache->GetVectorImage());
- resultImage->SetReferenceBValue(m_OutputCache->GetReferenceBValue());
- resultImage->SetMeasurementFrame(m_OutputCache->GetMeasurementFrame());
- resultImage->SetDirections(m_OutputCache->GetDirections());
- resultImage->InitializeFromVectorImage();
+ std::vector<itk::SmartPointer<mitk::BaseData> >
+ NrrdDiffusionImageReader::
+ Read()
+ {
+ std::vector<itk::SmartPointer<mitk::BaseData> > result;
- result.push_back(resultImage.GetPointer());
- return result;
-}
+ // Since everything is completely read in GenerateOutputInformation() it is stored
+ // in a cache variable. A timestamp is associated.
+ // If the timestamp of the cache variable is newer than the MTime, we only need to
+ // assign the cache variable to the DataObject.
+ // Otherwise, the tree must be read again from the file and OuputInformation must
+ // be updated!
+ if(m_OutputCache.IsNull()) InternalRead();
-void NrrdDiffusionImageReader::InternalRead()
-{
- OutputType::Pointer outputForCache = OutputType::New();
- if ( this->GetInputLocation() == "")
- {
- throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
+ result.push_back(m_OutputCache.GetPointer());
+ return result;
}
- else
+
+
+ void NrrdDiffusionImageReader::InternalRead()
{
- try
+ OutputType::Pointer outputForCache = OutputType::New();
+ if ( this->GetInputLocation() == "")
{
- const std::string& locale = "C";
- const std::string& currLocale = setlocale( LC_ALL, NULL );
-
- if ( locale.compare(currLocale)!=0 )
+ throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
+ }
+ else
+ {
+ try
{
- try
+ const std::string& locale = "C";
+ const std::string& currLocale = setlocale( LC_ALL, NULL );
+
+ if ( locale.compare(currLocale)!=0 )
{
- setlocale(LC_ALL, locale.c_str());
+ try
+ {
+ setlocale(LC_ALL, locale.c_str());
+ }
+ catch(...)
+ {
+ MITK_INFO << "Could not set locale " << locale;
+ }
}
- catch(...)
+
+
+ MITK_INFO << "NrrdDiffusionImageReader: reading image information";
+ VectorImageType::Pointer itkVectorImage;
+
+ std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetInputLocation());
+ ext = itksys::SystemTools::LowerCase(ext);
+ if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
{
- MITK_INFO << "Could not set locale " << locale;
+ typedef itk::ImageFileReader<VectorImageType> FileReaderType;
+ FileReaderType::Pointer reader = FileReaderType::New();
+ reader->SetFileName(this->GetInputLocation());
+ itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+ reader->SetImageIO(io);
+ reader->Update();
+ itkVectorImage = reader->GetOutput();
}
- }
+ else if(ext == ".fsl" || ext == ".fslgz")
+ {
+ // create temporary file with correct ending for nifti-io
+ std::string fname3 = "temp_dwi";
+ fname3 += ext == ".fsl" ? ".nii" : ".nii.gz";
+ itksys::SystemTools::CopyAFile(this->GetInputLocation().c_str(), fname3.c_str());
+
+ // create reader and read file
+ typedef itk::Image<DiffusionPixelType,4> ImageType4D;
+ itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
+ typedef itk::ImageFileReader<ImageType4D> FileReaderType;
+ FileReaderType::Pointer reader = FileReaderType::New();
+ reader->SetFileName(fname3);
+ reader->SetImageIO(io2);
+ reader->Update();
+ ImageType4D::Pointer img4 = reader->GetOutput();
+
+ // delete temporary file
+ itksys::SystemTools::RemoveFile(fname3.c_str());
+
+ // convert 4D file to vector image
+ itkVectorImage = VectorImageType::New();
+
+ VectorImageType::SpacingType spacing;
+ ImageType4D::SpacingType spacing4 = img4->GetSpacing();
+ for(int i=0; i<3; i++)
+ spacing[i] = spacing4[i];
+ itkVectorImage->SetSpacing( spacing ); // Set the image spacing
+ VectorImageType::PointType origin;
+ ImageType4D::PointType origin4 = img4->GetOrigin();
+ for(int i=0; i<3; i++)
+ origin[i] = origin4[i];
+ itkVectorImage->SetOrigin( origin ); // Set the image origin
- MITK_INFO << "NrrdDiffusionImageReader: reading image information";
- ImageType::Pointer img;
+ VectorImageType::DirectionType direction;
+ ImageType4D::DirectionType direction4 = img4->GetDirection();
+ for(int i=0; i<3; i++)
+ for(int j=0; j<3; j++)
+ direction[i][j] = direction4[i][j];
+ itkVectorImage->SetDirection( direction ); // Set the image direction
- std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetInputLocation());
- ext = itksys::SystemTools::LowerCase(ext);
- if (ext == ".hdwi" || ext == ".dwi")
- {
- typedef itk::ImageFileReader<ImageType> FileReaderType;
- FileReaderType::Pointer reader = FileReaderType::New();
- reader->SetFileName(this->GetInputLocation());
- itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
- reader->SetImageIO(io);
- reader->Update();
- img = reader->GetOutput();
+ VectorImageType::RegionType region;
+ ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
- int vecsize = img->GetVectorLength();
- std::cout << vecsize << std::endl;
+ VectorImageType::RegionType::SizeType size;
+ ImageType4D::RegionType::SizeType size4 = region4.GetSize();
+ for(int i=0; i<3; i++)
+ size[i] = size4[i];
- }
- else if(ext == ".fsl" || ext == ".fslgz")
- {
- // create temporary file with correct ending for nifti-io
- std::string fname3 = "temp_dwi";
- fname3 += ext == ".fsl" ? ".nii" : ".nii.gz";
- itksys::SystemTools::CopyAFile(this->GetInputLocation().c_str(), fname3.c_str());
-
- // create reader and read file
- typedef itk::Image<short,4> ImageType4D;
- itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
- typedef itk::ImageFileReader<ImageType4D> FileReaderType;
- FileReaderType::Pointer reader = FileReaderType::New();
- reader->SetFileName(fname3);
- reader->SetImageIO(io2);
- reader->Update();
- ImageType4D::Pointer img4 = reader->GetOutput();
-
- // delete temporary file
- itksys::SystemTools::RemoveFile(fname3.c_str());
-
- // convert 4D file to vector image
- img = ImageType::New();
-
- ImageType::SpacingType spacing;
- ImageType4D::SpacingType spacing4 = img4->GetSpacing();
- for(int i=0; i<3; i++)
- spacing[i] = spacing4[i];
- img->SetSpacing( spacing ); // Set the image spacing
-
- ImageType::PointType origin;
- ImageType4D::PointType origin4 = img4->GetOrigin();
- for(int i=0; i<3; i++)
- origin[i] = origin4[i];
- img->SetOrigin( origin ); // Set the image origin
-
- ImageType::DirectionType direction;
- ImageType4D::DirectionType direction4 = img4->GetDirection();
- for(int i=0; i<3; i++)
- for(int j=0; j<3; j++)
- direction[i][j] = direction4[i][j];
- img->SetDirection( direction ); // Set the image direction
-
- ImageType::RegionType region;
- ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
-
- ImageType::RegionType::SizeType size;
- ImageType4D::RegionType::SizeType size4 = region4.GetSize();
-
- for(int i=0; i<3; i++)
- size[i] = size4[i];
-
- ImageType::RegionType::IndexType index;
- ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
- for(int i=0; i<3; i++)
- index[i] = index4[i];
-
- region.SetSize(size);
- region.SetIndex(index);
- img->SetRegions( region );
-
- img->SetVectorLength(size4[3]);
- img->Allocate();
-
- itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
- typedef ImageType::PixelType VecPixType;
- for (it.GoToBegin(); !it.IsAtEnd(); ++it)
- {
- VecPixType vec = it.Get();
- ImageType::IndexType currentIndex = it.GetIndex();
+ VectorImageType::RegionType::IndexType index;
+ ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
for(int i=0; i<3; i++)
- index4[i] = currentIndex[i];
- for(unsigned int ind=0; ind<vec.Size(); ind++)
+ index[i] = index4[i];
+
+ region.SetSize(size);
+ region.SetIndex(index);
+ itkVectorImage->SetRegions( region );
+
+ itkVectorImage->SetVectorLength(size4[3]);
+ itkVectorImage->Allocate();
+
+ itk::ImageRegionIterator<VectorImageType> it ( itkVectorImage, itkVectorImage->GetLargestPossibleRegion() );
+ typedef VectorImageType::PixelType VecPixType;
+ for (it.GoToBegin(); !it.IsAtEnd(); ++it)
{
- index4[3] = ind;
- vec[ind] = img4->GetPixel(index4);
+ VecPixType vec = it.Get();
+ VectorImageType::IndexType currentIndex = it.GetIndex();
+ for(int i=0; i<3; i++)
+ index4[i] = currentIndex[i];
+ for(unsigned int ind=0; ind<vec.Size(); ind++)
+ {
+ index4[3] = ind;
+ vec[ind] = img4->GetPixel(index4);
+ }
+ it.Set(vec);
}
- it.Set(vec);
}
- }
- m_DiffusionVectors = GradientDirectionContainerType::New();
- m_OriginalDiffusionVectors = GradientDirectionContainerType::New();
- if (ext == ".hdwi" || ext == ".dwi")
- {
+ // Diffusion Image information START
+ GradientDirectionContainerType::Pointer DiffusionVectors = GradientDirectionContainerType::New();
+ GradientDirectionContainerType::Pointer OriginalDiffusionVectors = GradientDirectionContainerType::New();
+ MeasurementFrameType MeasurementFrame;
+ float BValue = -1;
+ // Diffusion Image information END
- itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
- std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
- std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
- std::string metaString;
+ if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
+ {
- GradientDirectionType vect3d;
+ itk::MetaDataDictionary imgMetaDictionary = itkVectorImage->GetMetaDataDictionary();
+ std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+ std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+ std::string metaString;
- int numberOfImages = 0;
- int numberOfGradientImages = 0;
- bool readb0 = false;
- double xx, xy, xz, yx, yy, yz, zx, zy, zz;
+ GradientDirectionType vect3d;
- for (; itKey != imgMetaKeys.end(); itKey ++)
- {
- double x,y,z;
+ int numberOfImages = 0;
+ int numberOfGradientImages = 0;
+ bool readb0 = false;
+ double xx, xy, xz, yx, yy, yz, zx, zy, zz;
- itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
- if (itKey->find("DWMRI_gradient") != std::string::npos)
+ for (; itKey != imgMetaKeys.end(); itKey ++)
{
- sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
- vect3d[0] = x; vect3d[1] = y; vect3d[2] = z;
- m_DiffusionVectors->InsertElement( numberOfImages, vect3d );
- ++numberOfImages;
- // If the direction is 0.0, this is a reference image
- if (vect3d[0] == 0.0 &&
- vect3d[1] == 0.0 &&
- vect3d[2] == 0.0)
+ double x,y,z;
+
+ itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+ if (itKey->find("DWMRI_gradient") != std::string::npos)
{
- continue;
+ sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
+ vect3d[0] = x; vect3d[1] = y; vect3d[2] = z;
+ DiffusionVectors->InsertElement( numberOfImages, vect3d );
+ ++numberOfImages;
+ // If the direction is 0.0, this is a reference image
+ if (vect3d[0] == 0.0 &&
+ vect3d[1] == 0.0 &&
+ vect3d[2] == 0.0)
+ {
+ continue;
+ }
+ ++numberOfGradientImages;;
}
- ++numberOfGradientImages;;
- }
- else if (itKey->find("DWMRI_b-value") != std::string::npos)
- {
- readb0 = true;
- m_B_Value = atof(metaString.c_str());
- }
- else if (itKey->find("measurement frame") != std::string::npos)
- {
- sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
-
- if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
- yx>10e-10 || yy>10e-10 || yz>10e-10 ||
- zx>10e-10 || zy>10e-10 || zz>10e-10 )
+ else if (itKey->find("DWMRI_b-value") != std::string::npos)
{
- m_MeasurementFrame(0,0) = xx;
- m_MeasurementFrame(0,1) = xy;
- m_MeasurementFrame(0,2) = xz;
- m_MeasurementFrame(1,0) = yx;
- m_MeasurementFrame(1,1) = yy;
- m_MeasurementFrame(1,2) = yz;
- m_MeasurementFrame(2,0) = zx;
- m_MeasurementFrame(2,1) = zy;
- m_MeasurementFrame(2,2) = zz;
+ readb0 = true;
+ BValue = atof(metaString.c_str());
}
- else
+ else if (itKey->find("measurement frame") != std::string::npos)
{
- m_MeasurementFrame(0,0) = 1;
- m_MeasurementFrame(0,1) = 0;
- m_MeasurementFrame(0,2) = 0;
- m_MeasurementFrame(1,0) = 0;
- m_MeasurementFrame(1,1) = 1;
- m_MeasurementFrame(1,2) = 0;
- m_MeasurementFrame(2,0) = 0;
- m_MeasurementFrame(2,1) = 0;
- m_MeasurementFrame(2,2) = 1;
+ sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
+
+ if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
+ yx>10e-10 || yy>10e-10 || yz>10e-10 ||
+ zx>10e-10 || zy>10e-10 || zz>10e-10 )
+ {
+ MeasurementFrame(0,0) = xx;
+ MeasurementFrame(0,1) = xy;
+ MeasurementFrame(0,2) = xz;
+ MeasurementFrame(1,0) = yx;
+ MeasurementFrame(1,1) = yy;
+ MeasurementFrame(1,2) = yz;
+ MeasurementFrame(2,0) = zx;
+ MeasurementFrame(2,1) = zy;
+ MeasurementFrame(2,2) = zz;
+ }
+ else
+ {
+ MeasurementFrame(0,0) = 1;
+ MeasurementFrame(0,1) = 0;
+ MeasurementFrame(0,2) = 0;
+ MeasurementFrame(1,0) = 0;
+ MeasurementFrame(1,1) = 1;
+ MeasurementFrame(1,2) = 0;
+ MeasurementFrame(2,0) = 0;
+ MeasurementFrame(2,1) = 0;
+ MeasurementFrame(2,2) = 1;
+ }
}
}
- }
-
- if(!readb0)
- {
- MITK_INFO << "BValue not specified in header file";
- }
- }
- else if(ext == ".fsl" || ext == ".fslgz")
- {
+ if(!readb0)
+ {
+ MITK_INFO << "BValue not specified in header file";
+ }
- std::string line;
- std::vector<float> bvec_entries;
- std::string fname = this->GetInputLocation();
- fname += ".bvecs";
- std::ifstream myfile (fname.c_str());
- if (myfile.is_open())
+ }
+ else if(ext == ".fsl" || ext == ".fslgz")
{
- while ( myfile.good() )
+
+ std::string line;
+ std::vector<float> bvec_entries;
+ std::string fname = this->GetInputLocation();
+ fname += ".bvecs";
+ std::ifstream myfile (fname.c_str());
+ if (myfile.is_open())
{
- getline (myfile,line);
- char* pch = strtok (const_cast<char*>(line.c_str())," ");
- while (pch != NULL)
+ while ( myfile.good() )
{
- bvec_entries.push_back(atof(pch));
- pch = strtok (NULL, " ");
+ getline (myfile,line);
+ char* pch = strtok (const_cast<char*>(line.c_str())," ");
+ while (pch != NULL)
+ {
+ bvec_entries.push_back(atof(pch));
+ pch = strtok (NULL, " ");
+ }
}
+ myfile.close();
+ }
+ else
+ {
+ MITK_INFO << "Unable to open bvecs file";
}
- myfile.close();
- }
- else
- {
- MITK_INFO << "Unable to open bvecs file";
- }
- std::vector<float> bval_entries;
- std::string fname2 = this->GetInputLocation();
- fname2 += ".bvals";
- std::ifstream myfile2 (fname2.c_str());
- if (myfile2.is_open())
- {
- while ( myfile2.good() )
+ std::vector<float> bval_entries;
+ std::string fname2 = this->GetInputLocation();
+ fname2 += ".bvals";
+ std::ifstream myfile2 (fname2.c_str());
+ if (myfile2.is_open())
{
- getline (myfile2,line);
- char* pch = strtok (const_cast<char*>(line.c_str())," ");
- while (pch != NULL)
+ while ( myfile2.good() )
{
- bval_entries.push_back(atof(pch));
- pch = strtok (NULL, " ");
+ getline (myfile2,line);
+ char* pch = strtok (const_cast<char*>(line.c_str())," ");
+ while (pch != NULL)
+ {
+ bval_entries.push_back(atof(pch));
+ pch = strtok (NULL, " ");
+ }
}
+ myfile2.close();
+ }
+ else
+ {
+ MITK_INFO << "Unable to open bvals file";
}
- myfile2.close();
- }
- else
- {
- MITK_INFO << "Unable to open bvals file";
- }
-
- m_B_Value = -1;
- unsigned int numb = bval_entries.size();
- for(unsigned int i=0; i<numb; i++)
- {
- // Take the first entry in bvals as the reference b-value
- if(m_B_Value == -1 && bval_entries.at(i) != 0)
+ BValue = -1;
+ unsigned int numb = bval_entries.size();
+ for(unsigned int i=0; i<numb; i++)
{
- m_B_Value = bval_entries.at(i);
- }
- float b_val = bval_entries.at(i);
+ // Take the first entry in bvals as the reference b-value
+ if(BValue == -1 && bval_entries.at(i) != 0)
+ {
+ BValue = bval_entries.at(i);
+ }
+ float b_val = bval_entries.at(i);
- vnl_vector_fixed< double, 3 > vec;
- vec[0] = bvec_entries.at(i);
- vec[1] = bvec_entries.at(i+numb);
- vec[2] = bvec_entries.at(i+2*numb);
- // Adjust the vector length to encode gradient strength
- float factor = b_val/m_B_Value;
- if(vec.magnitude() > 0)
- {
- vec[0] = sqrt(factor)*vec[0];
- vec[1] = sqrt(factor)*vec[1];
- vec[2] = sqrt(factor)*vec[2];
+ vnl_vector_fixed< double, 3 > vec;
+ vec[0] = bvec_entries.at(i);
+ vec[1] = bvec_entries.at(i+numb);
+ vec[2] = bvec_entries.at(i+2*numb);
+
+ // Adjust the vector length to encode gradient strength
+ float factor = b_val/BValue;
+ if(vec.magnitude() > 0)
+ {
+ vec[0] = sqrt(factor)*vec[0];
+ vec[1] = sqrt(factor)*vec[1];
+ vec[2] = sqrt(factor)*vec[2];
+ }
+
+ DiffusionVectors->InsertElement(i,vec);
}
- m_DiffusionVectors->InsertElement(i,vec);
+ for(int i=0; i<3; i++)
+ for(int j=0; j<3; j++)
+ MeasurementFrame[i][j] = i==j ? 1 : 0;
}
- for(int i=0; i<3; i++)
- for(int j=0; j<3; j++)
- m_MeasurementFrame[i][j] = i==j ? 1 : 0;
- }
+ outputForCache = mitk::GrabItkImageMemory( itkVectorImage);
- outputForCache->SetVectorImage(img);
- outputForCache->SetReferenceBValue(m_B_Value);
- outputForCache->SetMeasurementFrame(m_MeasurementFrame);
- outputForCache->SetDirections(m_DiffusionVectors);
+ // create BValueMap
+ mitk::BValueMapProperty::BValueMap BValueMap = mitk::BValueMapProperty::CreateBValueMap(DiffusionVectors,BValue);
+ outputForCache->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( DiffusionVectors ) );
+ outputForCache->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( OriginalDiffusionVectors ) );
+ outputForCache->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( MeasurementFrame ) );
+ outputForCache->SetProperty( mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(), mitk::BValueMapProperty::New( BValueMap ) );
+ outputForCache->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( BValue ) );
- // Since we have already read the tree, we can store it in a cache variable
- // so that it can be assigned to the DataObject in GenerateData();
- m_OutputCache = outputForCache;
- m_CacheTime.Modified();
+ // Since we have already read the tree, we can store it in a cache variable
+ // so that it can be assigned to the DataObject in GenerateData();
+ m_OutputCache = outputForCache;
+ m_CacheTime.Modified();
- try
+ try
+ {
+ setlocale(LC_ALL, currLocale.c_str());
+ }
+ catch(...)
+ {
+ MITK_INFO << "Could not reset locale " << currLocale;
+ }
+ }
+ catch(std::exception& e)
{
- setlocale(LC_ALL, currLocale.c_str());
+ MITK_INFO << "Std::Exception while reading file!!";
+ MITK_INFO << e.what();
+ throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
- MITK_INFO << "Could not reset locale " << currLocale;
+ MITK_INFO << "Exception while reading file!!";
+ throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
}
}
- catch(std::exception& e)
- {
- MITK_INFO << "Std::Exception while reading file!!";
- MITK_INFO << e.what();
- throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
- }
- catch(...)
- {
- MITK_INFO << "Exception while reading file!!";
- throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
- }
}
-}
} //namespace MITK
#endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
index f7c10669af..ac1fb1d29c 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
@@ -1,72 +1,73 @@
/*===================================================================
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 __mitkNrrdDiffusionImageReader_h
#define __mitkNrrdDiffusionImageReader_h
#include "mitkCommon.h"
-#include "itkVectorContainer.h"
+
+// MITK includes
+#include "mitkImageSource.h"
#include "mitkFileReader.h"
-#include "vnl/vnl_vector_fixed.h"
-#include "vnl/vnl_matrix_fixed.h"
+#include <mitkDiffusionPropertyHelper.h>
+
+// ITK includes
#include "itkVectorImage.h"
#include "mitkAbstractFileReader.h"
-#include "mitkDiffusionImage.h"
+
+
namespace mitk
{
/** \brief
*/
class NrrdDiffusionImageReader : public mitk::AbstractFileReader
{
public:
NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other);
NrrdDiffusionImageReader();
virtual ~NrrdDiffusionImageReader();
using AbstractFileReader::Read;
virtual std::vector<itk::SmartPointer<BaseData> > Read();
- typedef mitk::DiffusionImage<short> OutputType;
- typedef itk::VectorImage<short,3> ImageType;
- typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
- typedef vnl_matrix_fixed< double, 3, 3 > MeasurementFrameType;
- typedef itk::VectorContainer< unsigned int,GradientDirectionType > GradientDirectionContainerType;
+ typedef short DiffusionPixelType;
+
+ typedef mitk::Image OutputType;
+ typedef mitk::DiffusionPropertyHelper::ImageType VectorImageType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::MeasurementFrameType MeasurementFrameType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
protected:
OutputType::Pointer m_OutputCache;
itk::TimeStamp m_CacheTime;
- GradientDirectionContainerType::Pointer m_OriginalDiffusionVectors;
- GradientDirectionContainerType::Pointer m_DiffusionVectors;
- float m_B_Value;
- MeasurementFrameType m_MeasurementFrame;
void InternalRead();
private:
NrrdDiffusionImageReader* Clone() const;
us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
};
} //namespace MITK
-
#endif // __mitkNrrdDiffusionImageReader_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
index d9f7f745ba..94f152f17f 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
@@ -1,326 +1,332 @@
/*===================================================================
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 __mitkNrrdDiffusionImageWriter__cpp
#define __mitkNrrdDiffusionImageWriter__cpp
#include "mitkNrrdDiffusionImageWriter.h"
#include "itkMetaDataDictionary.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
#include "itkNiftiImageIO.h"
#include "itkImageFileWriter.h"
#include "itksys/SystemTools.hxx"
#include "mitkDiffusionIOMimeTypes.h"
+#include "mitkImageCast.h"
#include <iostream>
#include <fstream>
mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter()
- : AbstractFileWriter(mitk::DiffusionImage<short>::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION())
+ : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION())
{
RegisterService();
}
mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter(const mitk::NrrdDiffusionImageWriter& other)
: AbstractFileWriter(other)
{
}
mitk::NrrdDiffusionImageWriter::~NrrdDiffusionImageWriter()
{}
void mitk::NrrdDiffusionImageWriter::Write()
{
- InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
+ mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
+
+ VectorImageType::Pointer itkImg;
+ mitk::CastToItkImage(input,itkImg);
+
if (input.IsNull())
{
MITK_ERROR <<"Sorry, input to NrrdDiffusionImageWriter is NULL!";
return;
}
if ( this->GetOutputLocation().empty() )
{
MITK_ERROR << "Sorry, filename has not been set!";
return ;
}
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
char keybuffer[512];
char valbuffer[512];
//itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
- vnl_matrix_fixed<double,3,3> measurementFrame = input->GetMeasurementFrame();
+ vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
{
sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
- itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
+ itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
}
sprintf( valbuffer, "DWMRI");
- itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
+ itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
- if(input->GetDirections()->Size())
+ if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
{
- sprintf( valbuffer, "%1f", input->GetReferenceBValue() );
- itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
+ sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
+ itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
}
- for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+ for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
{
sprintf( keybuffer, "DWMRI_gradient_%04d", i );
/*if(itk::ExposeMetaData<std::string>(input->GetMetaDataDictionary(),
std::string(keybuffer),tmp))
continue;*/
- sprintf( valbuffer, "%1f %1f %1f", input->GetDirections()->ElementAt(i).get(0),
- input->GetDirections()->ElementAt(i).get(1), input->GetDirections()->ElementAt(i).get(2));
+ sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
+ mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
- itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
+ itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
}
typedef itk::VectorImage<short,3> ImageType;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation());
ext = itksys::SystemTools::LowerCase(ext);
// default extension is .dwi
if( ext == "")
{
- ext = ".dwi";
+ ext = ".nrrd";
this->SetOutputLocation(this->GetOutputLocation() + ext);
}
- if (ext == ".hdwi" || ext == ".dwi")
+ if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
{
+
+ MITK_INFO << "Extension " << ext;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
//io->SetNrrdVectorType( nrrdKindList );
io->SetFileType( itk::ImageIOBase::Binary );
io->UseCompressionOn();
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer nrrdWriter = WriterType::New();
nrrdWriter->UseInputMetaDataDictionaryOn();
- nrrdWriter->SetInput( input->GetVectorImage() );
+ nrrdWriter->SetInput( itkImg );
nrrdWriter->SetImageIO(io);
nrrdWriter->SetFileName(this->GetOutputLocation());
nrrdWriter->UseCompressionOn();
nrrdWriter->SetImageIO(io);
try
{
nrrdWriter->Update();
}
catch (itk::ExceptionObject e)
{
std::cout << e << std::endl;
throw;
}
}
else if (ext == ".fsl" || ext == ".fslgz")
{
MITK_INFO << "Writing Nifti-Image for FSL";
- ImageType::Pointer vecimg = input->GetVectorImage();
typedef itk::Image<short,4> ImageType4D;
ImageType4D::Pointer img4 = ImageType4D::New();
- ImageType::SpacingType spacing = vecimg->GetSpacing();
+ ImageType::SpacingType spacing = itkImg->GetSpacing();
ImageType4D::SpacingType spacing4;
for(int i=0; i<3; i++)
spacing4[i] = spacing[i];
spacing4[3] = 1;
img4->SetSpacing( spacing4 ); // Set the image spacing
- ImageType::PointType origin = vecimg->GetOrigin();
+ ImageType::PointType origin = itkImg->GetOrigin();
ImageType4D::PointType origin4;
for(int i=0; i<3; i++)
origin4[i] = origin[i];
origin4[3] = 0;
img4->SetOrigin( origin4 ); // Set the image origin
- ImageType::DirectionType direction = vecimg->GetDirection();
+ ImageType::DirectionType direction = itkImg->GetDirection();
ImageType4D::DirectionType direction4;
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
direction4[i][j] = direction[i][j];
for(int i=0; i<4; i++)
direction4[i][3] = 0;
for(int i=0; i<4; i++)
direction4[3][i] = 0;
direction4[3][3] = 1;
img4->SetDirection( direction4 ); // Set the image direction
- ImageType::RegionType region = vecimg->GetLargestPossibleRegion();
+ ImageType::RegionType region = itkImg->GetLargestPossibleRegion();
ImageType4D::RegionType region4;
ImageType::RegionType::SizeType size = region.GetSize();
ImageType4D::RegionType::SizeType size4;
for(int i=0; i<3; i++)
size4[i] = size[i];
- size4[3] = vecimg->GetVectorLength();
+ size4[3] = itkImg->GetVectorLength();
ImageType::RegionType::IndexType index = region.GetIndex();
ImageType4D::RegionType::IndexType index4;
for(int i=0; i<3; i++)
index4[i] = index[i];
index4[3] = 0;
region4.SetSize(size4);
region4.SetIndex(index4);
img4->SetRegions( region4 );
img4->Allocate();
- itk::ImageRegionIterator<ImageType> it (vecimg, vecimg->GetLargestPossibleRegion() );
+ itk::ImageRegionIterator<ImageType> it (itkImg, itkImg->GetLargestPossibleRegion() );
typedef ImageType::PixelType VecPixType;
for (it.GoToBegin(); !it.IsAtEnd(); ++it)
{
VecPixType vec = it.Get();
ImageType::IndexType currentIndex = it.GetIndex();
for(unsigned int ind=0; ind<vec.Size(); ind++)
{
for(int i=0; i<3; i++)
index4[i] = currentIndex[i];
index4[3] = ind;
img4->SetPixel(index4, vec[ind]);
}
}
// create copy of file with correct ending for mitk
std::string fname3 = this->GetOutputLocation();
std::string::iterator itend = fname3.end();
if (ext == ".fsl")
fname3.replace( itend-3, itend, "nii");
else
fname3.replace( itend-5, itend, "nii.gz");
itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
typedef itk::VectorImage<short,3> ImageType;
typedef itk::ImageFileWriter<ImageType4D> WriterType4;
WriterType4::Pointer nrrdWriter4 = WriterType4::New();
nrrdWriter4->UseInputMetaDataDictionaryOn();
nrrdWriter4->SetInput( img4 );
nrrdWriter4->SetFileName(fname3);
nrrdWriter4->UseCompressionOn();
nrrdWriter4->SetImageIO(io4);
try
{
nrrdWriter4->Update();
}
catch (itk::ExceptionObject e)
{
std::cout << e << std::endl;
throw;
}
itksys::SystemTools::CopyAFile(fname3.c_str(), this->GetOutputLocation().c_str());
- if(input->GetDirections()->Size())
+ if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
{
std::ofstream myfile;
std::string fname = this->GetOutputLocation();
fname += ".bvals";
myfile.open (fname.c_str());
- for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+ for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
{
- double twonorm = input->GetDirections()->ElementAt(i).two_norm();
- myfile << input->GetReferenceBValue()*twonorm*twonorm << " ";
+ double twonorm = mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).two_norm();
+ myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
}
myfile.close();
std::ofstream myfile2;
std::string fname2 = this->GetOutputLocation();
fname2 += ".bvecs";
myfile2.open (fname2.c_str());
for(int j=0; j<3; j++)
{
- for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+ for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
{
//need to modify the length
- mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer grads = input->GetDirections();
- mitk::DiffusionImage<short>::GradientDirectionType direction = grads->ElementAt(i);
+ GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetGradientContainer(input);
+ GradientDirectionType direction = grads->ElementAt(i);
direction.normalize();
myfile2 << direction.get(j) << " ";
//myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
}
myfile2 << std::endl;
}
std::ofstream myfile3;
std::string fname4 = this->GetOutputLocation();
fname4 += ".ttk";
myfile3.open (fname4.c_str());
- for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+ for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
{
for(int j=0; j<3; j++)
{
- myfile3 << input->GetDirections()->ElementAt(i).get(j) << " ";
+ myfile3 << mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(j) << " ";
}
myfile3 << std::endl;
}
}
}
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
mitk::NrrdDiffusionImageWriter* mitk::NrrdDiffusionImageWriter::Clone() const
{
return new NrrdDiffusionImageWriter(*this);
}
mitk::IFileWriter::ConfidenceLevel mitk::NrrdDiffusionImageWriter::GetConfidenceLevel() const
{
- InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
+ mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
if (input.IsNull() )
{
return Unsupported;
}
else
{
return Supported;
}
}
#endif //__mitkNrrdDiffusionImageWriter__cpp
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
index 072621a361..1bedf714ce 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
@@ -1,55 +1,58 @@
/*===================================================================
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 _MITK_NRRDDIFFVOL_WRITER__H_
#define _MITK_NRRDDIFFVOL_WRITER__H_
#include <mitkAbstractFileWriter.h>
-#include <mitkDiffusionImage.h>
+#include <mitkDiffusionPropertyHelper.h>
namespace mitk
{
/**
* Writes diffusion volumes to a file
* @ingroup Process
*/
class NrrdDiffusionImageWriter : public mitk::AbstractFileWriter
{
public:
- typedef mitk::DiffusionImage<short> InputType;
-
NrrdDiffusionImageWriter();
virtual ~NrrdDiffusionImageWriter();
using AbstractFileWriter::Write;
virtual void Write();
virtual ConfidenceLevel GetConfidenceLevel() const;
+ typedef mitk::DiffusionPropertyHelper::ImageType VectorImageType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::MeasurementFrameType MeasurementFrameType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
+
protected:
NrrdDiffusionImageWriter(const NrrdDiffusionImageWriter& other);
virtual mitk::NrrdDiffusionImageWriter* Clone() const;
};
} // end of namespace mitk
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
index aa56645ad8..c284489d44 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,132 +1,131 @@
/*===================================================================
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 __itkTractsToDWIImageFilter_h__
#define __itkTractsToDWIImageFilter_h__
#include <mitkFiberBundleX.h>
#include <itkVnlForwardFFTImageFilter.h>
#include <itkVectorImage.h>
#include <cmath>
#include <mitkFiberfoxParameters.h>
#include <itkTimeProbe.h>
#include <mitkRawShModel.h>
-#include <mitkDiffusionImage.h>
#include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
namespace itk
{
/**
* \brief Generates artificial diffusion weighted image volume from the input fiberbundle using a generic multicompartment model.
* See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
*/
template< class PixelType >
class TractsToDWIImageFilter : public ImageSource< itk::VectorImage< PixelType, 3 > >
{
public:
typedef TractsToDWIImageFilter Self;
typedef ImageSource< itk::VectorImage< PixelType, 3 > > Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef typename Superclass::OutputImageType OutputImageType;
typedef itk::Image<double, 3> ItkDoubleImgType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef mitk::FiberBundleX::Pointer FiberBundleType;
typedef itk::VectorImage< double, 3 > DoubleDwiType;
typedef itk::Matrix<double, 3, 3> MatrixType;
typedef itk::Image< double, 2 > SliceType;
typedef itk::VnlForwardFFTImageFilter<SliceType>::OutputImageType ComplexSliceType;
typedef itk::Vector< double,3> DoubleVectorType;
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkTypeMacro( TractsToDWIImageFilter, ImageSource )
/** Input */
itkSetMacro( FiberBundle, FiberBundleType ) ///< Input fiber bundle
itkSetMacro( UseConstantRandSeed, bool ) ///< Seed for random generator.
void SetParameters( FiberfoxParameters<double> param ) ///< Simulation parameters.
{ m_Parameters = param; }
/** Output */
FiberfoxParameters<double> GetParameters(){ return m_Parameters; }
std::vector< ItkDoubleImgType::Pointer > GetVolumeFractions() ///< one double image for each compartment containing the corresponding volume fraction per voxel
{ return m_VolumeFractions; }
mitk::LevelWindow GetLevelWindow(){ return m_LevelWindow; }
itkGetMacro( StatusText, std::string )
void GenerateData();
protected:
TractsToDWIImageFilter();
virtual ~TractsToDWIImageFilter();
itk::Point<float, 3> GetItkPoint(double point[3]);
itk::Vector<double, 3> GetItkVector(double point[3]);
vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
vnl_vector_fixed<double, 3> GetVnlVector(Vector< float, 3 >& vector);
double RoundToNearest(double num);
std::string GetTime();
/** Transform generated image compartment by compartment, channel by channel and slice by slice using DFT and add k-space artifacts. */
DoubleDwiType::Pointer DoKspaceStuff(std::vector< DoubleDwiType::Pointer >& images);
/** Generate signal of non-fiber compartments. */
void SimulateNonFiberSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g=-1);
/** Move fibers to simulate headmotion */
void SimulateMotion(int g=-1);
// input
mitk::FiberfoxParameters<double> m_Parameters;
FiberBundleType m_FiberBundle;
// output
mitk::LevelWindow m_LevelWindow;
std::vector< ItkDoubleImgType::Pointer > m_VolumeFractions;
std::string m_StatusText;
// MISC
itk::TimeProbe m_TimeProbe;
bool m_UseConstantRandSeed;
bool m_MaskImageSet;
ofstream m_Logfile;
// signal generation
FiberBundleType m_FiberBundleWorkingCopy; ///< we work on an upsampled version of the input bundle
FiberBundleType m_FiberBundleTransformed; ///< transformed bundle simulating headmotion
itk::Vector<double,3> m_UpsampledSpacing;
itk::Point<double,3> m_UpsampledOrigin;
ImageRegion<3> m_UpsampledImageRegion;
double m_VoxelVolume;
std::vector< DoubleDwiType::Pointer > m_CompartmentImages;
ItkUcharImgType::Pointer m_MaskImage; ///< copy of mask image (changes for each motion step)
ItkUcharImgType::Pointer m_UpsampledMaskImage; ///< helper image for motion simulation
DoubleVectorType m_Rotation;
DoubleVectorType m_Translation;
itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTractsToDWIImageFilter.cpp"
#endif
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
index 99f598474c..5cd056a4b6 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
@@ -1,176 +1,177 @@
/*===================================================================
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 _MITK_FiberBundleX_H
#define _MITK_FiberBundleX_H
//includes for MITK datastructure
#include <mitkBaseData.h>
#include <MitkFiberTrackingExports.h>
#include <mitkImage.h>
//includes storing fiberdata
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkDataSet.h>
#include <vtkTransform.h>
//#include <QStringList>
#include <mitkPlanarFigure.h>
#include <mitkPixelTypeTraits.h>
#include <mitkPlanarFigureComposite.h>
+
namespace mitk {
/**
* \brief Base Class for Fiber Bundles; */
class MitkFiberTracking_EXPORT FiberBundleX : public BaseData
{
public:
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
// fiber colorcodings
static const char* COLORCODING_ORIENTATION_BASED;
static const char* COLORCODING_FA_BASED;
static const char* COLORCODING_CUSTOM;
static const char* FIBER_ID_ARRAY;
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
virtual void SetRequestedRegion(const itk::DataObject*);
mitkClassMacro( FiberBundleX, BaseData )
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
mitkNewMacro1Param(Self, vtkSmartPointer<vtkPolyData>) // custom constructor
// colorcoding related methods
void SetColorCoding(const char*);
void SetFAMap(mitk::Image::Pointer);
template <typename TPixel>
void SetFAMap(const mitk::PixelType pixelType, mitk::Image::Pointer);
void DoColorCodingOrientationBased();
void DoColorCodingFaBased();
void DoUseFaFiberOpacity();
void ResetFiberOpacity();
// fiber compression
void Compress(float error = 0.0);
// fiber resampling
void ResampleSpline(float pointDistance=1);
void ResampleSpline(float pointDistance, double tension, double continuity, double bias );
bool RemoveShortFibers(float lengthInMM);
bool RemoveLongFibers(float lengthInMM);
bool ApplyCurvatureThreshold(float minRadius, bool deleteFibers);
void MirrorFibers(unsigned int axis);
void RotateAroundAxis(double x, double y, double z);
void TranslateFibers(double x, double y, double z);
void ScaleFibers(double x, double y, double z, bool subtractCenter=true);
void TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz);
void RemoveDir(vnl_vector_fixed<double,3> dir, double threshold);
itk::Point<float, 3> TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz);
itk::Matrix< double, 3, 3 > TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz);
// add/subtract fibers
FiberBundleX::Pointer AddBundle(FiberBundleX* fib);
FiberBundleX::Pointer SubtractBundle(FiberBundleX* fib);
// fiber subset extraction
FiberBundleX::Pointer ExtractFiberSubset(BaseData* roi);
std::vector<long> ExtractFiberIdSubset(BaseData* roi);
FiberBundleX::Pointer ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert=false);
FiberBundleX::Pointer RemoveFibersOutside(ItkUcharImgType* mask, bool invert=false);
vtkSmartPointer<vtkPolyData> GeneratePolyDataByIds( std::vector<long> ); // TODO: make protected
void GenerateFiberIds(); // TODO: make protected
// get/set data
void SetFiberPolyData(vtkSmartPointer<vtkPolyData>, bool updateGeometry = true);
vtkSmartPointer<vtkPolyData> GetFiberPolyData() const;
std::vector< std::string > GetAvailableColorCodings();
char* GetCurrentColorCoding();
itkGetMacro( NumFibers, int)
//itkGetMacro( FiberSampling, int)
int GetNumFibers() const {return m_NumFibers;}
itkGetMacro( MinFiberLength, float )
itkGetMacro( MaxFiberLength, float )
itkGetMacro( MeanFiberLength, float )
itkGetMacro( MedianFiberLength, float )
itkGetMacro( LengthStDev, float )
itkGetMacro( UpdateTime2D, itk::TimeStamp )
itkGetMacro( UpdateTime3D, itk::TimeStamp )
void RequestUpdate2D(){ m_UpdateTime2D.Modified(); }
void RequestUpdate3D(){ m_UpdateTime3D.Modified(); }
unsigned long GetNumberOfPoints();
// copy fiber bundle
mitk::FiberBundleX::Pointer GetDeepCopy();
// compare fiber bundles
bool Equals(FiberBundleX* fib, double eps=0.0001);
itkSetMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
itkGetConstMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
protected:
FiberBundleX( vtkPolyData* fiberPolyData = NULL );
virtual ~FiberBundleX();
itk::Point<float, 3> GetItkPoint(double point[3]);
// calculate geometry from fiber extent
void UpdateFiberGeometry();
// calculate colorcoding values according to m_CurrentColorCoding
void UpdateColorCoding();
private:
// actual fiber container
vtkSmartPointer<vtkPolyData> m_FiberPolyData;
// contains fiber ids
vtkSmartPointer<vtkDataSet> m_FiberIdDataSet;
char* m_CurrentColorCoding;
int m_NumFibers;
std::vector< float > m_FiberLengths;
float m_MinFiberLength;
float m_MaxFiberLength;
float m_MeanFiberLength;
float m_MedianFiberLength;
float m_LengthStDev;
int m_FiberSampling;
itk::TimeStamp m_UpdateTime2D;
itk::TimeStamp m_UpdateTime3D;
mitk::BaseGeometry::Pointer m_ReferenceGeometry;
};
} // namespace mitk
#endif /* _MITK_FiberBundleX_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
index f4db8d7de5..c10eec78d6 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
@@ -1,723 +1,723 @@
/*===================================================================
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 <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <itkImageFileWriter.h>
#include <itkImageFileReader.h>
template< class ScalarType >
mitk::FiberfoxParameters< ScalarType >::FiberfoxParameters()
: m_NoiseModel(NULL)
{
}
template< class ScalarType >
mitk::FiberfoxParameters< ScalarType >::~FiberfoxParameters()
{
// if (m_NoiseModel!=NULL)
// delete m_NoiseModel;
}
void mitk::SignalGenerationParameters::GenerateGradientHalfShell()
{
int NPoints = 2*m_NumGradients;
m_GradientDirections.clear();
m_NumBaseline = NPoints/20;
if (m_NumBaseline==0)
m_NumBaseline=1;
GradientType g;
g.Fill(0.0);
for (unsigned int i=0; i<m_NumBaseline; i++)
m_GradientDirections.push_back(g);
if (NPoints==0)
return;
vnl_vector<double> theta; theta.set_size(NPoints);
vnl_vector<double> phi; phi.set_size(NPoints);
double C = sqrt(4*M_PI);
phi(0) = 0.0;
phi(NPoints-1) = 0.0;
for(int i=0; i<NPoints; i++)
{
theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
if( i>0 && i<NPoints-1)
{
phi(i) = (phi(i-1) + C /
sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
}
}
for(int i=0; i<NPoints; i++)
{
g[2] = sin(theta(i));
if (g[2]<0)
continue;
g[0] = cos(theta(i)) * cos(phi(i));
g[1] = cos(theta(i)) * sin(phi(i));
m_GradientDirections.push_back(g);
}
}
std::vector< int > mitk::SignalGenerationParameters::GetBaselineIndices()
{
std::vector< int > result;
for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
if (m_GradientDirections.at(i).GetNorm()<0.0001)
result.push_back(i);
return result;
}
unsigned int mitk::SignalGenerationParameters::GetFirstBaselineIndex()
{
for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
if (m_GradientDirections.at(i).GetNorm()<0.0001)
return i;
return -1;
}
bool mitk::SignalGenerationParameters::IsBaselineIndex(unsigned int idx)
{
if (m_GradientDirections.size()>idx && m_GradientDirections.at(idx).GetNorm()<0.0001)
return true;
return false;
}
unsigned int mitk::SignalGenerationParameters::GetNumWeightedVolumes()
{
return m_NumGradients;
}
unsigned int mitk::SignalGenerationParameters::GetNumBaselineVolumes()
{
return m_NumBaseline;
}
unsigned int mitk::SignalGenerationParameters::GetNumVolumes()
{
return m_GradientDirections.size();
}
mitk::SignalGenerationParameters::GradientListType mitk::SignalGenerationParameters::GetGradientDirections()
{
return m_GradientDirections;
}
mitk::SignalGenerationParameters::GradientType mitk::SignalGenerationParameters::GetGradientDirection(unsigned int i)
{
return m_GradientDirections.at(i);
}
void mitk::SignalGenerationParameters::SetNumWeightedVolumes(int numGradients)
{
m_NumGradients = numGradients;
GenerateGradientHalfShell();
}
void mitk::SignalGenerationParameters::SetGradienDirections(GradientListType gradientList)
{
m_GradientDirections = gradientList;
m_NumGradients = 0;
m_NumBaseline = 0;
for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
{
if (m_GradientDirections.at(i).GetNorm()>0.0001)
m_NumGradients++;
else
m_NumBaseline++;
}
}
-void mitk::SignalGenerationParameters::SetGradienDirections(mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer gradientList)
+void mitk::SignalGenerationParameters::SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList)
{
m_NumGradients = 0;
m_NumBaseline = 0;
m_GradientDirections.clear();
for( unsigned int i=0; i<gradientList->Size(); i++)
{
GradientType g;
g[0] = gradientList->at(i)[0];
g[1] = gradientList->at(i)[1];
g[2] = gradientList->at(i)[2];
m_GradientDirections.push_back(g);
if (m_GradientDirections.at(i).GetNorm()>0.0001)
m_NumGradients++;
else
m_NumBaseline++;
}
}
template< class ScalarType >
void mitk::FiberfoxParameters< ScalarType >::SaveParameters(string filename)
{
if(filename.empty())
return;
if(".ffp"!=filename.substr(filename.size()-4, 4))
filename += ".ffp";
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
boost::property_tree::ptree parameters;
// fiber generation parameters
parameters.put("fiberfox.fibers.distribution", m_FiberGen.m_Distribution);
parameters.put("fiberfox.fibers.variance", m_FiberGen.m_Variance);
parameters.put("fiberfox.fibers.density", m_FiberGen.m_Density);
parameters.put("fiberfox.fibers.spline.sampling", m_FiberGen.m_Sampling);
parameters.put("fiberfox.fibers.spline.tension", m_FiberGen.m_Tension);
parameters.put("fiberfox.fibers.spline.continuity", m_FiberGen.m_Continuity);
parameters.put("fiberfox.fibers.spline.bias", m_FiberGen.m_Bias);
parameters.put("fiberfox.fibers.rotation.x", m_FiberGen.m_Rotation[0]);
parameters.put("fiberfox.fibers.rotation.y", m_FiberGen.m_Rotation[1]);
parameters.put("fiberfox.fibers.rotation.z", m_FiberGen.m_Rotation[2]);
parameters.put("fiberfox.fibers.translation.x", m_FiberGen.m_Translation[0]);
parameters.put("fiberfox.fibers.translation.y", m_FiberGen.m_Translation[1]);
parameters.put("fiberfox.fibers.translation.z", m_FiberGen.m_Translation[2]);
parameters.put("fiberfox.fibers.scale.x", m_FiberGen.m_Scale[0]);
parameters.put("fiberfox.fibers.scale.y", m_FiberGen.m_Scale[1]);
parameters.put("fiberfox.fibers.scale.z", m_FiberGen.m_Scale[2]);
// image generation parameters
parameters.put("fiberfox.image.basic.size.x", m_SignalGen.m_ImageRegion.GetSize(0));
parameters.put("fiberfox.image.basic.size.y", m_SignalGen.m_ImageRegion.GetSize(1));
parameters.put("fiberfox.image.basic.size.z", m_SignalGen.m_ImageRegion.GetSize(2));
parameters.put("fiberfox.image.basic.spacing.x", m_SignalGen.m_ImageSpacing[0]);
parameters.put("fiberfox.image.basic.spacing.y", m_SignalGen.m_ImageSpacing[1]);
parameters.put("fiberfox.image.basic.spacing.z", m_SignalGen.m_ImageSpacing[2]);
parameters.put("fiberfox.image.basic.origin.x", m_SignalGen.m_ImageOrigin[0]);
parameters.put("fiberfox.image.basic.origin.y", m_SignalGen.m_ImageOrigin[1]);
parameters.put("fiberfox.image.basic.origin.z", m_SignalGen.m_ImageOrigin[2]);
parameters.put("fiberfox.image.basic.direction.1", m_SignalGen.m_ImageDirection[0][0]);
parameters.put("fiberfox.image.basic.direction.2", m_SignalGen.m_ImageDirection[0][1]);
parameters.put("fiberfox.image.basic.direction.3", m_SignalGen.m_ImageDirection[0][2]);
parameters.put("fiberfox.image.basic.direction.4", m_SignalGen.m_ImageDirection[1][0]);
parameters.put("fiberfox.image.basic.direction.5", m_SignalGen.m_ImageDirection[1][1]);
parameters.put("fiberfox.image.basic.direction.6", m_SignalGen.m_ImageDirection[1][2]);
parameters.put("fiberfox.image.basic.direction.7", m_SignalGen.m_ImageDirection[2][0]);
parameters.put("fiberfox.image.basic.direction.8", m_SignalGen.m_ImageDirection[2][1]);
parameters.put("fiberfox.image.basic.direction.9", m_SignalGen.m_ImageDirection[2][2]);
parameters.put("fiberfox.image.basic.numgradients", m_SignalGen.GetNumWeightedVolumes());
for( unsigned int i=0; i<this->m_SignalGen.GetNumVolumes(); i++)
{
parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".x", m_SignalGen.GetGradientDirection(i)[0]);
parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".y", m_SignalGen.GetGradientDirection(i)[1]);
parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".z", m_SignalGen.GetGradientDirection(i)[2]);
}
parameters.put("fiberfox.image.signalScale", m_SignalGen.m_SignalScale);
parameters.put("fiberfox.image.tEcho", m_SignalGen.m_tEcho);
parameters.put("fiberfox.image.tLine", m_SignalGen.m_tLine);
parameters.put("fiberfox.image.tInhom", m_SignalGen.m_tInhom);
parameters.put("fiberfox.image.bvalue", m_SignalGen.m_Bvalue);
parameters.put("fiberfox.image.simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
parameters.put("fiberfox.image.axonRadius", m_SignalGen.m_AxonRadius);
parameters.put("fiberfox.image.diffusiondirectionmode", m_SignalGen.m_DiffusionDirectionMode);
parameters.put("fiberfox.image.fiberseparationthreshold", m_SignalGen.m_FiberSeparationThreshold);
parameters.put("fiberfox.image.doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
parameters.put("fiberfox.image.doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
parameters.put("fiberfox.image.artifacts.spikesnum", m_SignalGen.m_Spikes);
parameters.put("fiberfox.image.artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
parameters.put("fiberfox.image.artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
parameters.put("fiberfox.image.artifacts.eddyTau", m_SignalGen.m_Tau);
parameters.put("fiberfox.image.artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
parameters.put("fiberfox.image.artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
parameters.put("fiberfox.image.artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
parameters.put("fiberfox.image.artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
parameters.put("fiberfox.image.artifacts.translation0", m_SignalGen.m_Translation[0]);
parameters.put("fiberfox.image.artifacts.translation1", m_SignalGen.m_Translation[1]);
parameters.put("fiberfox.image.artifacts.translation2", m_SignalGen.m_Translation[2]);
parameters.put("fiberfox.image.artifacts.rotation0", m_SignalGen.m_Rotation[0]);
parameters.put("fiberfox.image.artifacts.rotation1", m_SignalGen.m_Rotation[1]);
parameters.put("fiberfox.image.artifacts.rotation2", m_SignalGen.m_Rotation[2]);
parameters.put("fiberfox.image.artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
parameters.put("fiberfox.image.artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
parameters.put("fiberfox.image.artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
parameters.put("fiberfox.image.artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
parameters.put("fiberfox.image.artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
parameters.put("fiberfox.image.artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
parameters.put("fiberfox.image.outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
parameters.put("fiberfox.image.showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
parameters.put("fiberfox.image.signalmodelstring", m_Misc.m_SignalModelString);
parameters.put("fiberfox.image.artifactmodelstring", m_Misc.m_ArtifactModelString);
parameters.put("fiberfox.image.outpath", m_Misc.m_OutputPath);
parameters.put("fiberfox.fibers.realtime", m_Misc.m_CheckRealTimeFibersBox);
parameters.put("fiberfox.fibers.showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
parameters.put("fiberfox.fibers.constantradius", m_Misc.m_CheckConstantRadiusBox);
parameters.put("fiberfox.fibers.includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
if (m_NoiseModel!=NULL)
{
parameters.put("fiberfox.image.artifacts.noisevariance", m_NoiseModel->GetNoiseVariance());
if (dynamic_cast<mitk::RicianNoiseModel<ScalarType>*>(m_NoiseModel))
parameters.put("fiberfox.image.artifacts.noisetype", "rice");
else if (dynamic_cast<mitk::ChiSquareNoiseModel<ScalarType>*>(m_NoiseModel))
parameters.put("fiberfox.image.artifacts.noisetype", "chisquare");
}
for (int i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
{
mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
if (i<m_FiberModelList.size())
{
signalModel = m_FiberModelList.at(i);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".type", "fiber");
}
else
{
signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".type", "non-fiber");
}
if (dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel))
{
mitk::StickModel<ScalarType>* model = dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "stick");
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d", model->GetDiffusivity());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
}
else if (dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel))
{
mitk::TensorModel<ScalarType>* model = dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "tensor");
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d1", model->GetDiffusivity1());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d2", model->GetDiffusivity2());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d3", model->GetDiffusivity3());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
}
else if (dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel))
{
mitk::RawShModel<ScalarType>* model = dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "prototype");
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".minFA", model->GetFaRange().first);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".maxFA", model->GetFaRange().second);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".minADC", model->GetAdcRange().first);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".maxADC", model->GetAdcRange().second);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".maxNumSamples", model->GetMaxNumKernels());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".numSamples", model->GetNumberOfKernels());
int shOrder = model->GetShOrder();
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".numCoeffs", (shOrder*shOrder + shOrder + 2)/2 + shOrder);
for (unsigned int j=0; j<model->GetNumberOfKernels(); j++)
{
vnl_vector< double > coeffs = model->GetCoefficients(j);
for (unsigned int k=0; k<coeffs.size(); k++)
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".kernels."+boost::lexical_cast<string>(j)+".coeffs."+boost::lexical_cast<string>(k), coeffs[k]);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".kernels."+boost::lexical_cast<string>(j)+".B0", model->GetBaselineSignal(j));
}
}
else if (dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel))
{
mitk::BallModel<ScalarType>* model = dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "ball");
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d", model->GetDiffusivity());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
}
else if (dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel))
{
mitk::AstroStickModel<ScalarType>* model = dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "astrosticks");
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d", model->GetDiffusivity());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".randomize", model->GetRandomizeSticks());
}
else if (dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel))
{
mitk::DotModel<ScalarType>* model = dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel);
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "dot");
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
}
if (signalModel!=NULL)
{
parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".ID", signalModel->m_CompartmentId);
if (signalModel->GetVolumeFractionImage().IsNotNull())
{
try{
itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
writer->SetFileName(filename+"_VOLUME"+boost::lexical_cast<string>(signalModel->m_CompartmentId)+".nrrd");
writer->SetInput(signalModel->GetVolumeFractionImage());
writer->Update();
MITK_INFO << "Volume fraction image for compartment "+boost::lexical_cast<string>(signalModel->m_CompartmentId)+" saved.";
}
catch(...)
{
}
}
}
}
boost::property_tree::xml_writer_settings<std::string> writerSettings(' ', 2);
boost::property_tree::xml_parser::write_xml(filename, parameters, std::locale(), writerSettings);
try{
itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
writer->SetFileName(filename+"_FMAP.nrrd");
writer->SetInput(m_SignalGen.m_FrequencyMap);
writer->Update();
}
catch(...)
{
MITK_INFO << "No frequency map saved.";
}
try{
itk::ImageFileWriter<ItkUcharImgType>::Pointer writer = itk::ImageFileWriter<ItkUcharImgType>::New();
writer->SetFileName(filename+"_MASK.nrrd");
writer->SetInput(m_SignalGen.m_MaskImage);
writer->Update();
}
catch(...)
{
MITK_INFO << "No mask image saved.";
}
setlocale(LC_ALL, currLocale.c_str());
}
template< class ScalarType >
void mitk::FiberfoxParameters< ScalarType >::LoadParameters(string filename)
{
if(filename.empty())
return;
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
boost::property_tree::ptree parameterTree;
boost::property_tree::xml_parser::read_xml(filename, parameterTree);
m_FiberModelList.clear();
m_NonFiberModelList.clear();
if (m_NoiseModel!=NULL)
delete m_NoiseModel;
BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameterTree.get_child("fiberfox") )
{
if( v1.first == "fibers" )
{
m_Misc.m_CheckRealTimeFibersBox = v1.second.get<bool>("realtime", m_Misc.m_CheckRealTimeFibersBox);
m_Misc.m_CheckAdvancedFiberOptionsBox = v1.second.get<bool>("showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
m_Misc.m_CheckConstantRadiusBox = v1.second.get<bool>("constantradius", m_Misc.m_CheckConstantRadiusBox);
m_Misc.m_CheckIncludeFiducialsBox = v1.second.get<bool>("includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
switch (v1.second.get<unsigned int>("distribution", 0))
{
case 0:
m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
break;
case 1:
m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
break;
default:
m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
}
m_FiberGen.m_Variance = v1.second.get<double>("variance", m_FiberGen.m_Variance);
m_FiberGen.m_Density = v1.second.get<unsigned int>("density", m_FiberGen.m_Density);
m_FiberGen.m_Sampling = v1.second.get<double>("spline.sampling", m_FiberGen.m_Sampling);
m_FiberGen.m_Tension = v1.second.get<double>("spline.tension", m_FiberGen.m_Tension);
m_FiberGen.m_Continuity = v1.second.get<double>("spline.continuity", m_FiberGen.m_Continuity);
m_FiberGen.m_Bias = v1.second.get<double>("spline.bias", m_FiberGen.m_Bias);
m_FiberGen.m_Rotation[0] = v1.second.get<double>("rotation.x", m_FiberGen.m_Rotation[0]);
m_FiberGen.m_Rotation[1] = v1.second.get<double>("rotation.y", m_FiberGen.m_Rotation[1]);
m_FiberGen.m_Rotation[2] = v1.second.get<double>("rotation.z", m_FiberGen.m_Rotation[2]);
m_FiberGen.m_Translation[0] = v1.second.get<double>("translation.x", m_FiberGen.m_Translation[0]);
m_FiberGen.m_Translation[1] = v1.second.get<double>("translation.y", m_FiberGen.m_Translation[1]);
m_FiberGen.m_Translation[2] = v1.second.get<double>("translation.z", m_FiberGen.m_Translation[2]);
m_FiberGen.m_Scale[0] = v1.second.get<double>("scale.x", m_FiberGen.m_Scale[0]);
m_FiberGen.m_Scale[1] = v1.second.get<double>("scale.y", m_FiberGen.m_Scale[1]);
m_FiberGen.m_Scale[2] = v1.second.get<double>("scale.z", m_FiberGen.m_Scale[2]);
}
else if ( v1.first == "image" )
{
m_Misc.m_SignalModelString = v1.second.get<string>("signalmodelstring", m_Misc.m_SignalModelString);
m_Misc.m_ArtifactModelString = v1.second.get<string>("artifactmodelstring", m_Misc.m_ArtifactModelString);
m_Misc.m_OutputPath = v1.second.get<string>("outpath", m_Misc.m_OutputPath);
m_Misc.m_CheckOutputVolumeFractionsBox = v1.second.get<bool>("outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
m_Misc.m_CheckAdvancedSignalOptionsBox = v1.second.get<bool>("showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
m_Misc.m_CheckAddDistortionsBox = v1.second.get<bool>("artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
m_Misc.m_CheckAddNoiseBox = v1.second.get<bool>("artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
m_Misc.m_CheckAddGhostsBox = v1.second.get<bool>("artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
m_Misc.m_CheckAddAliasingBox = v1.second.get<bool>("artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
m_Misc.m_CheckAddSpikesBox = v1.second.get<bool>("artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
m_Misc.m_CheckAddEddyCurrentsBox = v1.second.get<bool>("artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
m_SignalGen.m_ImageRegion.SetSize(0, v1.second.get<int>("basic.size.x",m_SignalGen.m_ImageRegion.GetSize(0)));
m_SignalGen.m_ImageRegion.SetSize(1, v1.second.get<int>("basic.size.y",m_SignalGen.m_ImageRegion.GetSize(1)));
m_SignalGen.m_ImageRegion.SetSize(2, v1.second.get<int>("basic.size.z",m_SignalGen.m_ImageRegion.GetSize(2)));
m_SignalGen.m_ImageSpacing[0] = v1.second.get<double>("basic.spacing.x",m_SignalGen.m_ImageSpacing[0]);
m_SignalGen.m_ImageSpacing[1] = v1.second.get<double>("basic.spacing.y",m_SignalGen.m_ImageSpacing[1]);
m_SignalGen.m_ImageSpacing[2] = v1.second.get<double>("basic.spacing.z",m_SignalGen.m_ImageSpacing[2]);
m_SignalGen.m_ImageOrigin[0] = v1.second.get<double>("basic.origin.x",m_SignalGen.m_ImageOrigin[0]);
m_SignalGen.m_ImageOrigin[1] = v1.second.get<double>("basic.origin.y",m_SignalGen.m_ImageOrigin[1]);
m_SignalGen.m_ImageOrigin[2] = v1.second.get<double>("basic.origin.z",m_SignalGen.m_ImageOrigin[2]);
m_SignalGen.m_ImageDirection[0][0] = v1.second.get<double>("basic.direction.1",m_SignalGen.m_ImageDirection[0][0]);
m_SignalGen.m_ImageDirection[0][1] = v1.second.get<double>("basic.direction.2",m_SignalGen.m_ImageDirection[0][1]);
m_SignalGen.m_ImageDirection[0][2] = v1.second.get<double>("basic.direction.3",m_SignalGen.m_ImageDirection[0][2]);
m_SignalGen.m_ImageDirection[1][0] = v1.second.get<double>("basic.direction.4",m_SignalGen.m_ImageDirection[1][0]);
m_SignalGen.m_ImageDirection[1][1] = v1.second.get<double>("basic.direction.5",m_SignalGen.m_ImageDirection[1][1]);
m_SignalGen.m_ImageDirection[1][2] = v1.second.get<double>("basic.direction.6",m_SignalGen.m_ImageDirection[1][2]);
m_SignalGen.m_ImageDirection[2][0] = v1.second.get<double>("basic.direction.7",m_SignalGen.m_ImageDirection[2][0]);
m_SignalGen.m_ImageDirection[2][1] = v1.second.get<double>("basic.direction.8",m_SignalGen.m_ImageDirection[2][1]);
m_SignalGen.m_ImageDirection[2][2] = v1.second.get<double>("basic.direction.9",m_SignalGen.m_ImageDirection[2][2]);
m_SignalGen.m_SignalScale = v1.second.get<double>("signalScale", m_SignalGen.m_SignalScale);
m_SignalGen.m_tEcho = v1.second.get<double>("tEcho", m_SignalGen.m_tEcho);
m_SignalGen.m_tLine = v1.second.get<double>("tLine", m_SignalGen.m_tLine);
m_SignalGen.m_tInhom = v1.second.get<double>("tInhom", m_SignalGen.m_tInhom);
m_SignalGen.m_Bvalue = v1.second.get<double>("bvalue", m_SignalGen.m_Bvalue);
m_SignalGen.m_SimulateKspaceAcquisition = v1.second.get<bool>("simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
m_SignalGen.m_AxonRadius = v1.second.get<double>("axonRadius", m_SignalGen.m_AxonRadius);
switch (v1.second.get<int>("diffusiondirectionmode", 0))
{
case 0:
m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
break;
case 1:
m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::MAIN_FIBER_DIRECTIONS;
break;
case 2:
m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::RANDOM_DIRECTIONS;
break;
default:
m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
}
m_SignalGen.m_FiberSeparationThreshold = v1.second.get<double>("fiberseparationthreshold", m_SignalGen.m_FiberSeparationThreshold);
m_SignalGen.m_Spikes = v1.second.get<unsigned int>("artifacts.spikesnum", m_SignalGen.m_Spikes);
m_SignalGen.m_SpikeAmplitude = v1.second.get<double>("artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
m_SignalGen.m_KspaceLineOffset = v1.second.get<double>("artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
m_SignalGen.m_EddyStrength = v1.second.get<double>("artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
m_SignalGen.m_Tau = v1.second.get<double>("artifacts.eddyTau", m_SignalGen.m_Tau);
m_SignalGen.m_CroppingFactor = v1.second.get<double>("artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
m_SignalGen.m_DoAddGibbsRinging = v1.second.get<bool>("artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
m_SignalGen.m_DoSimulateRelaxation = v1.second.get<bool>("doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
m_SignalGen.m_DoDisablePartialVolume = v1.second.get<bool>("doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
m_SignalGen.m_DoAddMotion = v1.second.get<bool>("artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
m_SignalGen.m_DoRandomizeMotion = v1.second.get<bool>("artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
m_SignalGen.m_Translation[0] = v1.second.get<double>("artifacts.translation0", m_SignalGen.m_Translation[0]);
m_SignalGen.m_Translation[1] = v1.second.get<double>("artifacts.translation1", m_SignalGen.m_Translation[1]);
m_SignalGen.m_Translation[2] = v1.second.get<double>("artifacts.translation2", m_SignalGen.m_Translation[2]);
m_SignalGen.m_Rotation[0] = v1.second.get<double>("artifacts.rotation0", m_SignalGen.m_Rotation[0]);
m_SignalGen.m_Rotation[1] = v1.second.get<double>("artifacts.rotation1", m_SignalGen.m_Rotation[1]);
m_SignalGen.m_Rotation[2] = v1.second.get<double>("artifacts.rotation2", m_SignalGen.m_Rotation[2]);
// m_SignalGen.SetNumWeightedVolumes(v1.second.get<unsigned int>("numgradients", m_SignalGen.GetNumWeightedVolumes()));
SignalGenerationParameters::GradientListType gradients;
BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("gradients") )
{
SignalGenerationParameters::GradientType g;
g[0] = v2.second.get<double>("x");
g[1] = v2.second.get<double>("y");
g[2] = v2.second.get<double>("z");
gradients.push_back(g);
}
m_SignalGen.SetGradienDirections(gradients);
try
{
if (v1.second.get<string>("artifacts.noisetype")=="rice")
{
m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
m_NoiseModel->SetNoiseVariance(v1.second.get<double>("artifacts.noisevariance"));
}
}
catch(...) {}
try
{
if (v1.second.get<string>("artifacts.noisetype")=="chisquare")
{
m_NoiseModel = new mitk::ChiSquareNoiseModel<ScalarType>();
m_NoiseModel->SetNoiseVariance(v1.second.get<double>("artifacts.noisevariance"));
}
}
catch(...){ }
BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("compartments") )
{
mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
std::string model = v2.second.get<string>("model");
if (model=="stick")
{
mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
model->SetDiffusivity(v2.second.get<double>("d"));
model->SetT2(v2.second.get<double>("t2"));
model->m_CompartmentId = v2.second.get<unsigned int>("ID");
if (v2.second.get<string>("type")=="fiber")
m_FiberModelList.push_back(model);
else if (v2.second.get<string>("type")=="non-fiber")
m_NonFiberModelList.push_back(model);
signalModel = model;
}
else if (model=="tensor")
{
mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
model->SetDiffusivity1(v2.second.get<double>("d1"));
model->SetDiffusivity2(v2.second.get<double>("d2"));
model->SetDiffusivity3(v2.second.get<double>("d3"));
model->SetT2(v2.second.get<double>("t2"));
model->m_CompartmentId = v2.second.get<unsigned int>("ID");
if (v2.second.get<string>("type")=="fiber")
m_FiberModelList.push_back(model);
else if (v2.second.get<string>("type")=="non-fiber")
m_NonFiberModelList.push_back(model);
signalModel = model;
}
else if (model=="ball")
{
mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
model->SetDiffusivity(v2.second.get<double>("d"));
model->SetT2(v2.second.get<double>("t2"));
model->m_CompartmentId = v2.second.get<unsigned int>("ID");
if (v2.second.get<string>("type")=="fiber")
m_FiberModelList.push_back(model);
else if (v2.second.get<string>("type")=="non-fiber")
m_NonFiberModelList.push_back(model);
signalModel = model;
}
else if (model=="astrosticks")
{
mitk::AstroStickModel<ScalarType>* model = new AstroStickModel<ScalarType>();
model->SetDiffusivity(v2.second.get<double>("d"));
model->SetT2(v2.second.get<double>("t2"));
model->SetRandomizeSticks(v2.second.get<bool>("randomize"));
model->m_CompartmentId = v2.second.get<unsigned int>("ID");
if (v2.second.get<string>("type")=="fiber")
m_FiberModelList.push_back(model);
else if (v2.second.get<string>("type")=="non-fiber")
m_NonFiberModelList.push_back(model);
signalModel = model;
}
else if (model=="dot")
{
mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
model->SetT2(v2.second.get<double>("t2"));
model->m_CompartmentId = v2.second.get<unsigned int>("ID");
if (v2.second.get<string>("type")=="fiber")
m_FiberModelList.push_back(model);
else if (v2.second.get<string>("type")=="non-fiber")
m_NonFiberModelList.push_back(model);
signalModel = model;
}
else if (model=="prototype")
{
mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
model->SetMaxNumKernels(v2.second.get<unsigned int>("maxNumSamples"));
model->SetFaRange(v2.second.get<double>("minFA"), v2.second.get<double>("maxFA"));
model->SetAdcRange(v2.second.get<double>("minADC"), v2.second.get<double>("maxADC"));
model->m_CompartmentId = v2.second.get<unsigned int>("ID");
unsigned int numCoeffs = v2.second.get<unsigned int>("numCoeffs");
unsigned int numSamples = v2.second.get<unsigned int>("numSamples");
for (unsigned int j=0; j<numSamples; j++)
{
vnl_vector< double > coeffs(numCoeffs);
for (unsigned int k=0; k<numCoeffs; k++)
{
coeffs[k] = v2.second.get<double>("kernels."+boost::lexical_cast<string>(j)+".coeffs."+boost::lexical_cast<string>(k));
}
model->SetShCoefficients( coeffs, v2.second.get<double>("kernels."+boost::lexical_cast<string>(j)+".B0") );
}
if (v2.second.get<string>("type")=="fiber")
m_FiberModelList.push_back(model);
else if (v2.second.get<string>("type")=="non-fiber")
m_NonFiberModelList.push_back(model);
signalModel = model;
}
if (signalModel!=NULL)
{
signalModel->SetGradientList(gradients);
try{
itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
reader->SetFileName(filename+"_VOLUME"+v2.second.get<string>("ID")+".nrrd");
reader->Update();
signalModel->SetVolumeFractionImage(reader->GetOutput());
}
catch(...)
{
}
}
}
}
}
try{
itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
reader->SetFileName(filename+"_FMAP.nrrd");
reader->Update();
m_SignalGen.m_FrequencyMap = reader->GetOutput();
}
catch(...)
{
MITK_INFO << "No frequency map saved.";
}
try{
itk::ImageFileReader<ItkUcharImgType>::Pointer reader = itk::ImageFileReader<ItkUcharImgType>::New();
reader->SetFileName(filename+"_MASK.nrrd");
reader->Update();
m_SignalGen.m_MaskImage = reader->GetOutput();
}
catch(...)
{
MITK_INFO << "No mask image saved.";
}
setlocale(LC_ALL, currLocale.c_str());
}
template< class ScalarType >
void mitk::FiberfoxParameters< ScalarType >::PrintSelf()
{
MITK_INFO << "Not implemented :(";
}
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
index 05370fdaac..e90e50c591 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
@@ -1,321 +1,321 @@
/*===================================================================
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 _MITK_FiberfoxParameters_H
#define _MITK_FiberfoxParameters_H
#include <itkImageRegion.h>
#include <itkMatrix.h>
#include <mitkDiffusionNoiseModel.h>
#include <mitkDiffusionSignalModel.h>
#include <mitkDataNode.h>
#include <mitkRicianNoiseModel.h>
#include <mitkChiSquareNoiseModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
#include <mitkPlanarEllipse.h>
-
#include <mitkStickModel.h>
#include <mitkTensorModel.h>
#include <mitkAstroStickModel.h>
#include <mitkBallModel.h>
#include <mitkDotModel.h>
#include <mitkRawShModel.h>
using namespace std;
namespace mitk {
/** Signal generation */
class SignalGenerationParameters
{
public:
typedef itk::Image<double, 3> ItkDoubleImgType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Vector<double,3> GradientType;
typedef std::vector<GradientType> GradientListType;
enum DiffusionDirectionMode {
FIBER_TANGENT_DIRECTIONS,
MAIN_FIBER_DIRECTIONS,
RANDOM_DIRECTIONS
};
SignalGenerationParameters()
: m_SignalScale(100)
, m_tEcho(100)
, m_tLine(1)
, m_tInhom(50)
, m_Bvalue(1000)
, m_SimulateKspaceAcquisition(false)
, m_AxonRadius(0)
, m_DoDisablePartialVolume(false)
, m_DiffusionDirectionMode(SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS)
, m_FiberSeparationThreshold(30)
, m_Spikes(0)
, m_SpikeAmplitude(1)
, m_KspaceLineOffset(0)
, m_EddyStrength(0)
, m_Tau(70)
, m_CroppingFactor(1)
, m_DoAddGibbsRinging(false)
, m_DoSimulateRelaxation(true)
, m_DoAddMotion(false)
, m_DoRandomizeMotion(true)
, m_FrequencyMap(NULL)
, m_MaskImage(NULL)
{
m_ImageRegion.SetSize(0, 12);
m_ImageRegion.SetSize(1, 12);
m_ImageRegion.SetSize(2, 3);
m_ImageSpacing.Fill(2.0);
m_ImageOrigin.Fill(0.0);
m_ImageDirection.SetIdentity();
m_Translation.Fill(0.0);
m_Rotation.Fill(0.0);
SetNumWeightedVolumes(6);
}
/** input/output image specifications */
itk::ImageRegion<3> m_ImageRegion; ///< Image size.
itk::Vector<double,3> m_ImageSpacing; ///< Image voxel size.
itk::Point<double,3> m_ImageOrigin; ///< Image origin.
itk::Matrix<double, 3, 3> m_ImageDirection; ///< Image rotation matrix.
/** Other acquisitions parameters */
double m_SignalScale; ///< Scaling factor for output signal (before noise is added).
double m_tEcho; ///< Echo time TE.
double m_tLine; ///< k-space line readout time.
double m_tInhom; ///< T2'
double m_Bvalue; ///< Acquisition b-value
bool m_SimulateKspaceAcquisition;///< Flag to enable/disable k-space acquisition simulation
double m_AxonRadius; ///< Determines compartment volume fractions (0 == automatic axon radius estimation)
bool m_DoDisablePartialVolume; ///< Disable partial volume effects. Each voxel is either all fiber or all non-fiber.
DiffusionDirectionMode m_DiffusionDirectionMode; ///< Determines how the main diffusion direction of the signal models is selected
double m_FiberSeparationThreshold; ///< Used for random and and mein fiber deriction DiffusionDirectionMode
/** Artifacts and other effects */
unsigned int m_Spikes; ///< Number of spikes randomly appearing in the image
double m_SpikeAmplitude; ///< amplitude of spikes relative to the largest signal intensity (magnitude of complex)
double m_KspaceLineOffset; ///< Causes N/2 ghosts. Larger offset means stronger ghost.
double m_EddyStrength; ///< Strength of eddy current induced gradients in mT/m.
double m_Tau; ///< Eddy current decay constant (in ms)
double m_CroppingFactor; ///< FOV size in y-direction is multiplied by this factor. Causes aliasing artifacts.
bool m_DoAddGibbsRinging; ///< Add Gibbs ringing artifact
bool m_DoSimulateRelaxation; ///< Add T2 relaxation effects
bool m_DoAddMotion; ///< Enable motion artifacts.
bool m_DoRandomizeMotion; ///< Toggles between random and linear motion.
itk::Vector<double,3> m_Translation; ///< Maximum translational motion.
itk::Vector<double,3> m_Rotation; ///< Maximum rotational motion.
ItkDoubleImgType::Pointer m_FrequencyMap; ///< If != NULL, distortions are added to the image using this frequency map.
ItkUcharImgType::Pointer m_MaskImage; ///< Signal is only genrated inside of the mask image.
inline void GenerateGradientHalfShell(); ///< Generates half shell of gradient directions (with m_NumGradients non-zero directions)
inline std::vector< int > GetBaselineIndices(); ///< Returns list of nun-diffusion-weighted image volume indices
inline unsigned int GetFirstBaselineIndex(); ///< Returns index of first non-diffusion-weighted image volume
inline bool IsBaselineIndex(unsigned int idx); ///< Checks if image volume with given index is non-diffusion-weighted volume or not.
inline unsigned int GetNumWeightedVolumes(); ///< Get number of diffusion-weighted image volumes
inline unsigned int GetNumBaselineVolumes(); ///< Get number of non-diffusion-weighted image volumes
inline unsigned int GetNumVolumes(); ///< Get number of baseline and diffusion-weighted image volumes
inline GradientListType GetGradientDirections(); ///< Return gradient direction container
inline GradientType GetGradientDirection(unsigned int i);
inline void SetNumWeightedVolumes(int numGradients); ///< Automaticall calls GenerateGradientHalfShell() afterwards.
inline void SetGradienDirections(GradientListType gradientList);
- inline void SetGradienDirections(mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer gradientList);
+ inline void SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList);
protected:
unsigned int m_NumGradients; ///< Number of diffusion-weighted image volumes.
unsigned int m_NumBaseline; ///< Number of non-diffusion-weighted image volumes.
GradientListType m_GradientDirections; ///< Total number of image volumes.
};
/** Fiber generation */
class FiberGenerationParameters
{
public:
enum FiberDistribution{
DISTRIBUTE_UNIFORM, // distribute fibers uniformly in the ROIs
DISTRIBUTE_GAUSSIAN // distribute fibers using a 2D gaussian
};
typedef vector< vector< mitk::PlanarEllipse::Pointer > > FiducialListType;
typedef vector< vector< unsigned int > > FlipListType;
FiberGenerationParameters()
: m_Distribution(DISTRIBUTE_UNIFORM)
, m_Density(100)
, m_Variance(100)
, m_Sampling(1)
, m_Tension(0)
, m_Continuity(0)
, m_Bias(0)
{
m_Rotation.Fill(0.0);
m_Translation.Fill(0.0);
m_Scale.Fill(1.0);
}
FiberDistribution m_Distribution;
unsigned int m_Density;
double m_Variance;
double m_Sampling;
double m_Tension;
double m_Continuity;
double m_Bias;
mitk::Vector3D m_Rotation;
mitk::Vector3D m_Translation;
mitk::Vector3D m_Scale;
FlipListType m_FlipList; ///< contains flags indicating a flip of the 2D fiber x-coordinates (needed to resolve some unwanted fiber twisting)
FiducialListType m_Fiducials; ///< container of the planar ellipses used as fiducials for the fiber generation process
};
/** GUI persistence, input, output, ... */
class MiscFiberfoxParameters
{
public:
MiscFiberfoxParameters()
: m_ResultNode(DataNode::New())
, m_ParentNode(NULL)
, m_SignalModelString("")
, m_ArtifactModelString("")
, m_OutputPath("")
, m_CheckOutputVolumeFractionsBox(false)
, m_CheckAdvancedSignalOptionsBox(false)
, m_CheckAddNoiseBox(false)
, m_CheckAddGhostsBox(false)
, m_CheckAddAliasingBox(false)
, m_CheckAddSpikesBox(false)
, m_CheckAddEddyCurrentsBox(false)
, m_CheckAddDistortionsBox(false)
, m_CheckRealTimeFibersBox(true)
, m_CheckAdvancedFiberOptionsBox(false)
, m_CheckConstantRadiusBox(false)
, m_CheckIncludeFiducialsBox(true)
{}
DataNode::Pointer m_ResultNode; ///< Stores resulting image.
DataNode::Pointer m_ParentNode; ///< Parent node of result node.
string m_SignalModelString; ///< Appendet to the name of the result node
string m_ArtifactModelString; ///< Appendet to the name of the result node
string m_OutputPath; ///< Image is automatically saved to the specified folder after simulation is finished.
/** member variables that store the check-state of GUI checkboxes */
// image generation
bool m_CheckOutputVolumeFractionsBox;
bool m_CheckAdvancedSignalOptionsBox;
bool m_CheckAddNoiseBox;
bool m_CheckAddGhostsBox;
bool m_CheckAddAliasingBox;
bool m_CheckAddSpikesBox;
bool m_CheckAddEddyCurrentsBox;
bool m_CheckAddDistortionsBox;
// fiber generation
bool m_CheckRealTimeFibersBox;
bool m_CheckAdvancedFiberOptionsBox;
bool m_CheckConstantRadiusBox;
bool m_CheckIncludeFiducialsBox;
};
/**
* \brief Datastructure to manage the Fiberfox signal generation parameters.
*
*/
template< class ScalarType = double >
class FiberfoxParameters
{
public:
typedef itk::Image<double, 3> ItkDoubleImgType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef DiffusionSignalModel<ScalarType> DiffusionModelType;
typedef std::vector< DiffusionModelType* > DiffusionModelListType;
typedef DiffusionNoiseModel<ScalarType> NoiseModelType;
FiberfoxParameters();
~FiberfoxParameters();
/** Get same parameter object with different template parameter */
template< class OutType >
FiberfoxParameters< OutType > CopyParameters()
{
FiberfoxParameters< OutType > out;
out.m_FiberGen = m_FiberGen;
out.m_SignalGen = m_SignalGen;
out.m_Misc = m_Misc;
if (m_NoiseModel!=NULL)
{
if (dynamic_cast<mitk::RicianNoiseModel<ScalarType>*>(m_NoiseModel))
out.m_NoiseModel = new mitk::RicianNoiseModel<OutType>();
else if (dynamic_cast<mitk::ChiSquareNoiseModel<ScalarType>*>(m_NoiseModel))
out.m_NoiseModel = new mitk::ChiSquareNoiseModel<OutType>();
out.m_NoiseModel->SetNoiseVariance(m_NoiseModel->GetNoiseVariance());
}
for (unsigned int i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
{
mitk::DiffusionSignalModel<OutType>* outModel = NULL;
mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
if (i<m_FiberModelList.size())
signalModel = m_FiberModelList.at(i);
else
signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());
if (dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel))
outModel = new mitk::StickModel<OutType>(dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel));
else if (dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel))
outModel = new mitk::TensorModel<OutType>(dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel));
else if (dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel))
outModel = new mitk::RawShModel<OutType>(dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel));
else if (dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel))
outModel = new mitk::BallModel<OutType>(dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel));
else if (dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel))
outModel = new mitk::AstroStickModel<OutType>(dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel));
else if (dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel))
outModel = new mitk::DotModel<OutType>(dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel));
if (i<m_FiberModelList.size())
out.m_FiberModelList.push_back(outModel);
else
out.m_NonFiberModelList.push_back(outModel);
}
return out;
}
/** Not templated parameters */
FiberGenerationParameters m_FiberGen; ///< Fiber generation parameters
SignalGenerationParameters m_SignalGen; ///< Signal generation parameters
MiscFiberfoxParameters m_Misc; ///< GUI realted and I/O parameters
/** Templated parameters */
DiffusionModelListType m_FiberModelList; ///< Intra- and inter-axonal compartments.
DiffusionModelListType m_NonFiberModelList; ///< Extra-axonal compartments.
NoiseModelType* m_NoiseModel; ///< If != NULL, noise is added to the image.
void PrintSelf(); ///< Print parameters to stdout.
void SaveParameters(string filename); ///< Save image generation parameters to .ffp file.
void LoadParameters(string filename); ///< Load image generation parameters from .ffp file.
};
}
#include "mitkFiberfoxParameters.cpp"
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp
index 0d2302d1e7..e23724c631 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp
@@ -1,382 +1,390 @@
/*===================================================================
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 <vnl/vnl_cross.h>
#include <vnl/vnl_quaternion.h>
#include <mitkRawShModel.h>
#include <boost/math/special_functions.hpp>
#include <itkOrientationDistributionFunction.h>
#include <mitkFiberfoxParameters.h>
#include <itkDiffusionTensor3DReconstructionImageFilter.h>
#include <itkAdcImageFilter.h>
#include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkProperties.h>
using namespace mitk;
using namespace boost::math;
template< class ScalarType >
RawShModel< ScalarType >::RawShModel()
: m_ShOrder(0)
, m_ModelIndex(-1)
, m_MaxNumKernels(1000)
{
this->m_RandGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
this->m_RandGen->SetSeed();
m_AdcRange.first = 0;
m_AdcRange.second = 0.004;
m_FaRange.first = 0;
m_FaRange.second = 1;
}
template< class ScalarType >
RawShModel< ScalarType >::~RawShModel()
{
}
template< class ScalarType >
void RawShModel< ScalarType >::Clear()
{
m_ShCoefficients.clear();
m_PrototypeMaxDirection.clear();
m_B0Signal.clear();
}
template< class ScalarType >
void RawShModel< ScalarType >::RandomModel()
{
m_ModelIndex = this->m_RandGen->GetIntegerVariate(m_B0Signal.size()-1);
}
template< class ScalarType >
unsigned int RawShModel< ScalarType >::GetNumberOfKernels()
{
return m_B0Signal.size();
}
template< class ScalarType >
-bool RawShModel< ScalarType >::SampleKernels(DiffusionImage<short>::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage, QballFilterType::CoefficientImageType::Pointer itkFeatureImage, ItkDoubleImageType::Pointer adcImage)
+bool RawShModel< ScalarType >::SampleKernels(Image::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage, QballFilterType::CoefficientImageType::Pointer itkFeatureImage, ItkDoubleImageType::Pointer adcImage)
{
if (diffImg.IsNull())
return false;
+ typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+
const int shOrder = 2;
if (tensorImage.IsNull())
{
typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
+
TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
- filter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
- filter->SetBValue(diffImg->GetReferenceBValue());
+ filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ filter->SetBValue(static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
filter->Update();
tensorImage = filter->GetOutput();
}
const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
if (itkFeatureImage.IsNull())
{
QballFilterType::Pointer qballfilter = QballFilterType::New();
- qballfilter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
- qballfilter->SetBValue(diffImg->GetReferenceBValue());
+ qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ qballfilter->SetBValue(static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
qballfilter->SetLambda(0.006);
qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
qballfilter->Update();
itkFeatureImage = qballfilter->GetCoefficientImage();
}
if (adcImage.IsNull())
{
itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
- adcFilter->SetInput(diffImg->GetVectorImage());
- adcFilter->SetGradientDirections(diffImg->GetDirections());
- adcFilter->SetB_value(diffImg->GetReferenceBValue());
+ adcFilter->SetInput(itkVectorImagePointer);
+ adcFilter->SetGradientDirections(static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
+ adcFilter->SetB_value(static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
adcFilter->Update();
adcImage = adcFilter->GetOutput();
}
int b0Index;
- for (unsigned int i=0; i<diffImg->GetDirectionsWithoutMeasurementFrame()->Size(); i++)
- if ( diffImg->GetDirectionsWithoutMeasurementFrame()->GetElement(i).magnitude()<0.001 )
+ for (unsigned int i=0; i<static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size(); i++)
+ if ( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->GetElement(i).magnitude()<0.001 )
{
b0Index = i;
break;
}
double max = 0;
{
- itk::ImageRegionIterator< itk::VectorImage< short, 3 > > it(diffImg->GetVectorImage(), diffImg->GetVectorImage()->GetLargestPossibleRegion());
+ itk::ImageRegionIterator< itk::VectorImage< short, 3 > > it(itkVectorImagePointer, itkVectorImagePointer->GetLargestPossibleRegion());
while(!it.IsAtEnd())
{
if (maskImage.IsNotNull() && maskImage->GetPixel(it.GetIndex())<=0)
{
++it;
continue;
}
if (it.Get()[b0Index]>max)
max = it.Get()[b0Index];
++it;
}
}
MITK_INFO << "Sampling signal kernels.";
unsigned int count = 0;
itk::ImageRegionIterator< itk::Image< itk::DiffusionTensor3D< double >, 3 > > it(tensorImage, tensorImage->GetLargestPossibleRegion());
while(!it.IsAtEnd())
{
bool skipPixel = false;
if (maskImage.IsNotNull() && maskImage->GetPixel(it.GetIndex())<=0)
{
++it;
continue;
}
- for (unsigned int i=0; i<diffImg->GetDirections()->Size(); i++)
+ for (unsigned int i=0; i<static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size(); i++)
{
- if (diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i]!=diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i] || diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i]<=0 || diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i]>diffImg->GetVectorImage()->GetPixel(it.GetIndex())[b0Index])
+ if (itkVectorImagePointer->GetPixel(it.GetIndex())[i]!=itkVectorImagePointer->GetPixel(it.GetIndex())[i] || itkVectorImagePointer->GetPixel(it.GetIndex())[i]<=0 || itkVectorImagePointer->GetPixel(it.GetIndex())[i]>itkVectorImagePointer->GetPixel(it.GetIndex())[b0Index])
{
skipPixel = true;
break;
}
}
if (skipPixel)
{
++it;
continue;
}
typedef itk::DiffusionTensor3D<double> TensorType;
TensorType::EigenValuesArrayType eigenvalues;
TensorType::EigenVectorsMatrixType eigenvectors;
TensorType tensor = it.Get();
double FA = tensor.GetFractionalAnisotropy();
double ADC = adcImage->GetPixel(it.GetIndex());
QballFilterType::CoefficientImageType::PixelType itkv = itkFeatureImage->GetPixel(it.GetIndex());
vnl_vector_fixed< double, NumCoeffs > coeffs;
for (unsigned int c=0; c<itkv.Size(); c++)
coeffs[c] = itkv[c]/max;
if ( this->GetMaxNumKernels()>this->GetNumberOfKernels() && FA>m_FaRange.first && FA<m_FaRange.second && ADC>m_AdcRange.first && ADC<m_AdcRange.second)
{
- if (this->SetShCoefficients( coeffs, (double)diffImg->GetVectorImage()->GetPixel(it.GetIndex())[b0Index]/max ))
+ if (this->SetShCoefficients( coeffs, (double)itkVectorImagePointer->GetPixel(it.GetIndex())[b0Index]/max ))
{
tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
itk::Vector<double,3> dir;
dir[0] = eigenvectors(2, 0);
dir[1] = eigenvectors(2, 1);
dir[2] = eigenvectors(2, 2);
m_PrototypeMaxDirection.push_back(dir);
count++;
MITK_INFO << "KERNEL: " << it.GetIndex() << " (" << count << ")";
}
}
++it;
}
if (m_ShCoefficients.size()>0)
return true;
return false;
}
// convert cartesian to spherical coordinates
template< class ScalarType >
void RawShModel< ScalarType >::Cart2Sph( GradientListType gradients )
{
m_SphCoords.set_size(gradients.size(), 2);
m_SphCoords.fill(0.0);
for (unsigned int i=0; i<gradients.size(); i++)
{
GradientType g = gradients[i];
if( g.GetNorm() > 0.0001 )
{
gradients[i].Normalize();
m_SphCoords(i,0) = acos(gradients[i][2]); // theta
m_SphCoords(i,1) = atan2(gradients[i][1], gradients[i][0]); // phi
}
}
}
template< class ScalarType >
void RawShModel< ScalarType >::SetFiberDirection(GradientType fiberDirection)
{
this->m_FiberDirection = fiberDirection;
this->m_FiberDirection.Normalize();
RandomModel();
GradientType axis = itk::CrossProduct(this->m_FiberDirection, m_PrototypeMaxDirection.at(m_ModelIndex));
axis.Normalize();
vnl_quaternion<double> rotation(axis.GetVnlVector(), acos(dot_product(this->m_FiberDirection.GetVnlVector(), m_PrototypeMaxDirection.at(m_ModelIndex).GetVnlVector())));
rotation.normalize();
GradientListType gradients;
for (unsigned int i=0; i<this->m_GradientList.size(); i++)
{
GradientType dir = this->m_GradientList.at(i);
if( dir.GetNorm() > 0.0001 )
{
dir.Normalize();
vnl_vector_fixed< double, 3 > vnlDir = rotation.rotate(dir.GetVnlVector());
dir[0] = vnlDir[0]; dir[1] = vnlDir[1]; dir[2] = vnlDir[2];
dir.Normalize();
}
gradients.push_back(dir);
}
Cart2Sph( gradients );
}
template< class ScalarType >
bool RawShModel< ScalarType >::SetShCoefficients(vnl_vector< double > shCoefficients, double b0 )
{
m_ShOrder = 2;
while ( (m_ShOrder*m_ShOrder + m_ShOrder + 2)/2 + m_ShOrder <= shCoefficients.size() )
m_ShOrder += 2;
m_ShOrder -= 2;
m_ModelIndex = m_B0Signal.size();
m_B0Signal.push_back(b0);
m_ShCoefficients.push_back(shCoefficients);
// itk::OrientationDistributionFunction<double, 10000> odf;
// GradientListType gradients;
// for (unsigned int i=0; i<odf.GetNumberOfComponents(); i++)
// {
// GradientType dir; dir[0]=odf.GetDirection(i)[0]; dir[1]=odf.GetDirection(i)[1]; dir[2]=odf.GetDirection(i)[2];
// dir.Normalize();
// gradients.push_back(dir);
// }
// Cart2Sph( this->m_GradientList );
// PixelType signal = SimulateMeasurement();
// int minDirIdx = 0;
// double min = itk::NumericTraits<double>::max();
// for (unsigned int i=0; i<signal.GetSize(); i++)
// {
// if (signal[i]>b0 || signal[i]<0)
// {
// MITK_INFO << "Corrupted signal value detected. Kernel rejected.";
// m_B0Signal.pop_back();
// m_ShCoefficients.pop_back();
// return false;
// }
// if (signal[i]<min)
// {
// min = signal[i];
// minDirIdx = i;
// }
// }
// GradientType maxDir = this->m_GradientList.at(minDirIdx);
// maxDir.Normalize();
// m_PrototypeMaxDirection.push_back(maxDir);
Cart2Sph( this->m_GradientList );
m_ModelIndex = -1;
return true;
}
template< class ScalarType >
ScalarType RawShModel< ScalarType >::SimulateMeasurement(unsigned int dir)
{
ScalarType signal = 0;
if (m_ModelIndex==-1)
RandomModel();
if (dir>=this->m_GradientList.size())
return signal;
int j, m; double mag, plm;
if (this->m_GradientList[dir].GetNorm()>0.001)
{
j=0;
for (int l=0; l<=m_ShOrder; l=l+2)
for (m=-l; m<=l; m++)
{
plm = legendre_p<double>(l,abs(m),cos(m_SphCoords(dir,0)));
mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
double basis;
if (m<0)
basis = sqrt(2.0)*mag*cos(fabs((double)m)*m_SphCoords(dir,1));
else if (m==0)
basis = mag;
else
basis = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*m_SphCoords(dir,1));
signal += m_ShCoefficients.at(m_ModelIndex)[j]*basis;
j++;
}
}
else
signal = m_B0Signal.at(m_ModelIndex);
m_ModelIndex = -1;
return signal;
}
template< class ScalarType >
typename RawShModel< ScalarType >::PixelType RawShModel< ScalarType >::SimulateMeasurement()
{
if (m_ModelIndex==-1)
RandomModel();
PixelType signal;
signal.SetSize(this->m_GradientList.size());
int M = this->m_GradientList.size();
int j, m; double mag, plm;
vnl_matrix< double > shBasis;
shBasis.set_size(M, m_ShCoefficients.at(m_ModelIndex).size());
shBasis.fill(0.0);
for (int p=0; p<M; p++)
{
if (this->m_GradientList[p].GetNorm()>0.001)
{
j=0;
for (int l=0; l<=m_ShOrder; l=l+2)
for (m=-l; m<=l; m++)
{
plm = legendre_p<double>(l,abs(m),cos(m_SphCoords(p,0)));
mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
if (m<0)
shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*m_SphCoords(p,1));
else if (m==0)
shBasis(p,j) = mag;
else
shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*m_SphCoords(p,1));
j++;
}
double val = 0;
for (unsigned int cidx=0; cidx<m_ShCoefficients.at(m_ModelIndex).size(); cidx++)
val += m_ShCoefficients.at(m_ModelIndex)[cidx]*shBasis(p,cidx);
signal[p] = val;
}
else
signal[p] = m_B0Signal.at(m_ModelIndex);
}
m_ModelIndex = -1;
return signal;
}
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
index 3fb5676395..1b03403ca7 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
@@ -1,114 +1,114 @@
/*===================================================================
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 _MITK_RawShModel_H
#define _MITK_RawShModel_H
#include <mitkDiffusionSignalModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
namespace mitk {
/**
* \brief The spherical harmonic representation of a prototype diffusion weighted MR signal is used to obtain the direction dependent signal.
*
*/
template< class ScalarType = double >
class RawShModel : public DiffusionSignalModel< ScalarType >
{
public:
RawShModel();
template< class OtherType >RawShModel(RawShModel<OtherType>* model)
{
this->m_CompartmentId = model->m_CompartmentId;
this->m_T2 = model->GetT2();
this->m_FiberDirection = model->GetFiberDirection();
this->m_GradientList = model->GetGradientList();
this->m_VolumeFractionImage = model->GetVolumeFractionImage();
this->m_RandGen = model->GetRandomGenerator();
this->m_AdcRange = model->GetAdcRange();
this->m_FaRange = model->GetFaRange();
this->m_ShCoefficients = model->GetShCoefficients();
this->m_B0Signal = model->GetB0Signals();
this->m_SphCoords = model->GetSphericalCoordinates();
this->m_ShOrder = model->GetShOrder();
this->m_ModelIndex = model->GetModelIndex();
this->m_MaxNumKernels = model->GetMaxNumKernels();
}
~RawShModel();
typedef itk::Image< double, 3 > ItkDoubleImageType;
typedef itk::Image< unsigned char, 3 > ItkUcharImageType;
typedef itk::Image< itk::DiffusionTensor3D< double >, 3 > TensorImageType;
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,2,QBALL_ODFSIZE> QballFilterType;
typedef typename DiffusionSignalModel< ScalarType >::PixelType PixelType;
typedef typename DiffusionSignalModel< ScalarType >::GradientType GradientType;
typedef typename DiffusionSignalModel< ScalarType >::GradientListType GradientListType;
typedef itk::Matrix< double, 3, 3 > MatrixType;
/** Actual signal generation **/
PixelType SimulateMeasurement();
ScalarType SimulateMeasurement(unsigned int dir);
bool SetShCoefficients(vnl_vector< double > shCoefficients, double b0);
void SetFiberDirection(GradientType fiberDirection);
void SetGradientList(GradientListType gradientList) { this->m_GradientList = gradientList; }
void SetFaRange(double min, double max){ m_FaRange.first = min; m_FaRange.second = max; }
void SetAdcRange(double min, double max){ m_AdcRange.first = min; m_AdcRange.second = max; }
void SetMaxNumKernels(unsigned int max){ m_MaxNumKernels = max; }
unsigned int GetNumberOfKernels();
std::pair< double, double > GetFaRange(){ return m_FaRange; }
std::pair< double, double > GetAdcRange(){ return m_AdcRange; }
unsigned int GetMaxNumKernels(){ return m_MaxNumKernels; }
void Clear();
std::vector< vnl_vector< double > > GetShCoefficients(){ return m_ShCoefficients; }
std::vector< double > GetB0Signals(){ return m_B0Signal; }
vnl_matrix<double> GetSphericalCoordinates(){ return m_SphCoords; }
unsigned int GetShOrder(){ return m_ShOrder; }
int GetModelIndex(){ return m_ModelIndex; }
double GetBaselineSignal(int index){ return m_B0Signal.at(index); }
vnl_vector< double > GetCoefficients(int listIndex){ return m_ShCoefficients.at(listIndex); }
- bool SampleKernels(DiffusionImage<short>::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage=NULL, QballFilterType::CoefficientImageType::Pointer coeffImage=NULL, ItkDoubleImageType::Pointer adcImage=NULL);
+ bool SampleKernels(Image::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage=NULL, QballFilterType::CoefficientImageType::Pointer coeffImage=NULL, ItkDoubleImageType::Pointer adcImage=NULL);
protected:
void Cart2Sph( GradientListType gradients );
void RandomModel();
std::vector< vnl_vector< double > > m_ShCoefficients;
std::vector< double > m_B0Signal;
std::vector< GradientType > m_PrototypeMaxDirection;
vnl_matrix<double> m_SphCoords;
std::pair< double, double > m_AdcRange;
std::pair< double, double > m_FaRange;
unsigned int m_ShOrder;
int m_ModelIndex;
unsigned int m_MaxNumKernels;
};
}
#include "mitkRawShModel.cpp"
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
index 3b03f3f67d..c51a305cf8 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
@@ -1,14 +1,14 @@
MITK_CREATE_MODULE_TESTS()
if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
mitkAddCustomModuleTest(mitkFiberBundleXReaderWriterTest mitkFiberBundleXReaderWriterTest)
mitkAddCustomModuleTest(mitkGibbsTrackingTest mitkGibbsTrackingTest ${MITK_DATA_DIR}/DiffusionImaging/qBallImage.qbi ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/gibbsTrackingParameters.gtp ${MITK_DATA_DIR}/DiffusionImaging/gibbsTractogram.fib)
mitkAddCustomModuleTest(mitkStreamlineTrackingTest mitkStreamlineTrackingTest ${MITK_DATA_DIR}/DiffusionImaging/tensorImage.dti ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/streamlineTractogramInterpolated.fib)
#mitkAddCustomModuleTest(mitkPeakExtractionTest mitkPeakExtractionTest ${MITK_DATA_DIR}/DiffusionImaging/qBallImage_SHCoeffs.nrrd ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/qBallImage_VectorField.fib)
mitkAddCustomModuleTest(mitkLocalFiberPlausibilityTest mitkLocalFiberPlausibilityTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/LDFP_GT_DIRECTION_0.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_GT_DIRECTION_1.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_ERROR_IMAGE.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_NUM_DIRECTIONS.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_VECTOR_FIELD.fib ${MITK_DATA_DIR}/DiffusionImaging/LDFP_ERROR_IMAGE_IGNORE.nrrd)
mitkAddCustomModuleTest(mitkFiberTransformationTest mitkFiberTransformationTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_transformed.fib)
mitkAddCustomModuleTest(mitkFiberExtractionTest mitkFiberExtractionTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_extracted.fib ${MITK_DATA_DIR}/DiffusionImaging/ROI1.pf ${MITK_DATA_DIR}/DiffusionImaging/ROI2.pf ${MITK_DATA_DIR}/DiffusionImaging/ROI3.pf ${MITK_DATA_DIR}/DiffusionImaging/ROIIMAGE.nrrd ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_inside.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_outside.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_passing-mask.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_ending-in-mask.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_subtracted.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_added.fib)
mitkAddCustomModuleTest(mitkFiberGenerationTest mitkFiberGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_0.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_1.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_2.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/uniform.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib)
-mitkAddCustomModuleTest(mitkFiberfoxSignalGenerationTest mitkFiberfoxSignalGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickAstrosticks_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickDot_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/TensorBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBallAstrosticks_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gibbsringing.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/ghost.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/aliasing.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/eddy.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/linearmotion.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/randommotion.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/spikes.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/riciannoise.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/chisquarenoise.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/distortions.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fieldmap.nrrd)
+mitkAddCustomModuleTest(mitkFiberfoxSignalGenerationTest mitkFiberfoxSignalGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickBall_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickAstrosticks_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickDot_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/TensorBall_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBall_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBallAstrosticks_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gibbsringing.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/ghost.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/aliasing.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/eddy.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/linearmotion.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/randommotion.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/spikes.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/riciannoise.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/chisquarenoise.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/distortions.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fieldmap.nrrd)
mitkAddCustomModuleTest(mitkFiberfoxAddArtifactsToDwiTest mitkFiberfoxAddArtifactsToDwiTest)
ENDIF()
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
index 5f991c3fc1..53622ec71b 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
@@ -1,182 +1,199 @@
/*===================================================================
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 <mitkTestingMacros.h>
#include <mitkIOUtil.h>
#include <mitkFiberBundleX.h>
#include <itkAddArtifactsToDwiImageFilter.h>
#include <mitkFiberfoxParameters.h>
#include <mitkStickModel.h>
#include <mitkTensorModel.h>
#include <mitkBallModel.h>
#include <mitkDotModel.h>
#include <mitkAstroStickModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <itkTestingComparisonImageFilter.h>
#include <itkImageRegionConstIterator.h>
#include <mitkRicianNoiseModel.h>
#include <mitkChiSquareNoiseModel.h>
#include <mitkTestFixture.h>
+#include <mitkITKImageImport.h>
+#include <mitkProperties.h>
+#include <mitkImageCast.h>
+
+typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
/**Documentation
* Test the Fiberfox simulation functions (diffusion weighted image -> diffusion weighted image)
*/
class mitkFiberfoxAddArtifactsToDwiTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkFiberfoxAddArtifactsToDwiTestSuite);
MITK_TEST(Spikes);
MITK_TEST(GibbsRinging);
MITK_TEST(Ghost);
MITK_TEST(Aliasing);
MITK_TEST(Eddy);
MITK_TEST(RicianNoise);
MITK_TEST(ChiSquareNoise);
MITK_TEST(Distortions);
CPPUNIT_TEST_SUITE_END();
private:
- mitk::DiffusionImage<short>::Pointer m_InputDwi;
+ mitk::Image::Pointer m_InputDwi;
FiberfoxParameters<short> m_Parameters;
public:
void setUp()
{
// reference files
- m_InputDwi = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(GetTestDataFilePath("DiffusionImaging/Fiberfox/StickBall_RELAX.dwi"))->GetData());
+ m_InputDwi = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(GetTestDataFilePath("DiffusionImaging/Fiberfox/StickBall_RELAX.dwi"))->GetData());
// parameter setup
+
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(m_InputDwi, itkVectorImagePointer);
+
m_Parameters = FiberfoxParameters<short>();
- m_Parameters.m_SignalGen.m_ImageRegion = m_InputDwi->GetVectorImage()->GetLargestPossibleRegion();
- m_Parameters.m_SignalGen.m_ImageSpacing = m_InputDwi->GetVectorImage()->GetSpacing();
- m_Parameters.m_SignalGen.m_ImageOrigin = m_InputDwi->GetVectorImage()->GetOrigin();
- m_Parameters.m_SignalGen.m_ImageDirection = m_InputDwi->GetVectorImage()->GetDirection();
- m_Parameters.m_SignalGen.m_Bvalue = m_InputDwi->GetReferenceBValue();
- m_Parameters.m_SignalGen.SetGradienDirections(m_InputDwi->GetDirections());
+ m_Parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
+ m_Parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
+ m_Parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
+ m_Parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
+ m_Parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(m_InputDwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+ m_Parameters.m_SignalGen.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>( m_InputDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
}
bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
{
typedef itk::VectorImage< short, 3 > DwiImageType;
try{
itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
while(!it1.IsAtEnd())
{
if (it1.Get()!=it2.Get())
return false;
++it1;
++it2;
}
}
catch(...)
{
return false;
}
return true;
}
void StartSimulation(string testFileName)
{
- mitk::DiffusionImage<short>::Pointer refImage = NULL;
+ mitk::Image::Pointer refImage = NULL;
if (!testFileName.empty())
- CPPUNIT_ASSERT(refImage = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(testFileName)->GetData()));
+ CPPUNIT_ASSERT(refImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(testFileName)->GetData()));
+
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(m_InputDwi, itkVectorImagePointer);
itk::AddArtifactsToDwiImageFilter< short >::Pointer artifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
artifactsToDwiFilter->SetUseConstantRandSeed(true);
- artifactsToDwiFilter->SetInput(m_InputDwi->GetVectorImage());
+ artifactsToDwiFilter->SetInput(itkVectorImagePointer);
artifactsToDwiFilter->SetParameters(m_Parameters);
CPPUNIT_ASSERT_NO_THROW(artifactsToDwiFilter->Update());
- mitk::DiffusionImage<short>::Pointer testImage = mitk::DiffusionImage<short>::New();
- testImage->SetVectorImage( artifactsToDwiFilter->GetOutput() );
- testImage->SetReferenceBValue( m_Parameters.m_SignalGen.m_Bvalue);
- testImage->SetDirections( m_Parameters.m_SignalGen.GetGradientDirections());
- testImage->InitializeFromVectorImage();
+ mitk::Image::Pointer testImage = mitk::GrabItkImageMemory( artifactsToDwiFilter->GetOutput() );
+ testImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( m_Parameters.m_SignalGen.GetGradientDirections() ) );
+ testImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( m_Parameters.m_SignalGen.m_Bvalue ) );
+ mitk::DiffusionPropertyHelper propertyHelper( testImage );
+ propertyHelper.InitializeImage();
if (refImage.IsNotNull())
{
- if (!CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage()))
- mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
- CPPUNIT_ASSERT_MESSAGE(testFileName, CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage()));
+ ITKDiffusionImageType::Pointer itkTestVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(testImage, itkTestVectorImagePointer);
+ ITKDiffusionImageType::Pointer itkRefVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(refImage, itkRefVectorImagePointer);
+ if (!CompareDwi( itkTestVectorImagePointer, itkRefVectorImagePointer))
+ mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
+
+ CPPUNIT_ASSERT_MESSAGE(testFileName, CompareDwi( itkTestVectorImagePointer, itkRefVectorImagePointer));
}
}
void Spikes()
{
m_Parameters.m_SignalGen.m_Spikes = 5;
m_Parameters.m_SignalGen.m_SpikeAmplitude = 1;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/spikes2.dwi") );
}
void GibbsRinging()
{
m_Parameters.m_SignalGen.m_DoAddGibbsRinging = true;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/gibbsringing2.dwi") );
}
void Ghost()
{
m_Parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/ghost2.dwi") );
}
void Aliasing()
{
m_Parameters.m_SignalGen.m_CroppingFactor = 0.4;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/aliasing2.dwi") );
}
void Eddy()
{
m_Parameters.m_SignalGen.m_EddyStrength = 0.05;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/eddy2.dwi") );
}
void RicianNoise()
{
mitk::RicianNoiseModel<short>* ricianNoiseModel = new mitk::RicianNoiseModel<short>();
ricianNoiseModel->SetNoiseVariance(1000000);
ricianNoiseModel->SetSeed(0);
m_Parameters.m_NoiseModel = ricianNoiseModel;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/riciannoise2.dwi") );
delete m_Parameters.m_NoiseModel;
}
void ChiSquareNoise()
{
mitk::ChiSquareNoiseModel<short>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<short>();
chiSquareNoiseModel->SetNoiseVariance(1000000);
chiSquareNoiseModel->SetSeed(0);
m_Parameters.m_NoiseModel = chiSquareNoiseModel;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/chisquarenoise2.dwi") );
delete m_Parameters.m_NoiseModel;
}
void Distortions()
{
mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode( GetTestDataFilePath("DiffusionImaging/Fiberfox/Fieldmap.nrrd") )->GetData());
typedef itk::Image<double, 3> ItkDoubleImgType;
ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
mitk::CastToItkImage(mitkFMap, fMap);
m_Parameters.m_SignalGen.m_FrequencyMap = fMap;
StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/distortions2.dwi") );
}
};
MITK_TEST_SUITE_REGISTRATION(mitkFiberfoxAddArtifactsToDwi)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
index 2e0ae2c4b5..1e73c01dce 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
@@ -1,273 +1,293 @@
/*===================================================================
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 <mitkTestingMacros.h>
#include <mitkIOUtil.h>
#include <mitkFiberBundleX.h>
#include <itkTractsToDWIImageFilter.h>
#include <mitkFiberfoxParameters.h>
#include <mitkStickModel.h>
#include <mitkTensorModel.h>
#include <mitkBallModel.h>
#include <mitkDotModel.h>
#include <mitkAstroStickModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <itkTestingComparisonImageFilter.h>
#include <itkImageRegionConstIterator.h>
#include <mitkRicianNoiseModel.h>
#include <mitkChiSquareNoiseModel.h>
#include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkProperties.h>
+#include <mitkITKImageImport.h>
+#include <mitkImageCast.h>
+
+#include <itkVectorImage.h>
+
+typedef itk::VectorImage< short, 3> ItkDwiType;
/**Documentation
* Test the Fiberfox simulation functions (fiberBundle -> diffusion weighted image)
*/
bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
{
typedef itk::VectorImage< short, 3 > DwiImageType;
try{
itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
while(!it1.IsAtEnd())
{
if (it1.Get()!=it2.Get())
return false;
++it1;
++it2;
}
}
catch(...)
{
return false;
}
return true;
}
-void StartSimulation(FiberfoxParameters<double> parameters, FiberBundleX::Pointer fiberBundle, mitk::DiffusionImage<short>::Pointer refImage, string message)
+void StartSimulation(FiberfoxParameters<double> parameters, FiberBundleX::Pointer fiberBundle, mitk::Image::Pointer refImage, string message)
{
itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
tractsToDwiFilter->SetUseConstantRandSeed(true);
tractsToDwiFilter->SetParameters(parameters);
tractsToDwiFilter->SetFiberBundle(fiberBundle);
tractsToDwiFilter->Update();
- mitk::DiffusionImage<short>::Pointer testImage = mitk::DiffusionImage<short>::New();
- testImage->SetVectorImage( tractsToDwiFilter->GetOutput() );
- testImage->SetReferenceBValue(parameters.m_SignalGen.m_Bvalue);
- testImage->SetDirections(parameters.m_SignalGen.GetGradientDirections());
- testImage->InitializeFromVectorImage();
+ mitk::Image::Pointer testImage = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
+ testImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
+ testImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
+
+ mitk::DiffusionPropertyHelper propertyHelper( testImage );
+ propertyHelper.InitializeImage();
if (refImage.IsNotNull())
{
- bool cond = CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage());
+ if( static_cast<mitk::GradientDirectionsProperty*>( refImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer().IsNotNull() )
+ {
+ ItkDwiType::Pointer itkTestImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(testImage, itkTestImagePointer);
+ ItkDwiType::Pointer itkRefImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(refImage, itkRefImagePointer);
+
+ bool cond = CompareDwi(itkTestImagePointer, itkRefImagePointer);
if (!cond)
{
- MITK_INFO << "Saving test and rference image to " << mitk::IOUtil::GetTempPath();
- mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
- mitk::IOUtil::SaveBaseData(refImage, mitk::IOUtil::GetTempPath()+"refImage.dwi");
+ MITK_INFO << "Saving test and rference image to " << mitk::IOUtil::GetTempPath();
+ mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.nrrd");
+ mitk::IOUtil::SaveBaseData(refImage, mitk::IOUtil::GetTempPath()+"refImage.nrrd");
}
MITK_TEST_CONDITION_REQUIRED(cond, message);
+ }
}
}
int mitkFiberfoxSignalGenerationTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkFiberfoxSignalGenerationTest");
MITK_TEST_CONDITION_REQUIRED(argc>=19,"check for input data");
// input fiber bundle
FiberBundleX::Pointer fiberBundle = dynamic_cast<FiberBundleX*>(mitk::IOUtil::Load(argv[1])[0].GetPointer());
// reference diffusion weighted images
- mitk::DiffusionImage<short>::Pointer stickBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
- mitk::DiffusionImage<short>::Pointer stickAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
- mitk::DiffusionImage<short>::Pointer stickDot = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
- mitk::DiffusionImage<short>::Pointer tensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
- mitk::DiffusionImage<short>::Pointer stickTensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
- mitk::DiffusionImage<short>::Pointer stickTensorBallAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
- mitk::DiffusionImage<short>::Pointer gibbsringing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
- mitk::DiffusionImage<short>::Pointer ghost = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
- mitk::DiffusionImage<short>::Pointer aliasing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
- mitk::DiffusionImage<short>::Pointer eddy = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
- mitk::DiffusionImage<short>::Pointer linearmotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
- mitk::DiffusionImage<short>::Pointer randommotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[13])->GetData());
- mitk::DiffusionImage<short>::Pointer spikes = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[14])->GetData());
- mitk::DiffusionImage<short>::Pointer riciannoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[15])->GetData());
- mitk::DiffusionImage<short>::Pointer chisquarenoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[16])->GetData());
- mitk::DiffusionImage<short>::Pointer distortions = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[17])->GetData());
+ mitk::Image::Pointer stickBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
+ mitk::Image::Pointer stickAstrosticks = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
+ mitk::Image::Pointer stickDot = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
+ mitk::Image::Pointer tensorBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
+ mitk::Image::Pointer stickTensorBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
+ mitk::Image::Pointer stickTensorBallAstrosticks = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
+ mitk::Image::Pointer gibbsringing = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
+ mitk::Image::Pointer ghost = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
+ mitk::Image::Pointer aliasing = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
+ mitk::Image::Pointer eddy = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
+ mitk::Image::Pointer linearmotion = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
+ mitk::Image::Pointer randommotion = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[13])->GetData());
+ mitk::Image::Pointer spikes = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[14])->GetData());
+ mitk::Image::Pointer riciannoise = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[15])->GetData());
+ mitk::Image::Pointer chisquarenoise = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[16])->GetData());
+ mitk::Image::Pointer distortions = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[17])->GetData());
mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[18])->GetData());
typedef itk::Image<double, 3> ItkDoubleImgType;
ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
mitk::CastToItkImage(mitkFMap, fMap);
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(stickBall, itkVectorImagePointer);
+
FiberfoxParameters<double> parameters;
parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
parameters.m_SignalGen.m_SignalScale = 10000;
- parameters.m_SignalGen.m_ImageRegion = stickBall->GetVectorImage()->GetLargestPossibleRegion();
- parameters.m_SignalGen.m_ImageSpacing = stickBall->GetVectorImage()->GetSpacing();
- parameters.m_SignalGen.m_ImageOrigin = stickBall->GetVectorImage()->GetOrigin();
- parameters.m_SignalGen.m_ImageDirection = stickBall->GetVectorImage()->GetDirection();
- parameters.m_SignalGen.m_Bvalue = stickBall->GetReferenceBValue();
- parameters.m_SignalGen.SetGradienDirections(stickBall->GetDirections());
+ parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
+ parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
+ parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
+ parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
+ parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(stickBall->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+ parameters.m_SignalGen.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>( stickBall->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
// intra and inter axonal compartments
mitk::StickModel<double> stickModel;
stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
stickModel.SetT2(110);
stickModel.SetDiffusivity(0.001);
stickModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
mitk::TensorModel<double> tensorModel;
tensorModel.SetT2(110);
stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
tensorModel.SetDiffusivity1(0.001);
tensorModel.SetDiffusivity2(0.00025);
tensorModel.SetDiffusivity3(0.00025);
tensorModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
// extra axonal compartment models
mitk::BallModel<double> ballModel;
ballModel.SetT2(80);
ballModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
ballModel.SetDiffusivity(0.001);
ballModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
mitk::AstroStickModel<double> astrosticksModel;
astrosticksModel.SetT2(80);
astrosticksModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
astrosticksModel.SetDiffusivity(0.001);
astrosticksModel.SetRandomizeSticks(true);
astrosticksModel.SetSeed(0);
astrosticksModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
mitk::DotModel<double> dotModel;
dotModel.SetT2(80);
dotModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
// noise models
mitk::RicianNoiseModel<double>* ricianNoiseModel = new mitk::RicianNoiseModel<double>();
ricianNoiseModel->SetNoiseVariance(1000000);
ricianNoiseModel->SetSeed(0);
// Rician noise
mitk::ChiSquareNoiseModel<double>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<double>();
chiSquareNoiseModel->SetNoiseVariance(1000000);
chiSquareNoiseModel->SetSeed(0);
try{
// Stick-Ball
parameters.m_FiberModelList.push_back(&stickModel);
parameters.m_NonFiberModelList.push_back(&ballModel);
StartSimulation(parameters, fiberBundle, stickBall, argv[2]);
// Srick-Astrosticks
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&astrosticksModel);
StartSimulation(parameters, fiberBundle, stickAstrosticks, argv[3]);
// Stick-Dot
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&dotModel);
StartSimulation(parameters, fiberBundle, stickDot, argv[4]);
// Tensor-Ball
parameters.m_FiberModelList.clear();
parameters.m_FiberModelList.push_back(&tensorModel);
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&ballModel);
StartSimulation(parameters, fiberBundle, tensorBall, argv[5]);
// Stick-Tensor-Ball
parameters.m_FiberModelList.clear();
parameters.m_FiberModelList.push_back(&stickModel);
parameters.m_FiberModelList.push_back(&tensorModel);
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&ballModel);
StartSimulation(parameters, fiberBundle, stickTensorBall, argv[6]);
// Stick-Tensor-Ball-Astrosticks
parameters.m_NonFiberModelList.push_back(&astrosticksModel);
StartSimulation(parameters, fiberBundle, stickTensorBallAstrosticks, argv[7]);
// Gibbs ringing
parameters.m_FiberModelList.clear();
parameters.m_FiberModelList.push_back(&stickModel);
parameters.m_NonFiberModelList.clear();
parameters.m_NonFiberModelList.push_back(&ballModel);
parameters.m_SignalGen.m_DoAddGibbsRinging = true;
StartSimulation(parameters, fiberBundle, gibbsringing, argv[8]);
// Ghost
parameters.m_SignalGen.m_DoAddGibbsRinging = false;
parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
StartSimulation(parameters, fiberBundle, ghost, argv[9]);
// Aliasing
parameters.m_SignalGen.m_KspaceLineOffset = 0;
parameters.m_SignalGen.m_CroppingFactor = 0.4;
parameters.m_SignalGen.m_SignalScale = 1000;
StartSimulation(parameters, fiberBundle, aliasing, argv[10]);
// Eddy currents
parameters.m_SignalGen.m_CroppingFactor = 1;
parameters.m_SignalGen.m_SignalScale = 10000;
parameters.m_SignalGen.m_EddyStrength = 0.05;
StartSimulation(parameters, fiberBundle, eddy, argv[11]);
// Motion (linear)
parameters.m_SignalGen.m_EddyStrength = 0.0;
parameters.m_SignalGen.m_DoAddMotion = true;
parameters.m_SignalGen.m_DoRandomizeMotion = false;
parameters.m_SignalGen.m_Translation[1] = 10;
parameters.m_SignalGen.m_Rotation[2] = 90;
StartSimulation(parameters, fiberBundle, linearmotion, argv[12]);
// Motion (random)
parameters.m_SignalGen.m_DoRandomizeMotion = true;
parameters.m_SignalGen.m_Translation[1] = 5;
parameters.m_SignalGen.m_Rotation[2] = 45;
StartSimulation(parameters, fiberBundle, randommotion, argv[13]);
// Spikes
parameters.m_SignalGen.m_DoAddMotion = false;
parameters.m_SignalGen.m_Spikes = 5;
parameters.m_SignalGen.m_SpikeAmplitude = 1;
StartSimulation(parameters, fiberBundle, spikes, argv[14]);
// Rician noise
parameters.m_SignalGen.m_Spikes = 0;
parameters.m_NoiseModel = ricianNoiseModel;
StartSimulation(parameters, fiberBundle, riciannoise, argv[15]);
delete parameters.m_NoiseModel;
// Chi-square noise
parameters.m_NoiseModel = chiSquareNoiseModel;
StartSimulation(parameters, fiberBundle, chisquarenoise, argv[16]);
delete parameters.m_NoiseModel;
// Distortions
parameters.m_NoiseModel = NULL;
parameters.m_SignalGen.m_FrequencyMap = fMap;
StartSimulation(parameters, fiberBundle, distortions, argv[17]);
}
catch (std::exception &e)
{
MITK_TEST_CONDITION_REQUIRED(false, e.what());
}
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
index 4ee5ff9d27..6110dc612f 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
@@ -1,109 +1,108 @@
/*===================================================================
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 <itkImageFileWriter.h>
#include <itkResampleImageFilter.h>
#include <itkFiniteDiffOdfMaximaExtractionFilter.h>
#include <mitkBaseDataIOFactory.h>
-#include <mitkDiffusionImage.h>
#include <mitkQBallImage.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <mitkTensorImage.h>
#include <mitkCoreObjectFactory.h>
#include <itkShCoefficientImageImporter.h>
#include <itkFlipImageFilter.h>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <mitkTestingMacros.h>
#include <mitkIOUtil.h>
using namespace std;
int mitkPeakExtractionTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkStreamlineTrackingTest");
MITK_TEST_CONDITION_REQUIRED(argc>3,"check for input data")
string shCoeffFileName = argv[1];
string maskFileName = argv[2];
string referenceFileName = argv[3];
MITK_INFO << "SH-coefficient file: " << shCoeffFileName;
MITK_INFO << "Mask file: " << maskFileName;
MITK_INFO << "Reference fiber file: " << referenceFileName;
try
{
mitk::CoreObjectFactory::GetInstance();
mitk::Image::Pointer image = mitk::IOUtil::LoadImage(shCoeffFileName);
mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(maskFileName);
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, 4, 20242 > MaximaExtractionFilterType;
MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
MITK_INFO << "Casting mask image ...";
ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
mitk::CastToItkImage(mitkMaskImage, itkMask);
filter->SetMaskImage(itkMask);
MITK_INFO << "Casting SH image ...";
typedef mitk::ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(image);
caster->Update();
filter->SetInput(caster->GetOutput());
filter->SetMaxNumPeaks(2);
filter->SetPeakThreshold(0.4);
filter->SetAbsolutePeakThreshold(0.01);
filter->SetAngularThreshold(25);
filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
filter->SetNumberOfThreads(1);
MITK_INFO << "Starting extraction ...";
filter->Update();
mitk::FiberBundleX::Pointer fib1 = filter->GetOutputFiberBundle();
MITK_INFO << "Loading reference ...";
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( referenceFileName, s1, s2, false );
mitk::FiberBundleX::Pointer fib2 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
// TODO: reduce epsilon. strange issues with differing values between windows and linux.
MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "Check if tractograms are equal.");
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp b/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
index de9023fb32..7fb1ae16ac 100755
--- a/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
+++ b/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
@@ -1,86 +1,81 @@
/*===================================================================
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 <mitkImageCast.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkIOUtil.h>
#include "mitkCommandLineParser.h"
using namespace mitk;
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Copy Geometry");
parser.setCategory("Preprocessing Tools");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
parser.addArgument("ref", "r", mitkCommandLineParser::InputFile, "Reference:", "reference image", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
// mandatory arguments
string imageName = us::any_cast<string>(parsedArgs["in"]);
string refImage = us::any_cast<string>(parsedArgs["ref"]);
string outImage = us::any_cast<string>(parsedArgs["out"]);
try
{
const std::string s1="", s2="";
std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( refImage, s1, s2, false );
Image::Pointer source = dynamic_cast<Image*>(infile.at(0).GetPointer());
infile = BaseDataIO::LoadBaseDataFromFile( imageName, s1, s2, false );
Image::Pointer target = dynamic_cast<Image*>(infile.at(0).GetPointer());
mitk::BaseGeometry* s_geom = source->GetGeometry();
mitk::BaseGeometry* t_geom = target->GetGeometry();
t_geom->SetIndexToWorldTransform(s_geom->GetIndexToWorldTransform());
target->SetGeometry(t_geom);
- if ( dynamic_cast<DiffusionImage<short>*>(target.GetPointer()) )
- {
- mitk::IOUtil::Save(dynamic_cast<DiffusionImage<short>*>(target.GetPointer()), outImage.c_str());
- }
- else
- mitk::IOUtil::SaveImage(target, outImage);
+ mitk::IOUtil::Save(target.GetPointer(), outImage.c_str());
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp b/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
index f62f43f2c2..e84237b798 100644
--- a/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
+++ b/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
@@ -1,272 +1,277 @@
/*===================================================================
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 "mitkBaseDataIOFactory.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
#include "mitkBaseData.h"
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkITKImageImport.h>
#include <itkImageFileWriter.h>
#include <itkNrrdImageIO.h>
#include "mitkCommandLineParser.h"
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
#include "mitkDiffusionDICOMFileReader.h"
#include "mitkDICOMTagBasedSorter.h"
#include "mitkDICOMSortByTag.h"
#include "itkMergeDiffusionImagesFilter.h"
#include <mitkIOUtil.h>
static mitk::StringList& GetInputFilenames()
{
static mitk::StringList inputs;
return inputs;
}
void SetInputFileNames( std::string input_directory )
{
// I. Get all files in directory
itksys::Directory input;
input.Load( input_directory.c_str() );
// II. Push back files
mitk::StringList inputlist;//, mergedlist;
for( unsigned long idx=0; idx<input.GetNumberOfFiles(); idx++)
{
if( ! itksys::SystemTools::FileIsDirectory( input.GetFile(idx)) )
{
std::string fullpath = input_directory + "/" + std::string( input.GetFile(idx) );
inputlist.push_back( itksys::SystemTools::ConvertToOutputPath( fullpath.c_str() ) );
MITK_INFO("dicom.loader.inputdir.addfile") << input.GetFile(idx);
}
}
/*mergedlist.reserve( GetInputFilenames().size() + inputlist.size() );
mergedlist.insert( mergedlist.end(), GetInputFilenames().begin(), GetInputFilenames().end() );
mergedlist.insert( mergedlist.end(), inputlist.begin(), inputlist.end() );*/
GetInputFilenames() = inputlist;//mergedlist;
MITK_INFO("dicom.loader.setinputfiles.end") << "[]";
}
-mitk::DiffusionImage<short>::Pointer ReadInDICOMFiles( mitk::StringList& input_files, std::string output_file )
+mitk::Image::Pointer ReadInDICOMFiles( mitk::StringList& input_files, std::string output_file )
{
// repeat test with some more realistic sorting
mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New(); // this also tests destruction
mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
// Use tags as in Qmitk
// all the things that split by tag in DicomSeriesReader
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
mitk::DICOMSortCriterion::ConstPointer sorting =
mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0013), // instance number
mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012) //acquisition number
).GetPointer()
).GetPointer();
tagSorter->SetSortCriterion( sorting );
MITK_INFO("dicom.loader.read.init") << "[]" ;
MITK_INFO("dicom.loader.read.inputs") << " " << input_files.size();
gdcmReader->SetInputFiles( input_files );
gdcmReader->AddSortingElement( tagSorter );
gdcmReader->AnalyzeInputFiles();
gdcmReader->LoadImages();
mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(0).GetMitkImage();
- mitk::DiffusionImage<short>::Pointer d_img = static_cast<mitk::DiffusionImage<short>*>( loaded_image.GetPointer() );
-
- return d_img;
+ return loaded_image;
}
typedef short DiffusionPixelType;
typedef itk::VectorImage<DiffusionPixelType,3> DwiImageType;
typedef DwiImageType::PixelType DwiPixelType;
typedef DwiImageType::RegionType DwiRegionType;
typedef std::vector< DwiImageType::Pointer > DwiImageContainerType;
-typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
-typedef DiffusionImageType::GradientDirectionContainerType GradientContainerType;
+typedef mitk::Image DiffusionImageType;
+typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientContainerType;
typedef std::vector< GradientContainerType::Pointer > GradientListContainerType;
void SearchForInputInSubdirs( std::string root_directory, std::string subdir_prefix , std::vector<DiffusionImageType::Pointer>& output_container)
{
// I. Get all dirs in directory
itksys::Directory rootdir;
rootdir.Load( root_directory.c_str() );
MITK_INFO("dicom.loader.setinputdirs.start") << "Prefix = " << subdir_prefix;
for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
{
std::string current_path = rootdir.GetFile(idx);
std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath: " << current_path;
MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
<< " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
// test for prefix
if( itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
&& itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() )
)
{
MITK_INFO("dicom.loader.inputrootdir.searchin") << directory_path;
SetInputFileNames( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) );
MITK_INFO("dicom.loader.inputrootdir.preload") << "[]" ;
DiffusionImageType::Pointer dwi = ReadInDICOMFiles( GetInputFilenames(), "" );
output_container.push_back( dwi );
}
}
MITK_INFO("dicom.loader.setinputdirs.end") << "[]";
}
using namespace mitk;
/**
* Read DICOM Files through the new (refactored) Diffusion DICOM Loader. It serves also as a first test of the new functionality, it will replace the
* current loading mechanism after the necessary parts are merged into the master branch.
*/
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("inputdir", "i", mitkCommandLineParser::String, "Input Directory" ,"input directory containing dicom files", us::Any(), false);
parser.addArgument("output", "o", mitkCommandLineParser::String, "Output File Name", "output file", us::Any(), false);
parser.addArgument("dwprefix", "p", mitkCommandLineParser::String, "Recursive Scan Prefix", "prefix for subfolders search rootdir is specified by the 'inputdir' argument value", us::Any(), true);
parser.addArgument("dryrun", "-s", mitkCommandLineParser::Bool, "Dry run","do not read, only look for input files ", us::Any(), true );
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
{
return EXIT_FAILURE;
}
std::string inputDirectory = us::any_cast<std::string>( parsedArgs["inputdir"] );
MITK_INFO << "Loading data from directory: " << inputDirectory;
// retrieve the prefix flag (if set)
bool search_for_subdirs = false;
std::string subdir_prefix;
if( parsedArgs.count("dwprefix"))
{
MITK_INFO << "Prefix specified, will search for subdirs in the input directory!";
subdir_prefix = us::any_cast<std::string>( parsedArgs["dwprefix"] );
search_for_subdirs = true;
}
// retrieve the output
std::string outputFile = us::any_cast< std::string >( parsedArgs["output"] );
// if the executable is called with a single directory, just parse the given folder for files and read them into a diffusion image
if( !search_for_subdirs )
{
SetInputFileNames( inputDirectory );
MITK_INFO << "Got " << GetInputFilenames().size() << " input files.";
- mitk::DiffusionImage<short>::Pointer d_img = ReadInDICOMFiles( GetInputFilenames(), outputFile );
+ mitk::Image::Pointer d_img = ReadInDICOMFiles( GetInputFilenames(), outputFile );
try
{
mitk::IOUtil::Save(d_img, outputFile.c_str());
}
catch( const itk::ExceptionObject& e)
{
MITK_ERROR << "Failed to write out the output file. \n\t Reason : ITK Exception " << e.what();
}
}
// if the --dwprefix flag is set, then we have to look for the directories, load each of them separately and afterwards merge the images
else
{
- std::vector<mitk::DiffusionImage<DiffusionPixelType>::Pointer> output_container;
+ std::vector<mitk::Image::Pointer> output_container;
SearchForInputInSubdirs( inputDirectory, subdir_prefix, output_container );
// final output image
- mitk::DiffusionImage<DiffusionPixelType>::Pointer image = mitk::DiffusionImage<DiffusionPixelType>::New();
+ mitk::Image::Pointer image = mitk::Image::New();
if( output_container.size() > 1 )
{
DwiImageContainerType imageContainer;
GradientListContainerType gradientListContainer;
std::vector< double > bValueContainer;
- for ( std::vector< mitk::DiffusionImage<DiffusionPixelType>::Pointer >::iterator dwi = output_container.begin();
- dwi != output_container.end(); ++dwi )
+ for ( std::vector< mitk::Image::Pointer >::iterator dwi = output_container.begin();
+ dwi != output_container.end(); ++dwi )
{
- imageContainer.push_back((*dwi)->GetVectorImage());
- gradientListContainer.push_back((*dwi)->GetDirections());
- bValueContainer.push_back((*dwi)->GetReferenceBValue());
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(*dwi, itkVectorImagePointer);
+
+ imageContainer.push_back(itkVectorImagePointer);
+ gradientListContainer.push_back( mitk::DiffusionPropertyHelper::GetGradientContainer(*dwi));
+ bValueContainer.push_back( mitk::DiffusionPropertyHelper::GetReferenceBValue(*dwi));
}
typedef itk::MergeDiffusionImagesFilter<short> FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetImageVolumes(imageContainer);
filter->SetGradientLists(gradientListContainer);
filter->SetBValues(bValueContainer);
filter->Update();
vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue(filter->GetB_Value());
- image->SetDirections(filter->GetOutputGradients());
- image->SetMeasurementFrame(mf);
- image->InitializeFromVectorImage();
+ image = mitk::GrabItkImageMemory( filter->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradients() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetB_Value() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( mf ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
}
// just output the image if there was only one folder found
else
{
image = output_container.at(0);
}
MITK_INFO("dicom.import.writeout") << " [OutputFile] " << outputFile.c_str();
try
{
mitk::IOUtil::Save(image, outputFile.c_str());
}
catch( const itk::ExceptionObject& e)
{
MITK_ERROR << "Failed to write out the output file. \n\t Reason : ITK Exception " << e.what();
}
}
return 1;
}
diff --git a/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp b/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
index 83f8f18544..f30bfd5189 100644
--- a/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
+++ b/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
@@ -1,156 +1,163 @@
/*===================================================================
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 <mitkImageCast.h>
#include <mitkBaseDataIOFactory.h>
#include "mitkCommandLineParser.h"
#include <boost/algorithm/string.hpp>
-#include <DiffusionWeightedImages/mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <itkNonLocalMeansDenoisingFilter.h>
#include <itkImage.h>
#include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkITKImageImport.h>
+#include <mitkProperties.h>
-typedef mitk::DiffusionImage<short> DiffusionImageType;
+typedef mitk::Image DiffusionImageType;
typedef itk::Image<short, 3> ImageType;
mitk::BaseData::Pointer LoadFile(std::string filename)
{
if( filename.empty() )
return NULL;
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
if( infile.empty() )
{
std::cout << "File " << filename << " could not be read!";
return NULL;
}
mitk::BaseData::Pointer baseData = infile.at(0);
return baseData;
}
/**
* Denoises DWI using the Nonlocal - Means algorithm
*/
int main(int argc, char* argv[])
{
std::cout << "DwiDenoising";
mitkCommandLineParser parser;
parser.setTitle("DWI Denoising");
parser.setCategory("Preprocessing Tools");
parser.setContributor("MBI");
parser.setDescription("Denoising for diffusion weighted images using a non-local means algorithm.");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image (DWI)", us::Any(), false);
parser.addArgument("variance", "v", mitkCommandLineParser::Float, "Variance:", "noise variance", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "brainmask for input image", us::Any(), true);
parser.addArgument("search", "s", mitkCommandLineParser::Int, "Search radius:", "search radius", us::Any(), true);
parser.addArgument("compare", "c", mitkCommandLineParser::Int, "Comparison radius:", "comparison radius", us::Any(), true);
parser.addArgument("joint", "j", mitkCommandLineParser::Bool, "Joint information:", "use joint information");
parser.addArgument("rician", "r", mitkCommandLineParser::Bool, "Rician adaption:", "use rician adaption");
parser.changeParameterGroup("Output", "Output of this miniapp");
parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output:", "output image (DWI)", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
string inFileName = us::any_cast<string>(parsedArgs["input"]);
double variance = static_cast<double>(us::any_cast<float>(parsedArgs["variance"]));
string maskName;
if (parsedArgs.count("mask"))
maskName = us::any_cast<string>(parsedArgs["mask"]);
string outFileName = us::any_cast<string>(parsedArgs["output"]);
// boost::algorithm::erase_all(outFileName, ".dwi");
int search = 4;
if (parsedArgs.count("search"))
search = us::any_cast<int>(parsedArgs["search"]);
int compare = 1;
if (parsedArgs.count("compare"))
compare = us::any_cast<int>(parsedArgs["compare"]);
bool joint = false;
if (parsedArgs.count("joint"))
joint = true;
bool rician = false;
if (parsedArgs.count("rician"))
rician = true;
try
{
if( boost::algorithm::ends_with(inFileName, ".dwi"))
{
DiffusionImageType::Pointer dwi = dynamic_cast<DiffusionImageType*>(LoadFile(inFileName).GetPointer());
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
itk::NonLocalMeansDenoisingFilter<short>::Pointer filter = itk::NonLocalMeansDenoisingFilter<short>::New();
filter->SetNumberOfThreads(12);
- filter->SetInputImage(dwi->GetVectorImage());
+ filter->SetInputImage( itkVectorImagePointer );
if (!maskName.empty())
{
mitk::Image::Pointer mask = dynamic_cast<mitk::Image*>(LoadFile(maskName).GetPointer());
ImageType::Pointer itkMask = ImageType::New();
mitk::CastToItkImage(mask, itkMask);
filter->SetInputMask(itkMask);
}
filter->SetUseJointInformation(joint);
filter->SetUseRicianAdaption(rician);
filter->SetSearchRadius(search);
filter->SetComparisonRadius(compare);
filter->SetVariance(variance);
filter->Update();
- DiffusionImageType::Pointer output = DiffusionImageType::New();
- output->SetVectorImage(filter->GetOutput());
- output->SetReferenceBValue(dwi->GetReferenceBValue());
- output->SetDirections(dwi->GetDirections());
- output->InitializeFromVectorImage();
+ DiffusionImageType::Pointer output = mitk::GrabItkImageMemory( filter->GetOutput() );
+ output->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi) ) );
+ output->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi) ) );
+ mitk::DiffusionPropertyHelper propertyHelper( output );
+ propertyHelper.InitializeImage();
// std::stringstream name;
// name << outFileName << "_NLM_" << search << "-" << compare << "-" << variance << ".dwi";
mitk::IOUtil::Save(output, outFileName.c_str());
}
else
{
std::cout << "Only supported for .dwi!";
}
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
index 3bf5e834b8..c50a85159d 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
@@ -1,174 +1,174 @@
/*===================================================================
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 <mitkBaseDataIOFactory.h>
#include <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <metaCommand.h>
#include "mitkCommandLineParser.h"
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <itkEvaluateDirectionImagesFilter.h>
#include <itkTractsToVectorImageFilter.h>
#include <mitkCoreObjectFactory.h>
#define _USE_MATH_DEFINES
#include <math.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Fiber Direction Extraction");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "mask image");
parser.addArgument("athresh", "a", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
parser.addArgument("peakthresh", "t", mitkCommandLineParser::Float, "Peak size threshold:", "peak size threshold relative to largest peak in voxel", 0.2, true);
parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
parser.addArgument("numdirs", "d", mitkCommandLineParser::Int, "Max. num. directions:", "maximum number of fibers per voxel", 3, true);
parser.addArgument("normalize", "n", mitkCommandLineParser::Bool, "Normalize:", "normalize vectors");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
string fibFile = us::any_cast<string>(parsedArgs["input"]);
string maskImage("");
if (parsedArgs.count("mask"))
maskImage = us::any_cast<string>(parsedArgs["mask"]);
float peakThreshold = 0.2;
if (parsedArgs.count("peakthresh"))
peakThreshold = us::any_cast<float>(parsedArgs["peakthresh"]);
float angularThreshold = 25;
if (parsedArgs.count("athresh"))
angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
string outRoot = us::any_cast<string>(parsedArgs["out"]);
bool verbose = false;
if (parsedArgs.count("verbose"))
verbose = us::any_cast<bool>(parsedArgs["verbose"]);
int maxNumDirs = 3;
if (parsedArgs.count("numdirs"))
maxNumDirs = us::any_cast<int>(parsedArgs["numdirs"]);
bool normalize = false;
if (parsedArgs.count("normalize"))
normalize = us::any_cast<bool>(parsedArgs["normalize"]);
try
{
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image< itk::Vector< float, 3>, 3 > ItkDirectionImage3DType;
typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer > ItkDirectionImageContainerType;
// load fiber bundle
mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
// load/create mask image
ItkUcharImgType::Pointer itkMaskImage = NULL;
if (maskImage.compare("")!=0)
{
std::cout << "Using mask image";
itkMaskImage = ItkUcharImgType::New();
mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
- mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
+ mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
}
// extract directions from fiber bundle
itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
fOdfFilter->SetFiberBundle(inputTractogram);
fOdfFilter->SetMaskImage(itkMaskImage);
fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
fOdfFilter->SetNormalizeVectors(normalize);
fOdfFilter->SetUseWorkingCopy(false);
fOdfFilter->SetSizeThreshold(peakThreshold);
fOdfFilter->SetMaxNumDirections(maxNumDirs);
fOdfFilter->Update();
ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
// write direction images
for (unsigned int i=0; i<directionImageContainer->Size(); i++)
{
itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_DIRECTION_");
outfilename.append(boost::lexical_cast<string>(i));
outfilename.append(".nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(itkImg);
writer->Update();
}
if (verbose)
{
// write vector field
mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
string outfilename = outRoot;
outfilename.append("_VECTOR_FIELD.fib");
mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
// write num direction image
{
ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_NUM_DIRECTIONS.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(numDirImage);
writer->Update();
}
}
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
index e767f81004..324fecfba2 100755
--- a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
@@ -1,78 +1,80 @@
/*===================================================================
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 <mitkImageCast.h>
-#include <mitkDiffusionImage.h>
+#include <mitkITKImageImport.h>
+#include <mitkProperties.h>
+#include <mitkImage.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkIOUtil.h>
#include <mitkFiberBundleX.h>
#include <mitkFiberfoxParameters.h>
#include "mitkCommandLineParser.h"
#include <itkAddArtifactsToDwiImageFilter.h>
#include <itkTractsToDWIImageFilter.h>
#include "boost/property_tree/ptree.hpp"
#include "boost/property_tree/xml_parser.hpp"
#include "boost/foreach.hpp"
/** TODO: Proritype signal komplett speichern oder bild mit speichern. */
/** TODO: Tarball aus images und parametern? */
/** TODO: Artefakte auf bild in miniapp */
using namespace mitk;
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output root:", "output root", us::Any(), false);
parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameter file:", "fiberfox parameter file", us::Any(), false);
parser.addArgument("fiberbundle", "f", mitkCommandLineParser::String, "Fiberbundle:", "", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
string outName = us::any_cast<string>(parsedArgs["out"]);
string paramName = us::any_cast<string>(parsedArgs["parameters"]);
string fibFile = "";
if (parsedArgs.count("fiberbundle"))
fibFile = us::any_cast<string>(parsedArgs["fiberbundle"]);
{
FiberfoxParameters<double> parameters;
parameters.LoadParameters(paramName);
mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
tractsToDwiFilter->SetParameters(parameters);
tractsToDwiFilter->SetFiberBundle(inputTractogram);
tractsToDwiFilter->Update();
- DiffusionImage<short>::Pointer image = DiffusionImage<short>::New();
- image->SetVectorImage( tractsToDwiFilter->GetOutput() );
- image->SetReferenceBValue( parameters.m_SignalGen.m_Bvalue );
- image->SetDirections( parameters.m_SignalGen.GetGradientDirections() );
- image->InitializeFromVectorImage();
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
mitk::IOUtil::Save(image, outName.c_str());
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp b/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
index faff7c6965..a05ce2419b 100644
--- a/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
+++ b/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
@@ -1,326 +1,314 @@
/*===================================================================
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 "mitkCommandLineParser.h"
#include <mitkIOUtil.h>
#include <mitkRegistrationWrapper.h>
#include <mitkImage.h>
#include <mitkImageCast.h>
#include <mitkITKImageImport.h>
-#include <mitkDiffusionImage.h>
#include <mitkImageTimeSelector.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkProperties.h>
// ITK
#include <itksys/SystemTools.hxx>
#include <itkDirectory.h>
#include "itkLinearInterpolateImageFunction.h"
#include "itkWindowedSincInterpolateImageFunction.h"
#include "itkIdentityTransform.h"
#include "itkResampleImageFilter.h"
#include "itkResampleDwiImageFilter.h"
typedef itk::Image<double, 3> InputImageType;
-typedef mitk::DiffusionImage<short> DiffusionImageType;
static mitk::Image::Pointer TransformToReference(mitk::Image *reference, mitk::Image *moving, bool sincInterpol = false)
{
// Convert to itk Images
InputImageType::Pointer itkReference = InputImageType::New();
InputImageType::Pointer itkMoving = InputImageType::New();
mitk::CastToItkImage(reference,itkReference);
mitk::CastToItkImage(moving,itkMoving);
// Identify Transform
typedef itk::IdentityTransform<double, 3> T_Transform;
T_Transform::Pointer _pTransform = T_Transform::New();
_pTransform->SetIdentity();
typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 3> WindowedSincInterpolatorType;
WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
typedef itk::ResampleImageFilter<InputImageType, InputImageType> ResampleFilterType;
ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetInput(itkMoving);
resampler->SetReferenceImage( itkReference );
resampler->UseReferenceImageOn();
resampler->SetTransform(_pTransform);
resampler->SetInterpolator(sinc_interpolator);
resampler->Update();
// Convert back to mitk
mitk::Image::Pointer result = mitk::Image::New();
result->InitializeByItk(resampler->GetOutput());
GrabItkImageMemory( resampler->GetOutput() , result );
return result;
}
static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim))
{
elems.push_back(item);
}
return elems;
}
static std::vector<std::string> split(const std::string &s, char delim)
{
std::vector < std::string > elems;
return split(s, delim, elems);
}
static mitk::Image::Pointer ResampleBySpacing(mitk::Image *input, float *spacing, bool useLinInt = true)
{
InputImageType::Pointer itkImage = InputImageType::New();
CastToItkImage(input,itkImage);
/**
* 1) Resampling
*
*/
// Identity transform.
// We don't want any transform on our image except rescaling which is not
// specified by a transform but by the input/output spacing as we will see
// later.
// So no transform will be specified.
typedef itk::IdentityTransform<double, 3> T_Transform;
// The resampler type itself.
typedef itk::ResampleImageFilter<InputImageType, InputImageType> T_ResampleFilter;
// Prepare the resampler.
// Instantiate the transform and specify it should be the id transform.
T_Transform::Pointer _pTransform = T_Transform::New();
_pTransform->SetIdentity();
// Instantiate the resampler. Wire in the transform and the interpolator.
T_ResampleFilter::Pointer _pResizeFilter = T_ResampleFilter::New();
// Specify the input.
_pResizeFilter->SetInput(itkImage);
_pResizeFilter->SetTransform(_pTransform);
// Set the output origin.
_pResizeFilter->SetOutputOrigin(itkImage->GetOrigin());
// Compute the size of the output.
// The size (# of pixels) in the output is recomputed using
// the ratio of the input and output sizes.
InputImageType::SpacingType inputSpacing = itkImage->GetSpacing();
InputImageType::SpacingType outputSpacing;
const InputImageType::RegionType& inputSize = itkImage->GetLargestPossibleRegion();
InputImageType::SizeType outputSize;
typedef InputImageType::SizeType::SizeValueType SizeValueType;
// Set the output spacing.
outputSpacing[0] = spacing[0];
outputSpacing[1] = spacing[1];
outputSpacing[2] = spacing[2];
outputSize[0] = static_cast<SizeValueType>(inputSize.GetSize()[0] * inputSpacing[0] / outputSpacing[0] + .5);
outputSize[1] = static_cast<SizeValueType>(inputSize.GetSize()[1] * inputSpacing[1] / outputSpacing[1] + .5);
outputSize[2] = static_cast<SizeValueType>(inputSize.GetSize()[2] * inputSpacing[2] / outputSpacing[2] + .5);
_pResizeFilter->SetOutputSpacing(outputSpacing);
_pResizeFilter->SetSize(outputSize);
typedef itk::LinearInterpolateImageFunction< InputImageType > LinearInterpolatorType;
LinearInterpolatorType::Pointer lin_interpolator = LinearInterpolatorType::New();
typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 4> WindowedSincInterpolatorType;
WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
if (useLinInt)
_pResizeFilter->SetInterpolator(lin_interpolator);
else
_pResizeFilter->SetInterpolator(sinc_interpolator);
_pResizeFilter->Update();
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk(_pResizeFilter->GetOutput());
mitk::GrabItkImageMemory( _pResizeFilter->GetOutput(), image);
return image;
}
/// Save images according to file type
static void SaveImage(std::string fileName, mitk::Image* image, std::string fileType )
{
std::cout << "----Save to " << fileName;
- if (fileType == "dwi") // IOUtil does not handle dwi files properly Bug 15772
- {
- try
- {
- mitk::IOUtil::Save(dynamic_cast<mitk::DiffusionImage<short>*>(image), fileName.c_str());
- }
- catch( const itk::ExceptionObject& e)
- {
- MITK_ERROR << "Caught exception: " << e.what();
- mitkThrow() << "Failed with exception from subprocess!";
- }
- }
- else
- {
- mitk::IOUtil::SaveImage(image, fileName);
- }
+ mitk::IOUtil::Save(image, fileName);
}
-DiffusionImageType::Pointer ResampleDWIbySpacing(DiffusionImageType::Pointer input, float* spacing, bool useLinInt = true)
+mitk::Image::Pointer ResampleDWIbySpacing(mitk::Image::Pointer input, float* spacing, bool useLinInt = true)
{
itk::Vector<double, 3> spacingVector;
spacingVector[0] = spacing[0];
spacingVector[1] = spacing[1];
spacingVector[2] = spacing[2];
typedef itk::ResampleDwiImageFilter<short> ResampleFilterType;
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(input, itkVectorImagePointer);
+
ResampleFilterType::Pointer resampler = ResampleFilterType::New();
- resampler->SetInput(input->GetVectorImage());
+ resampler->SetInput( itkVectorImagePointer );
resampler->SetInterpolation(ResampleFilterType::Interpolate_Linear);
resampler->SetNewSpacing(spacingVector);
resampler->Update();
- DiffusionImageType::Pointer output = DiffusionImageType::New();
- output->SetVectorImage(resampler->GetOutput());
- output->SetDirections(input->GetDirections());
- output->SetReferenceBValue(input->GetReferenceBValue());
- output->InitializeFromVectorImage();
+ mitk::Image::Pointer output = mitk::GrabItkImageMemory( resampler->GetOutput() );
+ output->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( mitk::DiffusionPropertyHelper::GetGradientContainer(input) ) );
+ output->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( mitk::DiffusionPropertyHelper::GetReferenceBValue(input) ) );
+ mitk::DiffusionPropertyHelper propertyHelper( output );
+ propertyHelper.InitializeImage();
return output;
}
int main( int argc, char* argv[] )
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--","-");
parser.setTitle("Image Resampler");
parser.setCategory("Preprocessing Tools");
parser.setContributor("MBI");
parser.setDescription("Resample an image to eigther a specific spacing or to a reference image.");
// Add command line argument names
parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Show this help text");
parser.addArgument("input", "i", mitkCommandLineParser::InputImage, "Input:", "Input file",us::Any(),false);
parser.addArgument("output", "o", mitkCommandLineParser::OutputDirectory, "Output:", "Output folder (ending with /)",us::Any(),false);
parser.addArgument("spacing", "s", mitkCommandLineParser::String, "Spacing:", "Resample provide x,y,z spacing in mm (e.g. -r 1,1,3), is not applied to tensor data",us::Any());
parser.addArgument("reference", "r", mitkCommandLineParser::String, "Reference:", "Resample using supplied reference image. Also cuts image to same dimensions",us::Any());
parser.addArgument("win-sinc", "w", mitkCommandLineParser::Bool, "Windowed-sinc interpolation:", "Use windowed-sinc interpolation (3) instead of linear interpolation ",us::Any());
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
// Handle special arguments
bool useSpacing = false;
bool useLinearInterpol = true;
{
if (parsedArgs.size() == 0)
{
return EXIT_FAILURE;
}
if (parsedArgs.count("sinc-int"))
useLinearInterpol = false;
// Show a help message
if ( parsedArgs.count("help") || parsedArgs.count("h"))
{
std::cout << parser.helpText();
return EXIT_SUCCESS;
}
}
std::string outputPath = us::any_cast<string>(parsedArgs["output"]);
std::string inputFile = us::any_cast<string>(parsedArgs["input"]);
std::vector<std::string> spacings;
float spacing[3];
if (parsedArgs.count("spacing"))
{
std::string arg = us::any_cast<string>(parsedArgs["spacing"]);
spacings = split(arg ,',');
spacing[0] = atoi(spacings.at(0).c_str());
spacing[1] = atoi(spacings.at(1).c_str());
spacing[2] = atoi(spacings.at(2).c_str());
useSpacing = true;
}
std::string refImageFile = "";
if (parsedArgs.count("reference"))
{
refImageFile = us::any_cast<string>(parsedArgs["reference"]);
}
if (refImageFile =="" && useSpacing == false)
{
MITK_ERROR << "No information how to resample is supplied. Use eigther --spacing or --reference !";
return EXIT_FAILURE;
}
mitk::Image::Pointer refImage;
if (!useSpacing)
refImage = mitk::IOUtil::LoadImage(refImageFile);
- DiffusionImageType::Pointer inputDWI = dynamic_cast<DiffusionImageType*>(mitk::IOUtil::LoadBaseData(inputFile).GetPointer());
- if (inputDWI.IsNotNull())
+ mitk::Image::Pointer inputDWI = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadBaseData(inputFile).GetPointer());
+ if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(inputDWI))
{
- DiffusionImageType::Pointer outputImage;
+ mitk::Image::Pointer outputImage;
if (useSpacing)
outputImage = ResampleDWIbySpacing(inputDWI, spacing);
else
{
MITK_WARN << "Not supported yet, to resample a DWI please set a new spacing.";
return EXIT_FAILURE;
}
std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(inputFile);
std::string outName(outputPath + fileStem + "_res.dwi");
mitk::IOUtil::Save(outputImage, outName.c_str());
return EXIT_SUCCESS;
}
mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inputFile);
mitk::Image::Pointer resultImage;
if (useSpacing)
resultImage = ResampleBySpacing(inputImage,spacing);
else
resultImage = TransformToReference(refImage,inputImage);
std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(inputFile);
mitk::IOUtil::SaveImage(resultImage, outputPath + fileStem + "_res.nrrd");
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
index 687ed57bf1..bc81479de8 100644
--- a/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
+++ b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
@@ -1,215 +1,219 @@
/*===================================================================
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 <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <string>
#include <itkImage.h>
#include <itkImageFileReader.h>
#include <itkExceptionObject.h>
#include <itkImageFileWriter.h>
#include <itkMetaDataObject.h>
#include <itkVectorImage.h>
#include <itkResampleImageFilter.h>
#include <mitkBaseDataIOFactory.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <mitkQBallImage.h>
#include <mitkBaseData.h>
#include <mitkFiberBundleX.h>
#include "mitkCommandLineParser.h"
#include <boost/lexical_cast.hpp>
#include <itkRadialMultishellToSingleshellImageFilter.h>
#include <itkADCAverageFunctor.h>
#include <itkBiExpFitFunctor.h>
#include <itkKurtosisFitFunctor.h>
#include <itkDwiGradientLengthCorrectionFilter.h>
#include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkProperties.h>
+#include <mitkImageCast.h>
+#include <mitkITKImageImport.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Multishell Methods");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
parser.addArgument("adc", "D", mitkCommandLineParser::Bool, "ADC:", "ADC Average", us::Any(), false);
parser.addArgument("akc", "K", mitkCommandLineParser::Bool, "Kurtosis fit:", "Kurtosis Fit", us::Any(), false);
parser.addArgument("biexp", "B", mitkCommandLineParser::Bool, "BiExp fit:", "BiExp fit", us::Any(), false);
parser.addArgument("targetbvalue", "b", mitkCommandLineParser::String, "b Value:", "target bValue (mean, min, max)", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
// mandatory arguments
string inName = us::any_cast<string>(parsedArgs["in"]);
string outName = us::any_cast<string>(parsedArgs["out"]);
bool applyADC = us::any_cast<bool>(parsedArgs["adc"]);
bool applyAKC = us::any_cast<bool>(parsedArgs["akc"]);
bool applyBiExp = us::any_cast<bool>(parsedArgs["biexp"]);
string targetType = us::any_cast<string>(parsedArgs["targetbvalue"]);
try
{
std::cout << "Loading " << inName;
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inName, s1, s2, false );
mitk::BaseData::Pointer baseData = infile.at(0);
- if ( dynamic_cast<mitk::DiffusionImage<short>*>(baseData.GetPointer()) )
+ if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(baseData.GetPointer()) ) )
{
- mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(baseData.GetPointer());
+ mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(baseData.GetPointer());
typedef itk::RadialMultishellToSingleshellImageFilter<short, short> FilterType;
typedef itk::DwiGradientLengthCorrectionFilter CorrectionFilterType;
CorrectionFilterType::Pointer roundfilter = CorrectionFilterType::New();
roundfilter->SetRoundingValue( 1000 );
- roundfilter->SetReferenceBValue(dwi->GetReferenceBValue());
- roundfilter->SetReferenceGradientDirectionContainer(dwi->GetDirections());
+ roundfilter->SetReferenceBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
+ roundfilter->SetReferenceGradientDirectionContainer(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi));
roundfilter->Update();
- dwi->SetReferenceBValue( roundfilter->GetNewBValue() );
- dwi->SetDirections( roundfilter->GetOutputGradientDirectionContainer());
+ dwi->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( roundfilter->GetNewBValue() ) );
+ dwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( roundfilter->GetOutputGradientDirectionContainer() ) );
// filter input parameter
- const mitk::DiffusionImage<short>::BValueMap
- &originalShellMap = dwi->GetBValueMap();
+ const mitk::DiffusionPropertyHelper::BValueMapType
+ &originalShellMap = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
- const mitk::DiffusionImage<short>::ImageType
- *vectorImage = dwi->GetVectorImage();
+ mitk::DiffusionPropertyHelper::ImageType::Pointer vectorImage = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, vectorImage);
- const mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer
- gradientContainer = dwi->GetDirections();
+ const mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
+ gradientContainer = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
const unsigned int
- &bValue = dwi->GetReferenceBValue();
+ &bValue = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
// filter call
vnl_vector<double> bValueList(originalShellMap.size()-1);
double targetBValue = bValueList.mean();
- mitk::DiffusionImage<short>::BValueMap::const_iterator it = originalShellMap.begin();
+ mitk::DiffusionPropertyHelper::BValueMapType::const_iterator it = originalShellMap.begin();
++it; int i = 0 ;
for(; it != originalShellMap.end(); ++it)
bValueList.put(i++,it->first);
if( targetType == "mean" )
targetBValue = bValueList.mean();
else if( targetType == "min" )
targetBValue = bValueList.min_value();
else if( targetType == "max" )
targetBValue = bValueList.max_value();
if(applyADC)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
- mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
- outImage->SetVectorImage( filter->GetOutput() );
- outImage->SetReferenceBValue( targetBValue );
- outImage->SetDirections( filter->GetTargetGradientDirections() );
- outImage->InitializeFromVectorImage();
+ mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue ) );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( outImage );
+ propertyHelper.InitializeImage();
mitk::IOUtil::Save(outImage, (outName + "_ADC.dwi").c_str());
}
if(applyAKC)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
- mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
- outImage->SetVectorImage( filter->GetOutput() );
- outImage->SetReferenceBValue( targetBValue );
- outImage->SetDirections( filter->GetTargetGradientDirections() );
- outImage->InitializeFromVectorImage();
+ mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue ) );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( outImage );
+ propertyHelper.InitializeImage();
mitk::IOUtil::Save(outImage, (string(outName) + "_AKC.dwi").c_str());
}
if(applyBiExp)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
- mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
- outImage->SetVectorImage( filter->GetOutput() );
- outImage->SetReferenceBValue( targetBValue );
- outImage->SetDirections( filter->GetTargetGradientDirections() );
- outImage->InitializeFromVectorImage();
+ mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue ) );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( outImage );
+ propertyHelper.InitializeImage();
mitk::IOUtil::Save(outImage, (string(outName) + "_BiExp.dwi").c_str());
}
}
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp b/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp
index 1fe492899c..2d124f8659 100644
--- a/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp
+++ b/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp
@@ -1,515 +1,516 @@
/*===================================================================
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.
===================================================================*/
// std includes
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <map>
#include <utility>
// boost includes
#include <boost/algorithm/string.hpp>
// ITK includes
#include <itkImageFileWriter.h>
// CTK includes
#include "mitkCommandLineParser.h"
// MITK includes
#include <mitkBaseDataIOFactory.h>
#include <mitkConnectomicsStatisticsCalculator.h>
#include <mitkConnectomicsNetworkThresholder.h>
#include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
+
parser.addArgument("inputNetwork", "i", mitkCommandLineParser::InputFile, "Input network", "input connectomics network (.cnf)", us::Any(), false);
parser.addArgument("outputFile", "o", mitkCommandLineParser::OutputFile, "Output file", "name of output file", us::Any(), false);
parser.addArgument("noGlobalStatistics", "g", mitkCommandLineParser::Bool, "No global statistics", "Do not calculate global statistics");
parser.addArgument("createConnectivityMatriximage", "I", mitkCommandLineParser::Bool, "Write connectivity matrix image", "Write connectivity matrix image");
parser.addArgument("binaryConnectivity", "b", mitkCommandLineParser::Bool, "Binary connectivity", "Whether to create a binary connectivity matrix");
parser.addArgument("rescaleConnectivity", "r", mitkCommandLineParser::Bool, "Rescale connectivity", "Whether to rescale the connectivity matrix");
parser.addArgument("localStatistics", "L", mitkCommandLineParser::StringList, "Local statistics", "Provide a list of node labels for local statistics", us::Any());
parser.addArgument("regionList", "R", mitkCommandLineParser::StringList, "Region list", "A space separated list of regions. Each region has the format\n regionname;label1;label2;...;labelN", us::Any());
parser.addArgument("granularity", "gr", mitkCommandLineParser::Int, "Granularity", "How finely to test the density range and how many thresholds to consider");
parser.addArgument("startDensity", "d", mitkCommandLineParser::Float, "Start Density", "Largest density for the range");
parser.addArgument("thresholdStepSize", "t", mitkCommandLineParser::Int, "Step size threshold", "Distance of two adjacent thresholds");
parser.setCategory("Connectomics");
parser.setTitle("Network Statistics");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
//default values
bool noGlobalStatistics( false );
bool binaryConnectivity( false );
bool rescaleConnectivity( false );
bool createConnectivityMatriximage( false );
int granularity( 1 );
double startDensity( 1.0 );
int thresholdStepSize( 3 );
// parse command line arguments
std::string networkName = us::any_cast<std::string>(parsedArgs["inputNetwork"]);
std::string outName = us::any_cast<std::string>(parsedArgs["outputFile"]);
mitkCommandLineParser::StringContainerType localLabels;
if(parsedArgs.count("localStatistics"))
{
localLabels = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["localStatistics"]);
}
mitkCommandLineParser::StringContainerType unparsedRegions;
std::map< std::string, std::vector<std::string> > parsedRegions;
std::map< std::string, std::vector<std::string> >::iterator parsedRegionsIterator;
if(parsedArgs.count("regionList"))
{
unparsedRegions = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["regionList"]);
for(unsigned int index(0); index < unparsedRegions.size(); index++ )
{
std::vector< std::string > tempRegionVector;
boost::split(tempRegionVector, unparsedRegions.at(index), boost::is_any_of(";"));
std::vector< std::string >::const_iterator begin = tempRegionVector.begin();
std::vector< std::string >::const_iterator last = tempRegionVector.begin() + tempRegionVector.size();
std::vector< std::string > insertRegionVector(begin + 1, last);
if( parsedRegions.count( tempRegionVector.at(0) ) == 0 )
{
parsedRegions.insert( std::pair< std::string, std::vector<std::string> >( tempRegionVector.at(0), insertRegionVector) );
}
else
{
MITK_ERROR << "Region already exists. Skipping second occurrence.";
}
}
}
if (parsedArgs.count("noGlobalStatistics"))
noGlobalStatistics = us::any_cast<bool>(parsedArgs["noGlobalStatistics"]);
if (parsedArgs.count("binaryConnectivity"))
binaryConnectivity = us::any_cast<bool>(parsedArgs["binaryConnectivity"]);
if (parsedArgs.count("rescaleConnectivity"))
rescaleConnectivity = us::any_cast<bool>(parsedArgs["rescaleConnectivity"]);
if (parsedArgs.count("createConnectivityMatriximage"))
createConnectivityMatriximage = us::any_cast<bool>(parsedArgs["createConnectivityMatriximage"]);
if (parsedArgs.count("granularity"))
granularity = us::any_cast<int>(parsedArgs["granularity"]);
if (parsedArgs.count("startDensity"))
startDensity = us::any_cast<float>(parsedArgs["startDensity"]);
if (parsedArgs.count("thresholdStepSize"))
thresholdStepSize = us::any_cast<int>(parsedArgs["thresholdStepSize"]);
try
{
const std::string s1="", s2="";
// load network
std::vector<mitk::BaseData::Pointer> networkFile =
mitk::BaseDataIO::LoadBaseDataFromFile( networkName, s1, s2, false );
if( networkFile.empty() )
{
std::string errorMessage = "File at " + networkName + " could not be read. Aborting.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
mitk::BaseData* networkBaseData = networkFile.at(0);
mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( networkBaseData );
if( !network )
{
std::string errorMessage = "Read file at " + networkName + " could not be recognized as network. Aborting.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
// streams
std::stringstream globalHeaderStream;
globalHeaderStream << "NumberOfVertices "
<< "NumberOfEdges "
<< "AverageDegree "
<< "ConnectionDensity "
<< "NumberOfConnectedComponents "
<< "AverageComponentSize "
<< "LargestComponentSize "
<< "RatioOfNodesInLargestComponent "
<< "HopPlotExponent "
<< "EffectiveHopDiameter "
<< "AverageClusteringCoefficientsC "
<< "AverageClusteringCoefficientsD "
<< "AverageClusteringCoefficientsE "
<< "AverageVertexBetweennessCentrality "
<< "AverageEdgeBetweennessCentrality "
<< "NumberOfIsolatedPoints "
<< "RatioOfIsolatedPoints "
<< "NumberOfEndPoints "
<< "RatioOfEndPoints "
<< "Diameter "
<< "Diameter90 "
<< "Radius "
<< "Radius90 "
<< "AverageEccentricity "
<< "AverageEccentricity90 "
<< "AveragePathLength "
<< "NumberOfCentralPoints "
<< "RatioOfCentralPoints "
<< "SpectralRadius "
<< "SecondLargestEigenValue "
<< "AdjacencyTrace "
<< "AdjacencyEnergy "
<< "LaplacianTrace "
<< "LaplacianEnergy "
<< "LaplacianSpectralGap "
<< "NormalizedLaplacianTrace "
<< "NormalizedLaplacianEnergy "
<< "NormalizedLaplacianNumberOf2s "
<< "NormalizedLaplacianNumberOf1s "
<< "NormalizedLaplacianNumberOf0s "
<< "NormalizedLaplacianLowerSlope "
<< "NormalizedLaplacianUpperSlope "
<< "SmallWorldness"
<< std::endl;
std::stringstream localHeaderStream;
std::stringstream regionalHeaderStream;
std::stringstream globalDataStream;
std::stringstream localDataStream;
std::stringstream regionalDataStream;
std::string globalOutName = outName + "_global.txt";
std::string localOutName = outName + "_local.txt";
std::string regionalOutName = outName + "_regional.txt";
bool firstRun( true );
// iterate over all three possible methods
for(unsigned int method( 0 ); method < 3; method++)
{
// 0 - Random removal threshold
// 1 - Largest density below threshold
// 2 - Threshold based
// iterate over possible targets
for( unsigned int step( 0 ); step < granularity; step++ )
{
double targetValue( 0.0 );
bool newStep( true );
switch ( method )
{
case mitk::ConnectomicsNetworkThresholder::RandomRemovalOfWeakest :
case mitk::ConnectomicsNetworkThresholder::LargestLowerThanDensity :
targetValue = startDensity * (1 - static_cast<double>( step ) / ( granularity + 0.5 ) );
break;
case mitk::ConnectomicsNetworkThresholder::ThresholdBased :
targetValue = static_cast<double>( thresholdStepSize * step );
break;
default:
MITK_ERROR << "Invalid thresholding method called, aborting.";
return EXIT_FAILURE;
break;
}
mitk::ConnectomicsNetworkThresholder::Pointer thresholder = mitk::ConnectomicsNetworkThresholder::New();
thresholder->SetNetwork( network );
thresholder->SetTargetThreshold( targetValue );
thresholder->SetTargetDensity( targetValue );
thresholder->SetThresholdingScheme( static_cast<mitk::ConnectomicsNetworkThresholder::ThresholdingSchemes>(method) );
mitk::ConnectomicsNetwork::Pointer thresholdedNetwork = thresholder->GetThresholdedNetwork();
mitk::ConnectomicsStatisticsCalculator::Pointer statisticsCalculator = mitk::ConnectomicsStatisticsCalculator::New();
statisticsCalculator->SetNetwork( thresholdedNetwork );
statisticsCalculator->Update();
// global statistics
if( !noGlobalStatistics )
{
globalDataStream << statisticsCalculator->GetNumberOfVertices() << " "
<< statisticsCalculator->GetNumberOfEdges() << " "
<< statisticsCalculator->GetAverageDegree() << " "
<< statisticsCalculator->GetConnectionDensity() << " "
<< statisticsCalculator->GetNumberOfConnectedComponents() << " "
<< statisticsCalculator->GetAverageComponentSize() << " "
<< statisticsCalculator->GetLargestComponentSize() << " "
<< statisticsCalculator->GetRatioOfNodesInLargestComponent() << " "
<< statisticsCalculator->GetHopPlotExponent() << " "
<< statisticsCalculator->GetEffectiveHopDiameter() << " "
<< statisticsCalculator->GetAverageClusteringCoefficientsC() << " "
<< statisticsCalculator->GetAverageClusteringCoefficientsD() << " "
<< statisticsCalculator->GetAverageClusteringCoefficientsE() << " "
<< statisticsCalculator->GetAverageVertexBetweennessCentrality() << " "
<< statisticsCalculator->GetAverageEdgeBetweennessCentrality() << " "
<< statisticsCalculator->GetNumberOfIsolatedPoints() << " "
<< statisticsCalculator->GetRatioOfIsolatedPoints() << " "
<< statisticsCalculator->GetNumberOfEndPoints() << " "
<< statisticsCalculator->GetRatioOfEndPoints() << " "
<< statisticsCalculator->GetDiameter() << " "
<< statisticsCalculator->GetDiameter90() << " "
<< statisticsCalculator->GetRadius() << " "
<< statisticsCalculator->GetRadius90() << " "
<< statisticsCalculator->GetAverageEccentricity() << " "
<< statisticsCalculator->GetAverageEccentricity90() << " "
<< statisticsCalculator->GetAveragePathLength() << " "
<< statisticsCalculator->GetNumberOfCentralPoints() << " "
<< statisticsCalculator->GetRatioOfCentralPoints() << " "
<< statisticsCalculator->GetSpectralRadius() << " "
<< statisticsCalculator->GetSecondLargestEigenValue() << " "
<< statisticsCalculator->GetAdjacencyTrace() << " "
<< statisticsCalculator->GetAdjacencyEnergy() << " "
<< statisticsCalculator->GetLaplacianTrace() << " "
<< statisticsCalculator->GetLaplacianEnergy() << " "
<< statisticsCalculator->GetLaplacianSpectralGap() << " "
<< statisticsCalculator->GetNormalizedLaplacianTrace() << " "
<< statisticsCalculator->GetNormalizedLaplacianEnergy() << " "
<< statisticsCalculator->GetNormalizedLaplacianNumberOf2s() << " "
<< statisticsCalculator->GetNormalizedLaplacianNumberOf1s() << " "
<< statisticsCalculator->GetNormalizedLaplacianNumberOf0s() << " "
<< statisticsCalculator->GetNormalizedLaplacianLowerSlope() << " "
<< statisticsCalculator->GetNormalizedLaplacianUpperSlope() << " "
<< statisticsCalculator->GetSmallWorldness()
<< std::endl;
} // end global statistics
//create connectivity matrix png
if( createConnectivityMatriximage )
{
std::string connectivity_png_postfix = "_connectivity";
if( binaryConnectivity )
{
connectivity_png_postfix += "_binary";
}
else if( rescaleConnectivity )
{
connectivity_png_postfix += "_rescaled";
}
connectivity_png_postfix += ".png";
/* File format
* A png file depicting the binary connectivity matrix
*/
itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::Pointer filter = itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::New();
filter->SetInputNetwork( network );
filter->SetBinaryConnectivity( binaryConnectivity );
filter->SetRescaleConnectivity( rescaleConnectivity );
filter->Update();
typedef itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::OutputImageType connectivityMatrixImageType;
itk::ImageFileWriter< connectivityMatrixImageType >::Pointer connectivityWriter = itk::ImageFileWriter< connectivityMatrixImageType >::New();
connectivityWriter->SetInput( filter->GetOutput() );
connectivityWriter->SetFileName( outName + connectivity_png_postfix);
connectivityWriter->Update();
std::cout << "Connectivity matrix image written.";
} // end create connectivity matrix png
/*
* We can either calculate local indices for specific nodes, or specific regions
*/
// Create LabelToIndex translation
std::map< std::string, int > labelToIdMap;
std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = thresholdedNetwork->GetVectorOfAllNodes();
for(int loop(0); loop < nodeVector.size(); loop++)
{
labelToIdMap.insert( std::pair< std::string, int>(nodeVector.at(loop).label, nodeVector.at(loop).id) );
}
std::vector< int > degreeVector = thresholdedNetwork->GetDegreeOfNodes();
std::vector< double > ccVector = thresholdedNetwork->GetLocalClusteringCoefficients( );
std::vector< double > bcVector = thresholdedNetwork->GetNodeBetweennessVector( );
// calculate local indices
{
// only add to header for the first step of the first method
if( firstRun )
{
localHeaderStream << "Th_method " << "Th_target " << "density";
}
double density = statisticsCalculator->GetConnectionDensity();
localDataStream << "\n"
<< method << " "
<< targetValue << " "
<< density;
for(unsigned int loop(0); loop < localLabels.size(); loop++ )
{
if( network->CheckForLabel(localLabels.at( loop )) )
{
if( firstRun )
{
localHeaderStream << " "
<< localLabels.at( loop ) << "_Degree "
<< localLabels.at( loop ) << "_CC "
<< localLabels.at( loop ) << "_BC";
}
localDataStream << " " << degreeVector.at( labelToIdMap.find( localLabels.at( loop ) )->second )
<< " " << ccVector.at( labelToIdMap.find( localLabels.at( loop ) )->second )
<< " " << bcVector.at( labelToIdMap.find( localLabels.at( loop ) )->second );
}
else
{
MITK_ERROR << "Illegal label. Label: \"" << localLabels.at( loop ) << "\" not found.";
}
}
}
// calculate regional indices
{
// only add to header for the first step of the first method
if( firstRun )
{
regionalHeaderStream << "Th_method " << "Th_target " << "density";
}
double density = statisticsCalculator->GetConnectionDensity();
regionalDataStream << "\n"
<< method << " "
<< targetValue << " "
<< density;
for( parsedRegionsIterator = parsedRegions.begin(); parsedRegionsIterator != parsedRegions.end(); parsedRegionsIterator++ )
{
std::vector<std::string> regionLabelsVector = parsedRegionsIterator->second;
std::string regionName = parsedRegionsIterator->first;
double sumDegree( 0 );
double sumCC( 0 );
double sumBC( 0 );
double count( 0 );
for( int loop(0); loop < regionLabelsVector.size(); loop++ )
{
if( thresholdedNetwork->CheckForLabel(regionLabelsVector.at( loop )) )
{
sumDegree = sumDegree + degreeVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
sumCC = sumCC + ccVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
sumBC = sumBC + bcVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
count = count + 1;
}
else
{
MITK_ERROR << "Illegal label. Label: \"" << regionLabelsVector.at( loop ) << "\" not found.";
}
}
// only add to header for the first step of the first method
if( firstRun )
{
regionalHeaderStream << " " << regionName << "_LocalAverageDegree "
<< regionName << "_LocalAverageCC "
<< regionName << "_LocalAverageBC "
<< regionName << "_NumberOfNodes";
}
regionalDataStream << " " << sumDegree / count
<< " " << sumCC / count
<< " " << sumBC / count
<< " " << count;
}
}
firstRun = false;
}
}// end calculate local averages
if( !noGlobalStatistics )
{
std::cout << "Writing to " << globalOutName;
std::ofstream glocalOutFile( globalOutName.c_str(), ios::out );
if( ! glocalOutFile.is_open() )
{
std::string errorMessage = "Could not open " + globalOutName + " for writing.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
glocalOutFile << globalHeaderStream.str() << globalDataStream.str();
glocalOutFile.close();
}
if( localLabels.size() > 0 )
{
std::cout << "Writing to " << localOutName;
std::ofstream localOutFile( localOutName.c_str(), ios::out );
if( ! localOutFile.is_open() )
{
std::string errorMessage = "Could not open " + localOutName + " for writing.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
localOutFile << localHeaderStream.str() << localDataStream.str();
localOutFile.close();
}
if( parsedRegions.size() > 0 )
{
std::cout << "Writing to " << regionalOutName;
std::ofstream regionalOutFile( regionalOutName.c_str(), ios::out );
if( ! regionalOutFile.is_open() )
{
std::string errorMessage = "Could not open " + regionalOutName + " for writing.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
regionalOutFile << regionalHeaderStream.str() << regionalDataStream.str();
regionalOutFile.close();
}
return EXIT_SUCCESS;
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
std::cout << "DONE";
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
index bebbbee478..7f8d7c47c0 100755
--- a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
@@ -1,374 +1,374 @@
/*===================================================================
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 <itkImageFileWriter.h>
#include <itkResampleImageFilter.h>
#include <itkFiniteDiffOdfMaximaExtractionFilter.h>
#include <mitkBaseDataIOFactory.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <mitkQBallImage.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <mitkTensorImage.h>
#include <mitkCoreObjectFactory.h>
#include "mitkCommandLineParser.h"
#include <itkShCoefficientImageImporter.h>
#include <itkFlipImageFilter.h>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <mitkIOUtil.h>
mitk::Image::Pointer LoadData(std::string filename)
{
if( filename.empty() )
return NULL;
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
if( infile.empty() )
{
std::cout << "File " << filename << " could not be read!";
return NULL;
}
mitk::BaseData::Pointer baseData = infile.at(0);
return dynamic_cast<mitk::Image*>(baseData.GetPointer());
}
template<int shOrder>
int StartPeakExtraction(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
parser.setCategory("Preprocessing Tools");
parser.setTitle("Peak Extraction");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
// mandatory arguments
string imageName = us::any_cast<string>(parsedArgs["image"]);
string outRoot = us::any_cast<string>(parsedArgs["outroot"]);
// optional arguments
string maskImageName("");
if (parsedArgs.count("mask"))
maskImageName = us::any_cast<string>(parsedArgs["mask"]);
int normalization = 1;
if (parsedArgs.count("normalization"))
normalization = us::any_cast<int>(parsedArgs["normalization"]);
int numPeaks = 2;
if (parsedArgs.count("numpeaks"))
numPeaks = us::any_cast<int>(parsedArgs["numpeaks"]);
float peakThres = 0.4;
if (parsedArgs.count("peakthres"))
peakThres = us::any_cast<float>(parsedArgs["peakthres"]);
float absPeakThres = 0.06;
if (parsedArgs.count("abspeakthres"))
absPeakThres = us::any_cast<float>(parsedArgs["abspeakthres"]);
bool noFlip = false;
if (parsedArgs.count("noFlip"))
noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
std::cout << "image: " << imageName;
std::cout << "outroot: " << outRoot;
if (!maskImageName.empty())
std::cout << "mask: " << maskImageName;
else
std::cout << "no mask image selected";
std::cout << "numpeaks: " << numPeaks;
std::cout << "peakthres: " << peakThres;
std::cout << "abspeakthres: " << absPeakThres;
std::cout << "shOrder: " << shOrder;
try
{
mitk::Image::Pointer image = LoadData(imageName);
mitk::Image::Pointer mask = LoadData(maskImageName);
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
int toolkitConvention = 0;
if (parsedArgs.count("shConvention"))
{
string convention = us::any_cast<string>(parsedArgs["shConvention"]).c_str();
if ( boost::algorithm::equals(convention, "FSL") )
{
toolkitConvention = 1;
std::cout << "Using FSL SH-basis";
}
else if ( boost::algorithm::equals(convention, "MRtrix") )
{
toolkitConvention = 2;
std::cout << "Using MRtrix SH-basis";
}
else
std::cout << "Using MITK SH-basis";
}
else
std::cout << "Using MITK SH-basis";
ItkUcharImgType::Pointer itkMaskImage = NULL;
if (mask.IsNotNull())
{
try{
itkMaskImage = ItkUcharImgType::New();
mitk::CastToItkImage(mask, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
catch(...)
{
}
}
if (toolkitConvention>0)
{
std::cout << "Converting coefficient image to MITK format";
typedef itk::ShCoefficientImageImporter< float, shOrder > ConverterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(image);
caster->Update();
itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
typename ConverterType::Pointer converter = ConverterType::New();
if (noFlip)
{
converter->SetInputImage(itkImage);
}
else
{
std::cout << "Flipping image";
itk::FixedArray<bool, 4> flipAxes;
flipAxes[0] = true;
flipAxes[1] = true;
flipAxes[2] = false;
flipAxes[3] = false;
itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
flipper->SetInput(itkImage);
flipper->SetFlipAxes(flipAxes);
flipper->Update();
itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
flipped->SetDirection(m);
itk::Point< float, 4 > o = itkImage->GetOrigin();
o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
flipped->SetOrigin(o);
converter->SetInputImage(flipped);
}
std::cout << "Starting conversion";
switch (toolkitConvention)
{
case 1:
converter->SetToolkit(ConverterType::FSL);
filter->SetToolkit(MaximaExtractionFilterType::FSL);
break;
case 2:
converter->SetToolkit(ConverterType::MRTRIX);
filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
break;
default:
converter->SetToolkit(ConverterType::FSL);
filter->SetToolkit(MaximaExtractionFilterType::FSL);
break;
}
converter->GenerateData();
filter->SetInput(converter->GetCoefficientImage());
}
else
{
try{
typedef mitk::ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
typename CasterType::Pointer caster = CasterType::New();
caster->SetInput(image);
caster->Update();
filter->SetInput(caster->GetOutput());
}
catch(...)
{
std::cout << "wrong image type";
return EXIT_FAILURE;
}
}
filter->SetMaxNumPeaks(numPeaks);
filter->SetPeakThreshold(peakThres);
filter->SetAbsolutePeakThreshold(absPeakThres);
filter->SetAngularThreshold(1);
switch (normalization)
{
case 0:
filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
break;
case 1:
filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
break;
case 2:
filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
break;
}
std::cout << "Starting extraction";
filter->Update();
// write direction images
{
typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (unsigned int i=0; i<container->Size(); i++)
{
typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
if (itkMaskImage.IsNotNull())
{
itkImg->SetDirection(itkMaskImage->GetDirection());
itkImg->SetOrigin(itkMaskImage->GetOrigin());
}
string outfilename = outRoot;
outfilename.append("_DIRECTION_");
outfilename.append(boost::lexical_cast<string>(i));
outfilename.append(".nrrd");
typedef itk::ImageFileWriter< typename MaximaExtractionFilterType::ItkDirectionImage > WriterType;
typename WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outfilename);
writer->SetInput(itkImg);
writer->Update();
}
}
// write num directions image
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
if (itkMaskImage.IsNotNull())
{
numDirImage->SetDirection(itkMaskImage->GetDirection());
numDirImage->SetOrigin(itkMaskImage->GetOrigin());
}
string outfilename = outRoot.c_str();
outfilename.append("_NUM_DIRECTIONS.nrrd");
typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outfilename);
writer->SetInput(numDirImage);
writer->Update();
}
// write vector field
{
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
string outfilename = outRoot.c_str();
outfilename.append("_VECTOR_FIELD.fib");
mitk::IOUtil::Save(directions.GetPointer(),outfilename.c_str());
}
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order");
parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
parser.setCategory("Preprocessing Tools");
parser.setTitle("Peak Extraction");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
int shOrder = -1;
if (parsedArgs.count("shOrder"))
shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
switch (shOrder)
{
case 4:
return StartPeakExtraction<4>(argc, argv);
case 6:
return StartPeakExtraction<6>(argc, argv);
case 8:
return StartPeakExtraction<8>(argc, argv);
case 10:
return StartPeakExtraction<10>(argc, argv);
case 12:
return StartPeakExtraction<12>(argc, argv);
}
return EXIT_FAILURE;
}
diff --git a/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp b/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
index 65cb7e0e33..13ea2b526b 100644
--- a/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
@@ -1,239 +1,263 @@
/*===================================================================
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 "mitkBaseDataIOFactory.h"
#include <mitkCoreObjectFactory.h>
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
#include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
#include <boost/lexical_cast.hpp>
#include "mitkCommandLineParser.h"
#include <mitkIOUtil.h>
#include <itksys/SystemTools.hxx>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
+#include <mitkImageCast.h>
+#include <mitkProperties.h>
using namespace mitk;
/**
* Perform Q-ball reconstruction using a spherical harmonics basis
*/
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order", 4, true);
parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
parser.addArgument("lambda", "r", mitkCommandLineParser::Float, "Lambda", "ragularization factor lambda", 0.006, true);
parser.addArgument("csa", "csa", mitkCommandLineParser::Bool, "Constant solid angle consideration", "use constant solid angle consideration");
parser.addArgument("outputCoeffs", "shc", mitkCommandLineParser::Bool, "Output coefficients", "output file containing the SH coefficients");
parser.addArgument("mrtrix", "mb", mitkCommandLineParser::Bool, "MRtrix", "use MRtrix compatible spherical harmonics definition");
parser.setCategory("Preprocessing Tools");
parser.setTitle("Qball Reconstruction");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
int threshold = 0;
if (parsedArgs.count("b0Threshold"))
threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
int shOrder = 4;
if (parsedArgs.count("shOrder"))
shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
float lambda = 0.006;
if (parsedArgs.count("lambda"))
lambda = us::any_cast<float>(parsedArgs["lambda"]);
int normalization = 0;
if (parsedArgs.count("csa") && us::any_cast<bool>(parsedArgs["csa"]))
normalization = 6;
bool outCoeffs = false;
if (parsedArgs.count("outputCoeffs"))
outCoeffs = us::any_cast<bool>(parsedArgs["outputCoeffs"]);
bool mrTrix = false;
if (parsedArgs.count("mrtrix"))
mrTrix = us::any_cast<bool>(parsedArgs["mrtrix"]);
try
{
const std::string s1="", s2="";
std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
- DiffusionImage<short>::Pointer dwi = dynamic_cast<DiffusionImage<short>*>(infile.at(0).GetPointer());
- dwi->AverageRedundantGradients(0.001);
+ Image::Pointer dwi = dynamic_cast<Image*>(infile.at(0).GetPointer());
+ mitk::DiffusionPropertyHelper propertyHelper(dwi);
+ propertyHelper.AverageRedundantGradients(0.001);
+ propertyHelper.InitializeImage();
mitk::QBallImage::Pointer image = mitk::QBallImage::New();
mitk::Image::Pointer coeffsImage = mitk::Image::New();
std::cout << "SH order: " << shOrder;
std::cout << "lambda: " << lambda;
std::cout << "B0 threshold: " << threshold;
switch ( shOrder )
{
case 4:
{
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+ filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
filter->SetThreshold( threshold );
filter->SetLambda(lambda);
filter->SetUseMrtrixBasis(mrTrix);
if (normalization==0)
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
else
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
filter->Update();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
break;
}
case 6:
{
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,6,QBALL_ODFSIZE> FilterType;
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+ filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
filter->SetThreshold( threshold );
filter->SetLambda(lambda);
filter->SetUseMrtrixBasis(mrTrix);
if (normalization==0)
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
else
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
filter->Update();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
break;
}
case 8:
{
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,8,QBALL_ODFSIZE> FilterType;
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+ filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
filter->SetThreshold( threshold );
filter->SetLambda(lambda);
filter->SetUseMrtrixBasis(mrTrix);
if (normalization==0)
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
else
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
filter->Update();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
break;
}
case 10:
{
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,10,QBALL_ODFSIZE> FilterType;
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+ filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
filter->SetThreshold( threshold );
filter->SetLambda(lambda);
filter->SetUseMrtrixBasis(mrTrix);
if (normalization==0)
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
else
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
filter->Update();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
break;
}
case 12:
{
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,12,QBALL_ODFSIZE> FilterType;
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+ filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
filter->SetThreshold( threshold );
filter->SetLambda(lambda);
if (normalization==0)
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
else
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
filter->Update();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
break;
}
default:
{
std::cout << "Supplied SH order not supported. Using default order of 4.";
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
FilterType::Pointer filter = FilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+ filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
filter->SetThreshold( threshold );
filter->SetLambda(lambda);
filter->SetUseMrtrixBasis(mrTrix);
if (normalization==0)
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
else
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
filter->Update();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
}
}
std::string coeffout = outfilename;
coeffout += "_shcoeffs.nrrd";
outfilename += ".qbi";
mitk::IOUtil::SaveBaseData(image, outfilename);
if (outCoeffs)
mitk::IOUtil::SaveImage(coeffsImage, coeffout);
}
catch ( itk::ExceptionObject &err)
{
std::cout << "Exception: " << err;
}
catch ( std::exception err)
{
std::cout << "Exception: " << err.what();
}
catch ( ... )
{
std::cout << "Exception!";
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp b/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp
index 5f1b3a55db..ecbe39b53b 100644
--- a/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp
@@ -1,191 +1,190 @@
/*===================================================================
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 <mitkIOUtil.h>
#include "mitkImage.h"
#include <mitkImageCast.h>
#include "mitkITKImageImport.h"
#include <iostream>
#include <fstream>
#include <mitkTensorImage.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
#include "itkTensorDerivedMeasurementsFilter.h"
#include "itkDiffusionTensor3DReconstructionImageFilter.h"
#include "mitkCommandLineParser.h"
#include <itkImageFileWriter.h>
#include <itkNrrdImageIO.h>
#include <itkDiffusionTensor3D.h>
typedef short DiffusionPixelType;
typedef double TTensorPixelType;
static void ExtractMapsAndSave(mitk::TensorImage::Pointer tensorImage, std::string filename, std::string postfix = "")
{
mitk::Image* image = dynamic_cast<mitk::Image*> (tensorImage.GetPointer());
typedef itk::DiffusionTensor3D< TTensorPixelType > TensorPixelType;
typedef itk::Image< TensorPixelType, 3 > TensorImageType;
TensorImageType::Pointer itkvol = TensorImageType::New();
mitk::CastToItkImage(image, itkvol);
typedef itk::TensorDerivedMeasurementsFilter<TTensorPixelType> MeasurementsType;
MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(itkvol.GetPointer() );
mitk::Image::Pointer map = mitk::Image::New();
// FA
measurementsCalculator->SetMeasure(MeasurementsType::FA);
measurementsCalculator->Update();
map->InitializeByItk( measurementsCalculator->GetOutput() );
map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
mitk::IOUtil::SaveImage(map, filename + "_dti_FA" + postfix + ".nrrd");
// MD
measurementsCalculator->SetMeasure(MeasurementsType::MD);
measurementsCalculator->Update();
map->InitializeByItk( measurementsCalculator->GetOutput() );
map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
mitk::IOUtil::SaveImage(map, filename + "_dti_MD" + postfix + ".nrrd");
// AD
measurementsCalculator->SetMeasure(MeasurementsType::AD);
measurementsCalculator->Update();
map->InitializeByItk( measurementsCalculator->GetOutput() );
map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
mitk::IOUtil::SaveImage(map, filename + "_dti_AD" + postfix + ".nrrd");
// CA
measurementsCalculator->SetMeasure(MeasurementsType::CA);
measurementsCalculator->Update();
map->InitializeByItk( measurementsCalculator->GetOutput() );
map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
mitk::IOUtil::SaveImage(map, filename + "_dti_CA" + postfix + ".nrrd");
// RA
measurementsCalculator->SetMeasure(MeasurementsType::RA);
measurementsCalculator->Update();
map->InitializeByItk( measurementsCalculator->GetOutput() );
map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
mitk::IOUtil::SaveImage(map, filename + "_dti_RA" + postfix + ".nrrd");
// RD
measurementsCalculator->SetMeasure(MeasurementsType::RD);
measurementsCalculator->Update();
map->InitializeByItk( measurementsCalculator->GetOutput() );
map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
mitk::IOUtil::SaveImage(map, filename + "_dti_RD" + postfix + ".nrrd");
}
int main(int argc, char* argv[])
{
std::cout << "TensorDerivedMapsExtraction";
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("help", "h", mitkCommandLineParser::String, "Help", "Show this help text");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input dwi file", us::Any(),false);
parser.addArgument("out", "o", mitkCommandLineParser::String, "Output folder", "output folder and base name, e.g. /tmp/outPatient1 ", us::Any(),false);
parser.setCategory("Diffusion Related Measures");
parser.setTitle("Tensor Derived Maps Extraction");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0 || parsedArgs.count("help") || parsedArgs.count("h"))
{
std::cout << "\n\nMiniApp Description: \nPerforms tensor reconstruction on DWI file," << endl;
std::cout << "and computes tensor derived measures." << endl;
std::cout << "\n\n For out parameter /tmp/outPatient1 it will produce :"<< endl;
std::cout << " /tmp/outPatient1_dti.dti , /tmp/outPatient1_dti_FA.nrrd, ..."<< endl;
std::cout << "\n\n Parameters:"<< endl;
std::cout << parser.helpText();
return EXIT_SUCCESS;
}
std::string inputFile = us::any_cast<string>(parsedArgs["input"]);
std::string baseFileName = us::any_cast<string>(parsedArgs["out"]);
std::string dtiFileName = "_dti.dti";
std::cout << "BaseFileName: " << baseFileName;
- mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inputFile);
- mitk::DiffusionImage<short>* diffusionImage = static_cast<mitk::DiffusionImage<short>*>(inputImage.GetPointer());
- if (diffusionImage == NULL) // does NULL pointer check make sense after static cast ?
+ mitk::Image::Pointer diffusionImage = mitk::IOUtil::LoadImage(inputFile);
+
+ if (diffusionImage.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(diffusionImage)) // does NULL pointer check make sense after static cast ?
{
MITK_ERROR << "Invalid Input Image. Must be DWI. Aborting.";
return -1;
}
- mitk::DiffusionImage<DiffusionPixelType>* vols = dynamic_cast <mitk::DiffusionImage<DiffusionPixelType>*> (inputImage.GetPointer());
-
typedef itk::DiffusionTensor3DReconstructionImageFilter< DiffusionPixelType, DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter = TensorReconstructionImageFilterType::New();
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef DiffusionImageType::GradientDirectionContainerType GradientDirectionContainerType;
-
- GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
- for(GradientDirectionContainerType::ConstIterator it = vols->GetDirections()->Begin(); it != vols->GetDirections()->End(); it++)
+ mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientContainerCopy = mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
+ for( mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::ConstIterator it = mitk::DiffusionPropertyHelper::GetGradientContainer(diffusionImage)->Begin(); it != mitk::DiffusionPropertyHelper::GetGradientContainer(diffusionImage)->End(); it++)
{
gradientContainerCopy->push_back(it.Value());
}
- tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, vols->GetVectorImage() );
- tensorReconstructionFilter->SetBValue(vols->GetReferenceBValue());
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(diffusionImage, itkVectorImagePointer);
+
+ tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer );
+ tensorReconstructionFilter->SetBValue( mitk::DiffusionPropertyHelper::GetReferenceBValue( diffusionImage ) );
tensorReconstructionFilter->SetThreshold(50);
tensorReconstructionFilter->Update();
typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
TensorImageType::Pointer tensorImage = tensorReconstructionFilter->GetOutput();
- tensorImage->SetDirection( vols->GetVectorImage()->GetDirection() );
+ tensorImage->SetDirection( itkVectorImagePointer->GetDirection() );
mitk::TensorImage::Pointer tensorImageMitk = mitk::TensorImage::New();
tensorImageMitk->InitializeByItk(tensorImage.GetPointer());
tensorImageMitk->SetVolume( tensorImage->GetBufferPointer() );
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
io->SetFileType( itk::ImageIOBase::Binary );
io->UseCompressionOn();
itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< double >, 3 > >::Pointer writer = itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< double >, 3 > >::New();
writer->SetInput(tensorReconstructionFilter->GetOutput());
writer->SetFileName(baseFileName + dtiFileName);
writer->SetImageIO(io);
writer->UseCompressionOn();
writer->Update();
ExtractMapsAndSave(tensorImageMitk,baseFileName);
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp b/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
index 2b7968a1fd..a1b066cc54 100644
--- a/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
@@ -1,98 +1,103 @@
/*===================================================================
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 "mitkBaseDataIOFactory.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
+#include <mitkImageCast.h>
#include "mitkBaseData.h"
+#include <mitkDiffusionPropertyHelper.h>
#include <itkDiffusionTensor3DReconstructionImageFilter.h>
#include <itkDiffusionTensor3D.h>
#include <itkImageFileWriter.h>
#include <itkNrrdImageIO.h>
#include "mitkCommandLineParser.h"
#include <itksys/SystemTools.hxx>
using namespace mitk;
/**
* Convert files from one ending to the other
*/
int main(int argc, char* argv[])
{
std::cout << "TensorReconstruction";
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
parser.setCategory("Preprocessing Tools");
parser.setTitle("Tensor Reconstruction");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
outfilename += ".dti";
int threshold = 0;
if (parsedArgs.count("b0Threshold"))
threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
try
{
const std::string s1="", s2="";
std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
- DiffusionImage<short>::Pointer dwi = dynamic_cast<DiffusionImage<short>*>(infile.at(0).GetPointer());
+ Image::Pointer dwi = dynamic_cast<Image*>(infile.at(0).GetPointer());
+
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, float > TensorReconstructionImageFilterType;
TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
- filter->SetBValue(dwi->GetReferenceBValue());
+ filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+ filter->SetBValue( mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
filter->SetThreshold(threshold);
filter->Update();
// Save tensor image
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
io->SetFileType( itk::ImageIOBase::Binary );
io->UseCompressionOn();
itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::Pointer writer = itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::New();
writer->SetInput(filter->GetOutput());
writer->SetFileName(outfilename);
writer->SetImageIO(io);
writer->UseCompressionOn();
writer->Update();
}
catch ( itk::ExceptionObject &err)
{
std::cout << "Exception: " << err;
}
catch ( std::exception err)
{
std::cout << "Exception: " << err.what();
}
catch ( ... )
{
std::cout << "Exception!";
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp b/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp
index 1cac8e8832..f758f91601 100755
--- a/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp
+++ b/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp
@@ -1,84 +1,80 @@
/*===================================================================
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 <mitkImageCast.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkIOUtil.h>
#include <mitkFiberBundleX.h>
#include "mitkCommandLineParser.h"
using namespace mitk;
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Format Converter");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
// mandatory arguments
string inName = us::any_cast<string>(parsedArgs["in"]);
string outName = us::any_cast<string>(parsedArgs["out"]);
try
{
const std::string s1="", s2="";
std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inName, s1, s2, false );
mitk::BaseData::Pointer baseData = infile.at(0);
- if ( dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer()) )
- {
- mitk::IOUtil::Save(dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer()), outName.c_str());
- }
- else if ( dynamic_cast<Image*>(baseData.GetPointer()) )
+ if ( dynamic_cast<Image*>(baseData.GetPointer()) )
{
mitk::IOUtil::Save(dynamic_cast<Image*>(baseData.GetPointer()), outName.c_str());
}
else if ( dynamic_cast<FiberBundleX*>(baseData.GetPointer()) )
{
mitk::IOUtil::Save(dynamic_cast<FiberBundleX*>(baseData.GetPointer()) ,outName.c_str());
}
else
std::cout << "File type currently not supported!";
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
diff --git a/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp b/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp
index d262915ba7..30077621d1 100644
--- a/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp
+++ b/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp
@@ -1,473 +1,457 @@
/*===================================================================
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.
===================================================================*/
// CTK
#include "mitkCommandLineParser.h"
#include <mitkIOUtil.h>
#include <mitkRegistrationWrapper.h>
#include <mitkImage.h>
#include <mitkImageCast.h>
#include <mitkITKImageImport.h>
-#include <mitkDiffusionImage.h>
#include <mitkImageTimeSelector.h>
// ITK
#include <itksys/SystemTools.hxx>
#include <itkDirectory.h>
#include "itkLinearInterpolateImageFunction.h"
#include "itkWindowedSincInterpolateImageFunction.h"
#include "itkIdentityTransform.h"
#include "itkResampleImageFilter.h"
typedef std::vector<std::string> FileListType;
typedef itk::Image<double, 3> InputImageType;
static mitk::Image::Pointer ExtractFirstTS(mitk::Image* image, std::string fileType)
{
if (fileType == ".dwi")
return image;
mitk::ImageTimeSelector::Pointer selector = mitk::ImageTimeSelector::New();
selector->SetInput(image);
selector->SetTimeNr(0);
selector->UpdateLargestPossibleRegion();
mitk::Image::Pointer img =selector->GetOutput()->Clone();
return img;
}
static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim))
{
elems.push_back(item);
}
return elems;
}
static std::vector<std::string> split(const std::string &s, char delim)
{
std::vector < std::string > elems;
return split(s, delim, elems);
}
/// Create list of all files in provided folder ending with same postfix
static FileListType CreateFileList(std::string folder , std::string postfix)
{
itk::Directory::Pointer dir = itk::Directory::New();
FileListType fileList;
if( dir->Load(folder.c_str() ) )
{
int n = dir->GetNumberOfFiles();
for(int r=0;r<n;r++)
{
std::string filename = dir->GetFile( r );
if (filename == "." || filename == "..")
continue;
filename = folder + filename;
if (!itksys::SystemTools::FileExists( filename.c_str()))
continue;
if (filename.substr(filename.length() -postfix.length() ) == postfix)
fileList.push_back(filename);
}
}
return fileList;
}
static std::string GetSavePath(std::string outputFolder, std::string fileName)
{
std::string fileType = itksys::SystemTools::GetFilenameExtension(fileName);
std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(fileName);
std::string savePathAndFileName = outputFolder +fileStem + fileType;
return savePathAndFileName;
}
static mitk::Image::Pointer ResampleBySpacing(mitk::Image *input, float *spacing, bool useLinInt = false)
{
InputImageType::Pointer itkImage = InputImageType::New();
CastToItkImage(input,itkImage);
/**
* 1) Resampling
*
*/
// Identity transform.
// We don't want any transform on our image except rescaling which is not
// specified by a transform but by the input/output spacing as we will see
// later.
// So no transform will be specified.
typedef itk::IdentityTransform<double, 3> T_Transform;
// The resampler type itself.
typedef itk::ResampleImageFilter<InputImageType, InputImageType> T_ResampleFilter;
// Prepare the resampler.
// Instantiate the transform and specify it should be the id transform.
T_Transform::Pointer _pTransform = T_Transform::New();
_pTransform->SetIdentity();
// Instantiate the resampler. Wire in the transform and the interpolator.
T_ResampleFilter::Pointer _pResizeFilter = T_ResampleFilter::New();
_pResizeFilter->SetTransform(_pTransform);
// Set the output origin.
_pResizeFilter->SetOutputOrigin(itkImage->GetOrigin());
// Compute the size of the output.
// The size (# of pixels) in the output is recomputed using
// the ratio of the input and output sizes.
InputImageType::SpacingType inputSpacing = itkImage->GetSpacing();
InputImageType::SpacingType outputSpacing;
const InputImageType::RegionType& inputSize = itkImage->GetLargestPossibleRegion();
InputImageType::SizeType outputSize;
typedef InputImageType::SizeType::SizeValueType SizeValueType;
// Set the output spacing.
outputSpacing[0] = spacing[0];
outputSpacing[1] = spacing[1];
outputSpacing[2] = spacing[2];
outputSize[0] = static_cast<SizeValueType>(inputSize.GetSize()[0] * inputSpacing[0] / outputSpacing[0] + .5);
outputSize[1] = static_cast<SizeValueType>(inputSize.GetSize()[1] * inputSpacing[1] / outputSpacing[1] + .5);
outputSize[2] = static_cast<SizeValueType>(inputSize.GetSize()[2] * inputSpacing[2] / outputSpacing[2] + .5);
_pResizeFilter->SetOutputSpacing(outputSpacing);
_pResizeFilter->SetSize(outputSize);
typedef itk::LinearInterpolateImageFunction< InputImageType > LinearInterpolatorType;
LinearInterpolatorType::Pointer lin_interpolator = LinearInterpolatorType::New();
typedef itk::Function::WelchWindowFunction<4> WelchWindowFunction;
typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 4,WelchWindowFunction> WindowedSincInterpolatorType;
WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
if (useLinInt)
_pResizeFilter->SetInterpolator(lin_interpolator);
else
_pResizeFilter->SetInterpolator(sinc_interpolator);
// Specify the input.
_pResizeFilter->SetInput(itkImage);
_pResizeFilter->Update();
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk(_pResizeFilter->GetOutput());
mitk::GrabItkImageMemory( _pResizeFilter->GetOutput(), image);
return image;
}
/// Build a derived file name from moving images e.g. xxx_T2.nrrd becomes xxx_GTV.nrrd
static FileListType CreateDerivedFileList(std::string baseFN, std::string baseSuffix, std::vector<std::string> derivedPatterns)
{
FileListType files;
for (unsigned int i=0; i < derivedPatterns.size(); i++)
{
std::string derResourceSuffix = derivedPatterns.at(i);
std::string derivedResourceFilename = baseFN.substr(0,baseFN.length() -baseSuffix.length()) + derResourceSuffix;
MITK_INFO <<" Looking for file: " << derivedResourceFilename;
if (!itksys::SystemTools::FileExists(derivedResourceFilename.c_str()))
{
MITK_INFO << "CreateDerivedFileList: File does not exit. Skipping entry.";
continue;
}
files.push_back(derivedResourceFilename);
}
return files;
}
/// Save images according to file type
static void SaveImage(std::string fileName, mitk::Image* image, std::string fileType )
{
MITK_INFO << "----Save to " << fileName;
- if (fileType == "dwi") // IOUtil does not handle dwi files properly Bug 15772
- {
- try
- {
- mitk::IOUtil::Save(dynamic_cast<mitk::DiffusionImage<short>*>(image), fileName.c_str());
- }
- catch( const itk::ExceptionObject& e)
- {
- MITK_ERROR << "Caught exception: " << e.what();
- mitkThrow() << "Failed with exception from subprocess!";
- }
- }
- else
- {
- mitk::IOUtil::SaveImage(image, fileName);
- }
+ mitk::IOUtil::Save(image, fileName);
}
/// Copy derived resources from first time step. Append _reg tag, but leave data untouched.
static void CopyResources(FileListType fileList, std::string outputPath)
{
for (unsigned int j=0; j < fileList.size(); j++)
{
std::string derivedResourceFilename = fileList.at(j);
std::string fileType = itksys::SystemTools::GetFilenameExtension(derivedResourceFilename);
std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(derivedResourceFilename);
std::string savePathAndFileName = outputPath +fileStem + "." + fileType;
MITK_INFO << "Copy resource " << savePathAndFileName;
mitk::Image::Pointer resImage = ExtractFirstTS(mitk::IOUtil::LoadImage(derivedResourceFilename), fileType);
mitk::IOUtil::SaveImage(resImage, savePathAndFileName);
}
}
int main( int argc, char* argv[] )
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--","-");
parser.setTitle("Folder Registraton");
parser.setCategory("Preprocessing Tools");
parser.setDescription("http://docs.mitk.org/nightly-qt4/DiffusionMiniApps.html");
parser.setContributor("MBI");
// Add command line argument names
parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Help", "Show this help text");
//parser.addArgument("usemask", "u", QVariant::Bool, "Use segmentations (derived resources) to exclude areas from registration metrics");
parser.addArgument("input", "i", mitkCommandLineParser::InputDirectory, "Input:", "Input folder",us::Any(),false);
parser.addArgument("output", "o", mitkCommandLineParser::OutputDirectory, "Output:", "Output folder (ending with /)",us::Any(),false);
parser.addArgument("fixed", "f", mitkCommandLineParser::String, "Fixed images:", "Suffix for fixed image (if none is supplied first file matching moving pattern is chosen)",us::Any(),true);
parser.addArgument("moving", "m", mitkCommandLineParser::String, "Moving images:", "Suffix for moving images",us::Any(),false);
parser.addArgument("derived", "d", mitkCommandLineParser::String, "Derived resources:", "Derived resources suffixes (replaces suffix for moving images); comma separated",us::Any(),true);
parser.addArgument("silent", "s", mitkCommandLineParser::Bool, "Silent:" "No xml progress output.");
parser.addArgument("resample", "r", mitkCommandLineParser::String, "Resample (x,y,z)mm:", "Resample provide x,y,z spacing in mm (e.g. -r 1,1,3), is not applied to tensor data",us::Any());
parser.addArgument("binary", "b", mitkCommandLineParser::Bool, "Binary:", "Speficies that derived resource are binary (interpolation using nearest neighbor)",us::Any());
parser.addArgument("correct-origin", "c", mitkCommandLineParser::Bool, "Origin correction:", "Correct for large origin displacement. Switch when you reveive: Joint PDF summed to zero ",us::Any());
parser.addArgument("sinc-int", "s", mitkCommandLineParser::Bool, "Windowed-sinc interpolation:", "Use windowed-sinc interpolation (3) instead of linear interpolation ",us::Any());
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
// Handle special arguments
bool silent = false;
bool isBinary = false;
bool alignOrigin = false;
bool useLinearInterpol = true;
{
if (parsedArgs.size() == 0)
{
return EXIT_FAILURE;
}
if (parsedArgs.count("sinc-int"))
useLinearInterpol = false;
if (parsedArgs.count("silent"))
silent = true;
if (parsedArgs.count("binary"))
isBinary = true;
if (parsedArgs.count("correct-origin"))
alignOrigin = true;
// Show a help message
if ( parsedArgs.count("help") || parsedArgs.count("h"))
{
std::cout << parser.helpText();
return EXIT_SUCCESS;
}
}
std::string refPattern = "";
bool useFirstMoving = false;
std::string movingImgPattern = us::any_cast<string>(parsedArgs["moving"]);
if (parsedArgs.count("fixed"))
{
refPattern = us::any_cast<string>(parsedArgs["fixed"]);
}
else
{
useFirstMoving = true;
refPattern = movingImgPattern;
}
std::string outputPath = us::any_cast<string>(parsedArgs["output"]);
std::string inputPath = us::any_cast<string>(parsedArgs["input"]);
//QString resampleReference = parsedArgs["resample"].toString();
//bool maskTumor = parsedArgs["usemask"].toBool();
// if derived sources pattern is provided, populate QStringList with possible filename postfixes
std::vector<std::string> derPatterns;
if (parsedArgs.count("derived") || parsedArgs.count("d") )
{
std::string arg = us::any_cast<string>(parsedArgs["derived"]);
derPatterns = split(arg ,',');
}
std::vector<std::string> spacings;
float spacing[3];
bool doResampling = false;
if (parsedArgs.count("resample") || parsedArgs.count("d") )
{
std::string arg = us::any_cast<string>(parsedArgs["resample"]);
spacings = split(arg ,',');
spacing[0] = atoi(spacings.at(0).c_str());
spacing[1] = atoi(spacings.at(1).c_str());
spacing[2] = atoi(spacings.at(2).c_str());
doResampling = true;
}
MITK_INFO << "Input Folder : " << inputPath;
MITK_INFO << "Looking for reference image ...";
FileListType referenceFileList = CreateFileList(inputPath,refPattern);
if ((!useFirstMoving && referenceFileList.size() != 1) || (useFirstMoving && referenceFileList.size() == 0))
{
MITK_ERROR << "None or more than one possible reference images (" << refPattern <<") found. Exiting." << referenceFileList.size();
MITK_INFO << "Choose a fixed arguement that is unique in the given folder!";
return EXIT_FAILURE;
}
std::string referenceFileName = referenceFileList.at(0);
MITK_INFO << "Loading Reference (fixed) image: " << referenceFileName;
std::string fileType = itksys::SystemTools::GetFilenameExtension(referenceFileName);
mitk::Image::Pointer refImage = ExtractFirstTS(mitk::IOUtil::LoadImage(referenceFileName), fileType);
mitk::Image::Pointer resampleReference = NULL;
if (doResampling)
{
refImage = ResampleBySpacing(refImage,spacing);
resampleReference = refImage;
}
if (refImage.IsNull())
MITK_ERROR << "Loaded fixed image is NULL";
// Copy reference image to destination
std::string savePathAndFileName = GetSavePath(outputPath, referenceFileName);
mitk::IOUtil::SaveImage(refImage, savePathAndFileName);
// Copy all derived resources also to output folder, adding _reg suffix
referenceFileList = CreateDerivedFileList(referenceFileName, movingImgPattern,derPatterns);
CopyResources(referenceFileList, outputPath);
std::string derivedResourceFilename;
mitk::Image::Pointer referenceMask = NULL; // union of all segmentations
if (!silent)
{
// XML Output to report progress
std::cout << "<filter-start>";
std::cout << "<filter-name>Batched Registration</filter-name>";
std::cout << "<filter-comment>Starting registration ... </filter-comment>";
std::cout << "</filter-start>";
}
// Now iterate over all files and register them to the reference image,
// also register derived resources based on file patterns
// ------------------------------------------------------------------------------
// Create File list
FileListType movingImagesList = CreateFileList(inputPath, movingImgPattern);
// TODO Reactivate Resampling Feature
// mitk::Image::Pointer resampleImage = NULL;
// if (QFileInfo(resampleReference).isFile())
// {
// resampleImage = mitk::IOUtil::LoadImage(resampleReference.toStdString());
// }
for (unsigned int i =0; i < movingImagesList.size(); i++)
{
std::string fileMorphName = movingImagesList.at(i);
if (fileMorphName == referenceFileName)
{
// do not process reference image again
continue;
}
MITK_INFO << "Processing image " << fileMorphName;
// 1 Register morphological file to reference image
if (!itksys::SystemTools::FileExists(fileMorphName.c_str()))
{
MITK_WARN << "File does not exit. Skipping entry.";
continue;
}
// Origin of images is cancelled
// TODO make this optional!!
double transf[6];
double offset[3];
{
std::string fileType = itksys::SystemTools::GetFilenameExtension(fileMorphName);
mitk::Image::Pointer movingImage = ExtractFirstTS(mitk::IOUtil::LoadImage(fileMorphName), fileType);
if (movingImage.IsNull())
MITK_ERROR << "Loaded moving image is NULL";
// Store transformation, apply it to morph file
MITK_INFO << "----------Registering moving image to reference----------";
mitk::RegistrationWrapper::GetTransformation(refImage, movingImage, transf, offset, alignOrigin, referenceMask);
mitk::RegistrationWrapper::ApplyTransformationToImage(movingImage, transf,offset, resampleReference); // , resampleImage
savePathAndFileName = GetSavePath(outputPath, fileMorphName);
if (fileType == ".dwi")
fileType = "dwi";
SaveImage(savePathAndFileName,movingImage,fileType );
}
if (!silent)
{
std::cout << "<filter-progress-text progress=\"" <<
(float)i / (float)movingImagesList.size()
<< "\" >.</filter-progress-text>";
}
// Now parse all derived resource and apply the above calculated transformation to them
// ------------------------------------------------------------------------------------
FileListType fList = CreateDerivedFileList(fileMorphName, movingImgPattern,derPatterns);
if (fList.size() > 0)
MITK_INFO << "----------DERIVED RESOURCES ---------";
for (unsigned int j=0; j < fList.size(); j++)
{
derivedResourceFilename = fList.at(j);
MITK_INFO << "----Processing derived resorce " << derivedResourceFilename << " ...";
std::string fileType = itksys::SystemTools::GetFilenameExtension(derivedResourceFilename);
mitk::Image::Pointer derivedMovingResource = ExtractFirstTS(mitk::IOUtil::LoadImage(derivedResourceFilename), fileType);
// Apply transformation to derived resource, treat derived resource as binary
mitk::RegistrationWrapper::ApplyTransformationToImage(derivedMovingResource, transf,offset, resampleReference,isBinary);
savePathAndFileName = GetSavePath(outputPath, derivedResourceFilename);
SaveImage(savePathAndFileName,derivedMovingResource,fileType );
}
}
if (!silent)
std::cout << "<filter-end/>";
return EXIT_SUCCESS;
}
diff --git a/Modules/LegacyIO/mitkItkImageFileReader.cpp b/Modules/LegacyIO/mitkItkImageFileReader.cpp
index 475610eaf1..3bdb8219ce 100644
--- a/Modules/LegacyIO/mitkItkImageFileReader.cpp
+++ b/Modules/LegacyIO/mitkItkImageFileReader.cpp
@@ -1,211 +1,237 @@
/*===================================================================
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 "mitkItkImageFileReader.h"
#include "mitkConfig.h"
#include "mitkException.h"
#include <mitkProportionalTimeGeometry.h>
#include <itkImageFileReader.h>
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
#include <itkImage.h>
//#include <itkImageSeriesReader.h>
#include <itkImageFileReader.h>
#include <itkImageIOFactory.h>
#include <itkImageIORegion.h>
+#include <itkMetaDataObject.h>
//#include <itkImageSeriesReader.h>
//#include <itkDICOMImageIO2.h>
//#include <itkDICOMSeriesFileNames.h>
//#include <itkGDCMImageIO.h>
//#include <itkGDCMSeriesFileNames.h>
//#include <itkNumericSeriesFileNames.h>
void mitk::ItkImageFileReader::GenerateData()
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO("mitkItkImageFileReader") << "Could not set locale " << locale;
}
}
mitk::Image::Pointer image = this->GetOutput();
const unsigned int MINDIM = 2;
const unsigned int MAXDIM = 4;
MITK_INFO("mitkItkImageFileReader") << "loading " << m_FileName << " via itk::ImageIOFactory... " << std::endl;
// Check to see if we can read the file given the name or prefix
if ( m_FileName == "" )
{
mitkThrow() << "Empty filename in mitk::ItkImageFileReader ";
return ;
}
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( m_FileName.c_str(), itk::ImageIOFactory::ReadMode );
if ( imageIO.IsNull() )
{
//itkWarningMacro( << "File Type not supported!" );
mitkThrow() << "Could not create itk::ImageIOBase object for filename " << m_FileName;
return ;
}
// Got to allocate space for the image. Determine the characteristics of
// the image.
imageIO->SetFileName( m_FileName.c_str() );
imageIO->ReadImageInformation();
unsigned int ndim = imageIO->GetNumberOfDimensions();
if ( ndim < MINDIM || ndim > MAXDIM )
{
itkWarningMacro( << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D." );
ndim = MAXDIM;
}
itk::ImageIORegion ioRegion( ndim );
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[ MAXDIM ];
dimensions[ 0 ] = 0;
dimensions[ 1 ] = 0;
dimensions[ 2 ] = 0;
dimensions[ 3 ] = 0;
ScalarType spacing[ MAXDIM ];
spacing[ 0 ] = 1.0f;
spacing[ 1 ] = 1.0f;
spacing[ 2 ] = 1.0f;
spacing[ 3 ] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for ( i = 0; i < ndim ; ++i )
{
ioStart[ i ] = 0;
ioSize[ i ] = imageIO->GetDimensions( i );
if(i<MAXDIM)
{
dimensions[ i ] = imageIO->GetDimensions( i );
spacing[ i ] = imageIO->GetSpacing( i );
if(spacing[ i ] <= 0)
spacing[ i ] = 1.0f;
}
if(i<3)
{
origin[ i ] = imageIO->GetOrigin( i );
}
}
ioRegion.SetSize( ioSize );
ioRegion.SetIndex( ioStart );
MITK_INFO("mitkItkImageFileReader") << "ioRegion: " << ioRegion << std::endl;
imageIO->SetIORegion( ioRegion );
void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
imageIO->Read( buffer );
image->Initialize( MakePixelType(imageIO), ndim, dimensions );
image->SetImportChannel( buffer, 0, Image::ManageMemory );
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
for ( i=0; i < itkDimMax3; ++i)
for( j=0; j < itkDimMax3; ++j )
matrix[i][j] = imageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(image->GetSlicedGeometry(0)->GetPlaneGeometry(0));
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
MITK_INFO("mitkItkImageFileReader") << slicedGeometry->GetCornerPoint(false,false,false);
MITK_INFO("mitkItkImageFileReader") << slicedGeometry->GetCornerPoint(true,true,true);
// re-initialize TimeGeometry
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
image->SetTimeGeometry(timeGeometry);
buffer = NULL;
MITK_INFO("mitkItkImageFileReader") << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
// mitk::DataNode::Pointer node = this->GetOutput();
// node->SetData( image );
// add level-window property
//if ( image->GetPixelType().GetNumberOfComponents() == 1 )
//{
// SetDefaultImageProperties( node );
//}
MITK_INFO("mitkItkImageFileReader") << "...finished!" << std::endl;
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO("mitkItkImageFileReader") << "Could not reset locale " << currLocale;
}
}
bool mitk::ItkImageFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
return false;
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( filename.c_str(), itk::ImageIOFactory::ReadMode );
if ( imageIO.IsNull() )
return false;
+ try
+ {
+ imageIO->SetFileName( filename.c_str() );
+ imageIO->ReadImageInformation();
+ itk::MetaDataDictionary imgMetaDictionary = imageIO->GetMetaDataDictionary();
+ std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+ std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+ std::string metaString;
+
+ for (; itKey != imgMetaKeys.end(); itKey ++)
+ {
+ itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+ if (itKey->find("modality") != std::string::npos)
+ {
+ if (metaString.find("DWMRI") != std::string::npos)
+ {
+ return false; // DiffusionImageReader should handle this
+ }
+ }
+ }
+ }catch(...)
+ {
+ MITK_INFO("mitkItkImageFileReader") << "Could not read ImageInformation ";
+ }
+
return true;
}
mitk::ItkImageFileReader::ItkImageFileReader()
: m_FileName(""), m_FilePrefix(""), m_FilePattern("")
{
}
mitk::ItkImageFileReader::~ItkImageFileReader()
{
}
diff --git a/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp b/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
index 1beccf113c..74b2a1df02 100644
--- a/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
+++ b/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
@@ -1,265 +1,264 @@
/*===================================================================
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 "mitkTestingMacros.h"
#include "mitkCoreObjectFactory.h"
#include "mitkBaseProperty.h"
#include "mitkProperties.h"
#include <mitkAnnotationProperty.h>
#include <mitkClippingProperty.h>
#include <mitkColorProperty.h>
#include <mitkEnumerationProperty.h>
/*
#include <mitkGridRepresentationProperty.h>
#include <mitkGridVolumeMapperProperty.h>
#include <mitkOrganTypeProperty.h>
*/
#include <mitkModalityProperty.h>
//#include <mitkOdfNormalizationMethodProperty.h>
//#include <mitkOdfScaleByProperty.h>
#include <mitkPlaneOrientationProperty.h>
#include <mitkShaderProperty.h>
#include <mitkVtkInterpolationProperty.h>
#include <mitkVtkRepresentationProperty.h>
#include <mitkVtkResliceInterpolationProperty.h>
#include <mitkVtkScalarModeProperty.h>
#include <mitkVtkVolumeRenderingProperty.h>
#include <mitkGroupTagProperty.h>
#include <mitkLevelWindowProperty.h>
#include <mitkLookupTableProperty.h>
#include <mitkStringProperty.h>
#include <mitkTransferFunctionProperty.h>
#include "mitkPropertyList.h"
#include "mitkPropertyListSerializer.h"
#include "mitkBasePropertySerializer.h"
#include <mitkPointSet.h>
#include <mitkImage.h>
#include <mitkSurface.h>
#include <mitkVtkWidgetRendering.h>
/*
#include <mitkContour.h>
#include <mitkContourSet.h>
#include <mitkMesh.h>
#include <mitkCone.h>
#include <mitkCuboid.h>
#include <mitkCylinder.h>
#include <mitkEllipsoid.h>
#include <mitkExtrudedContour.h>
#include <mitkPlane.h>
#include <mitkUnstructuredGrid.h>
*/
void TestAllProperties(const mitk::PropertyList* propList);
/**Documentation
* \brief Test for all PropertySerializer classes.
*
*/
int mitkPropertySerializationTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("PropertySerializationTest");
mitk::PropertyListSerializer::Pointer serializer = mitk::PropertyListSerializer::New(); // make sure something from the lib is actually used (registration of serializers)
/* build list of properties that will be serialized and deserialized */
mitk::PropertyList::Pointer propList = mitk::PropertyList::New();
propList->SetProperty("booltrue", mitk::BoolProperty::New(true));
propList->SetProperty("boolfalse", mitk::BoolProperty::New(false));
propList->SetProperty("int", mitk::IntProperty::New(-32));
propList->SetProperty("float", mitk::FloatProperty::New(-31.337));
propList->SetProperty("double", mitk::DoubleProperty::New(-31.337));
propList->SetProperty("string", mitk::StringProperty::New("Hello MITK"));
mitk::Point3D p3d;
mitk::FillVector3D(p3d, 1.0, 2.2, -3.3);
propList->SetProperty("p3d", mitk::Point3dProperty::New(p3d));
mitk::Point3I p3i;
mitk::FillVector3D(p3i, 1, 2, -3);
propList->SetProperty("p3i", mitk::Point3iProperty::New(p3i));
mitk::Point4D p4d;
mitk::FillVector4D(p4d, 1.5, 2.6, -3.7, 4.44);
propList->SetProperty("p4d", mitk::Point4dProperty::New(p4d));
mitk::Vector3D v3d;
mitk::FillVector3D(v3d, 1.0, 2.2, -3.3);
propList->SetProperty("v3d", mitk::Vector3DProperty::New(v3d));
propList->SetProperty("annotation", mitk::AnnotationProperty::New("My Annotation", p3d));
propList->SetProperty("clipping", mitk::ClippingProperty::New(p3d, v3d));
propList->SetProperty("color", mitk::ColorProperty::New(1.0, 0.2, 0.2));
//mitk::EnumerationProperty::Pointer en = mitk::EnumerationProperty::New();
//en->AddEnum("PC", 1); en->AddEnum("Playstation", 2); en->AddEnum("Wii", 111); en->AddEnum("XBox", 7);
//en->SetValue("XBox");
//propList->SetProperty("enum", en);
/*
propList->SetProperty("gridrep", mitk::GridRepresentationProperty::New(2));
propList->SetProperty("gridvol", mitk::GridVolumeMapperProperty::New(0));
propList->SetProperty("OrganTypeProperty", mitk::OrganTypeProperty::New("Larynx"));
*/
propList->SetProperty("modality", mitk::ModalityProperty::New("Color Doppler"));
//propList->SetProperty("OdfNormalizationMethodProperty", mitk::OdfNormalizationMethodProperty::New("Global Maximum"));
//propList->SetProperty("OdfScaleByProperty", mitk::OdfScaleByProperty::New("Principal Curvature"));
propList->SetProperty("PlaneOrientationProperty", mitk::PlaneOrientationProperty::New("Arrows in positive direction"));
propList->SetProperty("ShaderProperty", mitk::ShaderProperty::New("fixed"));
propList->SetProperty("VtkInterpolationProperty", mitk::VtkInterpolationProperty::New("Gouraud"));
propList->SetProperty("VtkRepresentationProperty", mitk::VtkRepresentationProperty::New("Surface"));
propList->SetProperty("VtkResliceInterpolationProperty", mitk::VtkResliceInterpolationProperty::New("Cubic"));
propList->SetProperty("VtkScalarModeProperty", mitk::VtkScalarModeProperty::New("PointFieldData"));
propList->SetProperty("VtkVolumeRenderingProperty", mitk::VtkVolumeRenderingProperty::New("COMPOSITE"));
mitk::BoolLookupTable blt;
blt.SetTableValue(0, true); blt.SetTableValue(1, false); blt.SetTableValue(2, true);
propList->SetProperty("BoolLookupTableProperty", mitk::BoolLookupTableProperty::New(blt));
mitk::FloatLookupTable flt;
flt.SetTableValue(0, 3.1); flt.SetTableValue(1, 3.3); flt.SetTableValue(2, 7.0);
propList->SetProperty("FloatLookupTableProperty", mitk::FloatLookupTableProperty::New(flt));
mitk::IntLookupTable ilt;
ilt.SetTableValue(0, 3); ilt.SetTableValue(1, 2); ilt.SetTableValue(2, 11);
propList->SetProperty("IntLookupTableProperty", mitk::IntLookupTableProperty::New(ilt));
mitk::StringLookupTable slt;
slt.SetTableValue(0, "Hello"); slt.SetTableValue(1, "MITK"); slt.SetTableValue(2, "world");
propList->SetProperty("StringLookupTableProperty", mitk::StringLookupTableProperty::New(slt));
propList->SetProperty("GroupTagProperty", mitk::GroupTagProperty::New());
propList->SetProperty("LevelWindowProperty", mitk::LevelWindowProperty::New(mitk::LevelWindow(100.0, 50.0)));
mitk::LookupTable::Pointer lt = mitk::LookupTable::New();
lt->ChangeOpacityForAll(0.25);
lt->ChangeOpacity(17, 0.88);
propList->SetProperty("LookupTableProperty", mitk::LookupTableProperty::New(lt));
propList->SetProperty("StringProperty", mitk::StringProperty::New("Oh why, gruel world"));
//mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
//tf->SetTransferFunctionMode(1);
//propList->SetProperty("TransferFunctionProperty", mitk::TransferFunctionProperty::New(tf));
MITK_TEST_CONDITION_REQUIRED(propList->GetMap()->size() > 0, "Initialize PropertyList");
TestAllProperties(propList);
/* test default property lists of basedata objects */
// activate the following tests after MaterialProperty is deleted
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(mitk::PointSet::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Image::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Surface::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::VtkWidgetRendering::New());
TestAllProperties(node->GetPropertyList());
/*
node->SetData(mitk::Contour::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::ContourSet::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Mesh::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Cone::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Cuboid::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Cylinder::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Ellipsoid::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::ExtrudedContour::New());
TestAllProperties(node->GetPropertyList());
node->SetData(mitk::Plane::New());
TestAllProperties(node->GetPropertyList());
//node->SetData(mitk::TrackingVolume::New()); // TrackingVolume is in IGT Module, it does not have special properties, therefore we skip it here
//TestAllProperties(node->GetPropertyList());
node->SetData(mitk::UnstructuredGrid::New());
TestAllProperties(node->GetPropertyList());
*/
/* untested base data types:
BaseDataTestImplementation
RenderWindowFrame
- mitk::DiffusionImage< TPixelType >
GeometryData
mitk::PlaneGeometryData
GradientBackground
ItkBaseDataAdapter
ManufacturerLogo
SlicedData
QBallImage
SeedsImage
TensorImage
BoundingObject
BoundingObjectGroup
*/
MITK_TEST_END();
}
void TestAllProperties(const mitk::PropertyList* propList)
{
assert(propList);
/* try to serialize each property in the list, then deserialize again and check for equality */
for (mitk::PropertyList::PropertyMap::const_iterator it = propList->GetMap()->begin(); it != propList->GetMap()->end(); ++it)
{
const mitk::BaseProperty* prop = it->second;
// construct name of serializer class
std::string serializername = std::string(prop->GetNameOfClass()) + "Serializer";
std::list<itk::LightObject::Pointer> allSerializers = itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
MITK_TEST_CONDITION(allSerializers.size() > 0, std::string("Creating serializers for ") + serializername);
if (allSerializers.size() == 0)
{
MITK_TEST_OUTPUT( << "serialization not possible, skipping " << prop->GetNameOfClass());
continue;
}
if (allSerializers.size() > 1)
{
MITK_TEST_OUTPUT (<< "Warning: " << allSerializers.size() << " serializers found for " << prop->GetNameOfClass() << "testing only the first one.");
}
mitk::BasePropertySerializer* serializer = dynamic_cast<mitk::BasePropertySerializer*>( allSerializers.begin()->GetPointer());
MITK_TEST_CONDITION(serializer != NULL, serializername + std::string(" is valid"));
if (serializer != NULL)
{
serializer->SetProperty(prop);
TiXmlElement* valueelement = NULL;
try
{
valueelement = serializer->Serialize();
}
catch (...)
{
}
MITK_TEST_CONDITION(valueelement != NULL, std::string("Serialize property with ") + serializername);
if (valueelement == NULL)
{
MITK_TEST_OUTPUT( << "serialization failed, skipping deserialization");
continue;
}
mitk::BaseProperty::Pointer deserializedProp = serializer->Deserialize( valueelement );
MITK_TEST_CONDITION(deserializedProp.IsNotNull(), "serializer created valid property");
if (deserializedProp.IsNotNull())
{
MITK_TEST_CONDITION(*(deserializedProp.GetPointer()) == *prop, "deserialized property equals initial property for type " << prop->GetNameOfClass());
}
}
else
{
MITK_TEST_OUTPUT( << "created serializer object is of class " << allSerializers.begin()->GetPointer()->GetNameOfClass())
}
} // for all properties
}
diff --git a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
index 40d92b2cdf..210aa03fc6 100644
--- a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
+++ b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
@@ -1,61 +1,64 @@
/*===================================================================
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 "mitkDiffusionImagingActivator.h"
#include "QmitkNodeDescriptorManager.h"
#include "mitkNodePredicateDataType.h"
+#include "mitkNodePredicateProperty.h"
+#include "mitkNodePredicateIsDWI.h"
+#include <mitkDiffusionPropertyHelper.h>
#include <QtPlugin>
void
mitk::DiffusionImagingActivator::start(ctkPluginContext* context)
{
Q_UNUSED(context)
QmitkNodeDescriptorManager* manager =
QmitkNodeDescriptorManager::GetInstance();
- mitk::NodePredicateDataType::Pointer isDiffusionImage = mitk::NodePredicateDataType::New("DiffusionImage");
+ mitk::NodePredicateIsDWI::Pointer isDiffusionImage = mitk::NodePredicateIsDWI::New();
QmitkNodeDescriptor* desc = new QmitkNodeDescriptor(QObject::tr("DiffusionImage"), QString(":/QmitkDiffusionImaging/QBallData24.png"), isDiffusionImage, manager);
manager->AddDescriptor(desc);
mitk::NodePredicateDataType::Pointer isTensorImage = mitk::NodePredicateDataType::New("TensorImage");
manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("TensorImage"), QString(":/QmitkDiffusionImaging/recontensor.png"), isTensorImage, manager));
mitk::NodePredicateDataType::Pointer isQBallImage = mitk::NodePredicateDataType::New("QBallImage");
manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("QBallImage"), QString(":/QmitkDiffusionImaging/reconodf.png"), isQBallImage, manager));
mitk::NodePredicateDataType::Pointer isFiberBundle = mitk::NodePredicateDataType::New("FiberBundle");
manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundle"), QString(":/QmitkDiffusionImaging/FiberBundle.png"), isFiberBundle, manager));
mitk::NodePredicateDataType::Pointer isFiberBundleX = mitk::NodePredicateDataType::New("FiberBundleX");
manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundleX"), QString(":/QmitkDiffusionImaging/FiberBundleX.png"), isFiberBundleX, manager));
mitk::NodePredicateDataType::Pointer isConnectomicsNetwork = mitk::NodePredicateDataType::New("ConnectomicsNetwork");
manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("ConnectomicsNetwork"), QString(":/QmitkDiffusionImaging/ConnectomicsNetwork.png"), isConnectomicsNetwork, manager));
}
void
mitk::DiffusionImagingActivator::stop(ctkPluginContext* context)
{
Q_UNUSED(context)
}
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
Q_EXPORT_PLUGIN2(org_mitk_diffusionimaging, mitk::DiffusionImagingActivator)
#endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index c9059bb39f..50cfe086bc 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1829 +1,1839 @@
/*===================================================================
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 "QmitkControlVisualizationPropertiesView.h"
#include "mitkNodePredicateDataType.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkResliceMethodProperty.h"
#include "mitkRenderingManager.h"
#include "mitkTbssImage.h"
#include "mitkPlanarFigure.h"
#include "mitkFiberBundleX.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFiberBundleInteractor.h"
#include "mitkPlanarFigureInteractor.h"
#include <mitkQBallImage.h>
#include <mitkTensorImage.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
#include <mitkConnectomicsNetwork.h>
#include "mitkGlobalInteraction.h"
#include "usModuleRegistry.h"
#include "mitkPlaneGeometry.h"
#include "berryIWorkbenchWindow.h"
#include "berryIWorkbenchPage.h"
#include "berryISelectionService.h"
#include "berryConstants.h"
#include "berryPlatformUI.h"
#include "itkRGBAPixel.h"
#include <itkTractDensityImageFilter.h>
#include "qwidgetaction.h"
#include "qcolordialog.h"
#include <itkMultiThreader.h>
#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
static bool DetermineAffectedImageSlice( const mitk::Image* image, const mitk::PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
{
assert(image);
assert(plane);
// compare normal of plane to the three axis vectors of the image
mitk::Vector3D normal = plane->GetNormal();
mitk::Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
mitk::Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
mitk::Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
normal.Normalize();
imageNormal0.Normalize();
imageNormal1.Normalize();
imageNormal2.Normalize();
imageNormal0.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal0.GetVnlVector()) );
imageNormal1.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal1.GetVnlVector()) );
imageNormal2.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal2.GetVnlVector()) );
double eps( 0.00001 );
// axial
if ( imageNormal2.GetNorm() <= eps )
{
affectedDimension = 2;
}
// sagittal
else if ( imageNormal1.GetNorm() <= eps )
{
affectedDimension = 1;
}
// frontal
else if ( imageNormal0.GetNorm() <= eps )
{
affectedDimension = 0;
}
else
{
affectedDimension = -1; // no idea
return false;
}
// determine slice number in image
mitk::BaseGeometry* imageGeometry = image->GetGeometry(0);
mitk::Point3D testPoint = imageGeometry->GetCenter();
mitk::Point3D projectedPoint;
plane->Project( testPoint, projectedPoint );
mitk::Point3D indexPoint;
imageGeometry->WorldToIndex( projectedPoint, indexPoint );
affectedSlice = ROUND( indexPoint[affectedDimension] );
MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice " << affectedSlice;
// check if this index is still within the image
if ( affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)) ) return false;
return true;
}
const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
using namespace berry;
struct CvpSelListener : ISelectionListener
{
berryObjectMacro(CvpSelListener);
CvpSelListener(QmitkControlVisualizationPropertiesView* view)
{
m_View = view;
}
void ApplySettings(mitk::DataNode::Pointer node)
{
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
int val;
node->GetIntProperty("ShowMaxNumber", val);
m_View->m_Controls->m_ShowMaxNumber->setValue(val);
m_View->m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
float fval;
node->GetFloatProperty("Scaling",fval);
m_View->m_Controls->m_ScalingFactor->setValue(fval);
m_View->m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
node->GetFloatProperty("IndexParam1",fval);
m_View->m_Controls->m_IndexParam1->setValue(fval);
node->GetFloatProperty("IndexParam2",fval);
m_View->m_Controls->m_IndexParam2->setValue(fval);
}
void DoSelectionChanged(ISelection::ConstPointer selection)
{
// save current selection in member variable
m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
m_View->m_Controls->m_VisibleOdfsON_T->setVisible(false);
m_View->m_Controls->m_VisibleOdfsON_S->setVisible(false);
m_View->m_Controls->m_VisibleOdfsON_C->setVisible(false);
m_View->m_Controls->m_TextureIntON->setVisible(false);
m_View->m_Controls->m_ImageControlsFrame->setVisible(false);
m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(false);
m_View->m_Controls->m_BundleControlsFrame->setVisible(false);
m_View->m_SelectedNode = 0;
if(m_View->m_CurrentSelection.IsNull())
return;
if(m_View->m_CurrentSelection->Size() == 1)
{
mitk::DataNodeObject::Pointer nodeObj = m_View->m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
if(nodeObj.IsNotNull())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData != NULL )
{
if(dynamic_cast<mitk::PlanarFigure*>(nodeData) != 0)
{
m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(true);
m_View->m_SelectedNode = node;
float val;
node->GetFloatProperty("planarfigure.line.width", val);
m_View->m_Controls->m_PFWidth->setValue((int)(val*10.0));
QString label = "Width %1";
label = label.arg(val);
m_View->m_Controls->label_pfwidth->setText(label);
float color[3];
node->GetColor( color, NULL, "planarfigure.default.line.color");
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_View->m_Controls->m_PFColor->setAutoFillBackground(true);
m_View->m_Controls->m_PFColor->setStyleSheet(styleSheet);
node->GetColor( color, NULL, "color");
styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_View->PlanarFigureFocus();
}
if(dynamic_cast<mitk::FiberBundleX*>(nodeData) != 0)
{
m_View->m_Controls->m_BundleControlsFrame->setVisible(true);
m_View->m_SelectedNode = node;
if(m_View->m_CurrentPickingNode != 0 && node.GetPointer() != m_View->m_CurrentPickingNode)
{
m_View->m_Controls->m_Crosshair->setEnabled(false);
}
else
{
m_View->m_Controls->m_Crosshair->setEnabled(true);
}
int width;
node->GetIntProperty("LineWidth", width);
m_View->m_Controls->m_LineWidth->setValue(width);
float range;
node->GetFloatProperty("Fiber2DSliceThickness",range);
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
mitk::BaseGeometry::Pointer geo = fib->GetGeometry();
mitk::ScalarType max = geo->GetExtentInMM(0);
max = std::max(max, geo->GetExtentInMM(1));
max = std::max(max, geo->GetExtentInMM(2));
m_View->m_Controls->m_FiberThicknessSlider->setMaximum(max * 10);
m_View->m_Controls->m_FiberThicknessSlider->setValue(range * 10);
}
} // check node data != NULL
}
}
if(m_View->m_CurrentSelection->Size() > 0 && m_View->m_SelectedNode == 0)
{
m_View->m_Controls->m_ImageControlsFrame->setVisible(true);
bool foundDiffusionImage = false;
bool foundQBIVolume = false;
bool foundTensorVolume = false;
bool foundImage = false;
bool foundMultipleOdfImages = false;
bool foundRGBAImage = false;
bool foundTbssImage = false;
// do something with the selected items
if(m_View->m_CurrentSelection)
{
// iterate selection
for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
i != m_View->m_CurrentSelection->End(); ++i)
{
// extract datatree node
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
mitk::BaseData* nodeData = node->GetData();
if(nodeData != NULL )
{
// only look at interesting types
if(QString("DiffusionImage").compare(nodeData->GetNameOfClass())==0)
{
foundDiffusionImage = true;
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
int val;
node->GetIntProperty("DisplayChannel", val);
m_View->m_Controls->m_DisplayIndex->setValue(val);
m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
QString label = "Channel %1";
label = label.arg(val);
m_View->m_Controls->label_channel->setText(label);
- int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(nodeData))->GetVectorImage()->GetVectorLength();
+ mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+ mitk::CastToItkImage(dynamic_cast<mitk::Image*>(nodeData), itkVectorImagePointer);
+
+ int maxVal = itkVectorImagePointer->GetVectorLength();
m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
}
if(QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
{
foundTbssImage = true;
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
int val;
node->GetIntProperty("DisplayChannel", val);
m_View->m_Controls->m_DisplayIndex->setValue(val);
m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
QString label = "Channel %1";
label = label.arg(val);
m_View->m_Controls->label_channel->setText(label);
int maxVal = (dynamic_cast<mitk::TbssImage* >(nodeData))->GetImage()->GetVectorLength();
m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
}
else if(QString("QBallImage").compare(nodeData->GetNameOfClass())==0)
{
foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
foundQBIVolume = true;
ApplySettings(node);
}
else if(QString("TensorImage").compare(nodeData->GetNameOfClass())==0)
{
foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
foundTensorVolume = true;
ApplySettings(node);
}
else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
{
foundImage = true;
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(nodeData);
if(img.IsNotNull()
&& img->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA
&& img->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR )
{
foundRGBAImage = true;
}
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
}
} // END CHECK node != NULL
}
}
}
m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
&& !foundMultipleOdfImages;
m_View->m_Controls->m_NumberGlyphsFrame->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_NormalizationDropdown->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->label->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_ScalingFactor->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_AdditionalScaling->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_NormalizationScalingFrame->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->OpacMinFrame->setVisible(foundRGBAImage || m_View->m_FoundSingleOdfImage);
// changed for SPIE paper, Principle curvature scaling
//m_View->m_Controls->params_frame->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->params_frame->setVisible(false);
m_View->m_Controls->m_VisibleOdfsON_T->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_VisibleOdfsON_S->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_VisibleOdfsON_C->setVisible(m_View->m_FoundSingleOdfImage);
bool foundAnyImage = foundDiffusionImage ||
foundQBIVolume || foundTensorVolume || foundImage || foundTbssImage;
m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
}
}
void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
{
// check, if selection comes from datamanager
if (part)
{
QString partname(part->GetPartName().c_str());
if(partname.compare("Data Manager")==0)
{
// apply selection
DoSelectionChanged(selection);
}
}
}
QmitkControlVisualizationPropertiesView* m_View;
};
QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL),
m_NodeUsedForOdfVisualization(NULL),
m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
m_CurrentSelection(0),
m_CurrentPickingNode(0),
m_GlyIsOn_S(false),
m_GlyIsOn_C(false),
m_GlyIsOn_T(false),
m_FiberBundleObserverTag(0),
m_Color(NULL)
{
currentThickSlicesMode = 1;
m_MyMenu = NULL;
int numThread = itk::MultiThreader::GetGlobalMaximumNumberOfThreads();
if (numThread > 12)
numThread = 12;
itk::MultiThreader::SetGlobalDefaultNumberOfThreads(numThread);
}
QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
{
if(m_SlicesRotationObserverTag1 )
{
mitk::SlicesCoordinator::Pointer coordinator = m_MultiWidget->GetSlicesRotator();
if( coordinator.IsNotNull() )
coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
}
if( m_SlicesRotationObserverTag2)
{
mitk::SlicesCoordinator::Pointer coordinator = m_MultiWidget->GetSlicesRotator();
if( coordinator.IsNotNull() )
coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
}
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
}
void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
{
currentThickSlicesMode = action->data().toInt();
switch(currentThickSlicesMode)
{
default:
case 1:
this->m_Controls->m_TSMenu->setText("MIP");
break;
case 2:
this->m_Controls->m_TSMenu->setText("SUM");
break;
case 3:
this->m_Controls->m_TSMenu->setText("WEIGH");
break;
}
mitk::DataNode* n;
n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
mitk::BaseRenderer::Pointer renderer =
this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
if(renderer.IsNotNull())
{
renderer->SendUpdateSlice();
}
renderer->GetRenderingManager()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::OnTSNumChanged(int num)
{
if(num==0)
{
mitk::DataNode* n;
n = this->m_MultiWidget->GetWidgetPlane1();
if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
n = this->m_MultiWidget->GetWidgetPlane2();
if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
n = this->m_MultiWidget->GetWidgetPlane3();
if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
}
else
{
mitk::DataNode* n;
n = this->m_MultiWidget->GetWidgetPlane1();
if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
n = this->m_MultiWidget->GetWidgetPlane2();
if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
n = this->m_MultiWidget->GetWidgetPlane3();
if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
}
m_TSLabel->setText(QString::number(num*2+1));
mitk::BaseRenderer::Pointer renderer = this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
if(renderer.IsNotNull())
renderer->SendUpdateSlice();
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
if(renderer.IsNotNull())
renderer->SendUpdateSlice();
renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
if(renderer.IsNotNull())
renderer->SendUpdateSlice();
renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
}
void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
// hide warning (ODFs in rotated planes)
m_Controls->m_lblRotatedPlanesWarning->hide();
m_MyMenu = new QMenu(parent);
// button for changing rotation mode
m_Controls->m_TSMenu->setMenu( m_MyMenu );
//m_CrosshairModeButton->setIcon( QIcon( iconCrosshairMode_xpm ) );
m_Controls->params_frame->setVisible(false);
QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
m_Controls->m_Reinit->setIcon(icon5);
m_Controls->m_Focus->setIcon(icon5);
QIcon iconColor(":/QmitkDiffusionImaging/color24.gif");
m_Controls->m_PFColor->setIcon(iconColor);
m_Controls->m_Color->setIcon(iconColor);
QIcon iconReset(":/QmitkDiffusionImaging/reset.png");
m_Controls->m_ResetColoring->setIcon(iconReset);
m_Controls->m_PFColor->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QIcon iconCrosshair(":/QmitkDiffusionImaging/crosshair.png");
m_Controls->m_Crosshair->setIcon(iconCrosshair);
// was is los
QIcon iconPaint(":/QmitkDiffusionImaging/paint2.png");
m_Controls->m_TDI->setIcon(iconPaint);
QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
m_Controls->m_TextureIntON->setCheckable(true);
#ifndef DIFFUSION_IMAGING_EXTENDED
int size = m_Controls->m_AdditionalScaling->count();
for(int t=0; t<size; t++)
{
if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
{
m_Controls->m_AdditionalScaling->removeItem(t);
}
}
#endif
m_Controls->m_OpacitySlider->setRange(0.0,1.0);
m_Controls->m_OpacitySlider->setMinimumValue(0.0);
m_Controls->m_OpacitySlider->setMaximumValue(0.0);
m_Controls->m_ScalingFrame->setVisible(false);
m_Controls->m_NormalizationFrame->setVisible(false);
}
m_IsInitialized = false;
m_SelListener = berry::ISelectionListener::Pointer(new CvpSelListener(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
m_IsInitialized = true;
}
void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
if (m_MultiWidget)
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if (coordinator)
{
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
}
coordinator = m_MultiWidget->GetSlicesSwiveller();
if (coordinator)
{
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
}
}
}
void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
{
// test if plane rotated
if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
{
if( this->IsPlaneRotated() )
{
// show label
m_Controls->m_lblRotatedPlanesWarning->show();
}
else
{
//hide label
m_Controls->m_lblRotatedPlanesWarning->hide();
}
}
}
void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkControlVisualizationPropertiesView::NodeRemoved(const mitk::DataNode* node)
{
}
#include <mitkMessage.h>
void QmitkControlVisualizationPropertiesView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_DisplayIndex), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
connect( (QObject*)(m_Controls->m_DisplayIndexSpinBox), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
connect( (QObject*)(m_Controls->m_Reinit), SIGNAL(clicked()), this, SLOT(Reinit()) );
connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
connect( (QObject*)(m_Controls->m_IndexParam1), SIGNAL(valueChanged(double)), this, SLOT(IndexParam1Changed(double)) );
connect( (QObject*)(m_Controls->m_IndexParam2), SIGNAL(valueChanged(double)), this, SLOT(IndexParam2Changed(double)) );
connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
connect( (QObject*)(m_Controls->m_OpacitySlider), SIGNAL(spanChanged(double,double)), this, SLOT(OpacityChanged(double,double)) );
connect((QObject*) m_Controls->m_Color, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationColor()));
connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
connect((QObject*) m_Controls->m_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
connect((QObject*) m_Controls->m_PFWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(PFWidth(int)));
connect((QObject*) m_Controls->m_PFColor, SIGNAL(clicked()), (QObject*) this, SLOT(PFColor()));
connect((QObject*) m_Controls->m_TDI, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateTdi()));
connect((QObject*) m_Controls->m_LineWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(LineWidthChanged()));
}
}
void QmitkControlVisualizationPropertiesView::Activated()
{
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
QmitkFunctionality::Activated();
}
void QmitkControlVisualizationPropertiesView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
int QmitkControlVisualizationPropertiesView::GetSizeFlags(bool width)
{
if(!width)
{
return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
}
else
{
return 0;
}
}
int QmitkControlVisualizationPropertiesView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
{
if(width==false)
{
return m_FoundSingleOdfImage ? 120 : 80;
}
else
{
return preferredResult;
}
}
// set diffusion image channel to b0 volume
void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
{
mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
- if (dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData()))
+
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+
+ if (isDiffusionImage)
{
- mitk::DiffusionImage<short>::Pointer dimg = dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData());
+ mitk::Image::Pointer dimg = dynamic_cast<mitk::Image*>(notConst->GetData());
// if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
// and hence we cannot set the Property directly to .front()
int displayChannelPropertyValue = 0;
- mitk::DiffusionImage<short>::BValueMap map = dimg->GetBValueMap();
+ mitk::BValueMapProperty* bmapproperty = static_cast<mitk::BValueMapProperty*>(dimg->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() );
+ mitk::DiffusionPropertyHelper::BValueMapType map = bmapproperty->GetBValueMap();
if( map[0].size() > 0)
displayChannelPropertyValue = map[0].front();
notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
}
}
/* OnSelectionChanged is registered to SelectionService, therefore no need to
implement SelectionService Listener explicitly */
void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
// deactivate channel slider if no diffusion weighted image or tbss image is selected
m_Controls->m_DisplayIndex->setVisible(false);
m_Controls->m_DisplayIndexSpinBox->setVisible(false);
m_Controls->label_channel->setVisible(false);
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+
+
if (node.IsNotNull() && (dynamic_cast<mitk::TbssImage*>(nodeData) ||
- dynamic_cast<mitk::DiffusionImage<short>*>(nodeData)))
+ isDiffusionImage))
{
m_Controls->m_DisplayIndex->setVisible(true);
m_Controls->m_DisplayIndexSpinBox->setVisible(true);
m_Controls->label_channel->setVisible(true);
}
else if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
if (m_Color.IsNotNull())
m_Color->RemoveObserver(m_FiberBundleObserverTag);
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
if (m_Color.IsNotNull())
m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
}
}
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData)) )
{
if(m_NodeUsedForOdfVisualization.IsNotNull())
{
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
}
m_NodeUsedForOdfVisualization = node;
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
m_Controls->m_TSMenu->setVisible(false); // deactivate mip etc. for tensor and q-ball images
break;
}
else if( node.IsNotNull() && dynamic_cast<mitk::ConnectomicsNetwork*>(nodeData) )
m_Controls->m_TSMenu->setVisible(false);
else
m_Controls->m_TSMenu->setVisible(true);
}
// if selection changes, set the current selction member and call SellListener::DoSelectionChanged
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
// adapt thick slice controls
// THICK SLICE SUPPORT
if( nodes.size() < 1)
return;
mitk::DataNode::Pointer node = nodes.at(0);
if( node.IsNull() )
return;
QMenu *myMenu = m_MyMenu;
myMenu->clear();
QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
thickSlicesActionGroup->setExclusive(true);
int currentTSMode = 0;
{
mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(node->GetProperty( "reslice.thickslices" ));
if( m.IsNotNull() )
currentTSMode = m->GetValueAsId();
}
int maxTS = 30;
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::Image* image = dynamic_cast<mitk::Image*>((*it)->GetData());
if (image)
{
int size = std::max(image->GetDimension(0), std::max(image->GetDimension(1), image->GetDimension(2)));
if (size>maxTS)
maxTS=size;
}
}
maxTS /= 2;
int currentNum = 0;
{
mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(node->GetProperty( "reslice.thickslices.num" ));
if( m.IsNotNull() )
{
currentNum = m->GetValue();
if(currentNum < 0) currentNum = 0;
if(currentNum > maxTS) currentNum = maxTS;
}
}
if(currentTSMode==0)
currentNum=0;
QSlider *m_TSSlider = new QSlider(myMenu);
m_TSSlider->setMinimum(0);
m_TSSlider->setMaximum(maxTS-1);
m_TSSlider->setValue(currentNum);
m_TSSlider->setOrientation(Qt::Horizontal);
connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
QHBoxLayout* _TSLayout = new QHBoxLayout;
_TSLayout->setContentsMargins(4,4,4,4);
_TSLayout->addWidget(m_TSSlider);
_TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
QWidget* _TSWidget = new QWidget;
_TSWidget->setLayout(_TSLayout);
QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
thickSliceModeActionGroup->setExclusive(true);
QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
m_TSSliderAction->setDefaultWidget(_TSWidget);
myMenu->addAction(m_TSSliderAction);
QAction* mipThickSlicesAction = new QAction(myMenu);
mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
mipThickSlicesAction->setText("MIP (max. intensity proj.)");
mipThickSlicesAction->setCheckable(true);
mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
mipThickSlicesAction->setData(1);
myMenu->addAction( mipThickSlicesAction );
QAction* sumThickSlicesAction = new QAction(myMenu);
sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
sumThickSlicesAction->setText("SUM (sum intensity proj.)");
sumThickSlicesAction->setCheckable(true);
sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
sumThickSlicesAction->setData(2);
myMenu->addAction( sumThickSlicesAction );
QAction* weightedThickSlicesAction = new QAction(myMenu);
weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
weightedThickSlicesAction->setCheckable(true);
weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
weightedThickSlicesAction->setData(3);
myMenu->addAction( weightedThickSlicesAction );
connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
}
mitk::DataStorage::SetOfObjects::Pointer
QmitkControlVisualizationPropertiesView::ActiveSet(std::string classname)
{
if (m_CurrentSelection)
{
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
i != m_CurrentSelection->End();
++i)
{
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
const mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if(QString(classname.c_str()).compare(nodeData->GetNameOfClass())==0)
{
set->InsertElement(at++, node);
}
}
}
return set;
}
return 0;
}
void QmitkControlVisualizationPropertiesView::SetBoolProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, bool value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetBoolProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetIntProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, int value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetFloatProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, float value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetFloatProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetLevelWindowProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::LevelWindow value)
{
if(set.IsNotNull())
{
mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), prop);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetEnumProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::EnumerationProperty::Pointer value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::DisplayIndexChanged(int dispIndex)
{
m_Controls->m_DisplayIndex->setValue(dispIndex);
m_Controls->m_DisplayIndexSpinBox->setValue(dispIndex);
QString label = "Channel %1";
label = label.arg(dispIndex);
m_Controls->label_channel->setText(label);
std::vector<std::string> sets;
- sets.push_back("DiffusionImage");
sets.push_back("TbssImage");
std::vector<std::string>::iterator it = sets.begin();
while(it != sets.end())
{
std::string s = *it;
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet(s);
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
++itemiter;
}
//m_MultiWidget->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
it++;
}
}
void QmitkControlVisualizationPropertiesView::Reinit()
{
if (m_CurrentSelection)
{
mitk::DataNodeObject::Pointer nodeObj =
m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkControlVisualizationPropertiesView::TextIntON()
{
if(m_TexIsOn)
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
}
else
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("DiffusionImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("TensorImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("QBallImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("Image");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
m_TexIsOn = !m_TexIsOn;
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
{
m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
VisibleOdfsON(0);
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
{
m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
VisibleOdfsON(1);
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
{
m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
VisibleOdfsON(2);
}
bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
{
// for all 2D renderwindows of m_MultiWidget check alignment
mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
if (displayPlane.IsNull()) return false;
mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
if( currentImage == NULL )
{
MITK_ERROR << " Casting problems. Returning false";
return false;
}
int affectedDimension(-1);
int affectedSlice(-1);
return !(DetermineAffectedImageSlice( currentImage, displayPlane, affectedDimension, affectedSlice ));
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON(int view)
{
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
{
int maxNr = m_Controls->m_ShowMaxNumber->value();
if ( maxNr < 1 )
{
m_Controls->m_ShowMaxNumber->setValue( 1 );
maxNr = 1;
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
set = ActiveSet("TensorImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
{
typedef mitk::OdfNormalizationMethodProperty PropType;
PropType::Pointer normMeth = PropType::New();
switch(normDropdown)
{
case 0:
normMeth->SetNormalizationToMinMax();
break;
case 1:
normMeth->SetNormalizationToMax();
break;
case 2:
normMeth->SetNormalizationToNone();
break;
case 3:
normMeth->SetNormalizationToGlobalMax();
break;
default:
normMeth->SetNormalizationToMinMax();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
// if(m_MultiWidget)
// m_MultiWidget->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"Scaling", scalingFactor);
set = ActiveSet("TensorImage");
SetFloatProp(set,"Scaling", scalingFactor);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
{
typedef mitk::OdfScaleByProperty PropType;
PropType::Pointer scaleBy = PropType::New();
switch(additionalScaling)
{
case 0:
scaleBy->SetScaleByNothing();
break;
case 1:
scaleBy->SetScaleByGFA();
//m_Controls->params_frame->setVisible(true);
break;
#ifdef DIFFUSION_IMAGING_EXTENDED
case 2:
scaleBy->SetScaleByPrincipalCurvature();
// commented in for SPIE paper, Principle curvature scaling
//m_Controls->params_frame->setVisible(true);
break;
#endif
default:
scaleBy->SetScaleByNothing();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::IndexParam1Changed(double param1)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam1", param1);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam1", param1);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::IndexParam2Changed(double param2)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam2", param2);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam2", param2);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::OpacityChanged(double l, double u)
{
mitk::LevelWindow olw;
olw.SetRangeMinMax(l*255, u*255);
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("TensorImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("Image");
SetLevelWindowProp(set,"opaclevelwindow", olw);
m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
{
m_Controls->m_ScalingFrame->setVisible(
m_Controls->m_ScalingCheckbox->isChecked());
if(!m_Controls->m_ScalingCheckbox->isChecked())
{
m_Controls->m_AdditionalScaling->setCurrentIndex(0);
m_Controls->m_ScalingFactor->setValue(1.0);
}
}
void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
{
if (m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()) )
{
bool currentMode;
m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
{
if (m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
{
float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
float currentThickness = 0;
m_SelectedNode->GetFloatProperty("Fiber2DSliceThickness", currentThickness);
if (fabs(fibThickness-currentThickness)<0.001)
return;
m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
{
QString label = "Range %1 mm";
label = label.arg(value * 0.1);
m_Controls->label_range->setText(label);
this->FiberSlicingThickness2D();
}
void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
{
float color[3];
m_SelectedNode->GetColor(color);
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color[0], color[1], color[2]));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationColor()
{
if(m_SelectedNode)
{
QColor color = QColorDialog::getColor();
if (!color.isValid())
return;
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
{
if(m_SelectedNode)
{
MITK_INFO << "reset colorcoding to oBased";
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(255,255,255)";
m_Controls->m_Color->setStyleSheet(styleSheet);
// m_SelectedNode->SetProperty("color",NULL);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(1.0, 1.0, 1.0));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED);
fib->DoColorCodingOrientationBased();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
{
if(m_SelectedNode)
{
mitk::PlanarFigure* _PlanarFigure = 0;
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry())
{
QmitkRenderWindow* selectedRenderWindow = 0;
bool PlanarFigureInitializedWindow = false;
QmitkRenderWindow* RenderWindow1 =
this->GetActiveStdMultiWidget()->GetRenderWindow1();
if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
{
selectedRenderWindow = RenderWindow1;
}
QmitkRenderWindow* RenderWindow2 =
this->GetActiveStdMultiWidget()->GetRenderWindow2();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow2->GetRenderer()))
{
selectedRenderWindow = RenderWindow2;
}
QmitkRenderWindow* RenderWindow3 =
this->GetActiveStdMultiWidget()->GetRenderWindow3();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow3->GetRenderer()))
{
selectedRenderWindow = RenderWindow3;
}
QmitkRenderWindow* RenderWindow4 =
this->GetActiveStdMultiWidget()->GetRenderWindow4();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow4->GetRenderer()))
{
selectedRenderWindow = RenderWindow4;
}
const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry1 =
RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane1 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry2 =
RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane2 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry3 =
RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane3 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
normal[0] = fabs(normal[0]); normal[1] = fabs(normal[1]); normal[2] = fabs(normal[2]);
normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
double ang1 = angle(normal, normal1);
double ang2 = angle(normal, normal2);
double ang3 = angle(normal, normal3);
if(ang1 < ang2 && ang1 < ang3)
{
selectedRenderWindow = RenderWindow1;
}
else
{
if(ang2 < ang3)
{
selectedRenderWindow = RenderWindow2;
}
else
{
selectedRenderWindow = RenderWindow3;
}
}
// make node visible
if (selectedRenderWindow)
{
const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
centerP, _PlaneGeometry->GetNormal());
}
}
// set interactor for new node (if not already set)
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New();
us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode( m_SelectedNode );
}
m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
}
}
void QmitkControlVisualizationPropertiesView::SetInteractor()
{
typedef std::vector<mitk::DataNode*> Container;
Container _NodeSet = this->GetDataManagerSelection();
mitk::DataNode* node = 0;
mitk::FiberBundleX* bundle = 0;
mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
// finally add all nodes to the model
for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
; it++)
{
node = const_cast<mitk::DataNode*>(*it);
bundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
if(bundle)
{
bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
if(bundleInteractor.IsNotNull())
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
if(!m_Controls->m_Crosshair->isChecked())
{
m_Controls->m_Crosshair->setChecked(false);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
m_CurrentPickingNode = 0;
}
else
{
m_Controls->m_Crosshair->setChecked(true);
bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
m_CurrentPickingNode = node;
}
}
}
}
void QmitkControlVisualizationPropertiesView::PFWidth(int w)
{
double width = w/10.0;
m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QString label = "Width %1";
label = label.arg(width);
m_Controls->label_pfwidth->setText(label);
}
void QmitkControlVisualizationPropertiesView::PFColor()
{
QColor color = QColorDialog::getColor();
if (!color.isValid())
return;
m_Controls->m_PFColor->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_PFColor->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::GenerateTdi()
{
if(m_SelectedNode)
{
mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
if(!bundle)
return;
typedef float OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
// run generator
itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
generator->SetFiberBundle(bundle);
generator->SetOutputAbsoluteValues(true);
generator->SetUpsamplingFactor(1);
generator->Update();
// get result
OutImageType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
QString name(m_SelectedNode->GetName().c_str());
name += "_TDI";
node->SetName(name.toStdString());
node->SetVisibility(true);
GetDataStorage()->Add(node);
}
}
void QmitkControlVisualizationPropertiesView::LineWidthChanged()
{
if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
{
int newWidth = m_Controls->m_LineWidth->value();
int currentWidth = 0;
m_SelectedNode->GetIntProperty("LineWidth", currentWidth);
if (currentWidth==newWidth)
return;
m_SelectedNode->SetIntProperty("LineWidth", newWidth);
dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate3D();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::Welcome()
{
berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
GetSite()->GetWorkbenchWindow(), false);
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
index 6ccec586f7..77dee17b43 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
@@ -1,508 +1,525 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkDenoisingView.h"
#include <mitkImageCast.h>
#include <mitkProgressBar.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
QmitkDenoisingWorker::QmitkDenoisingWorker(QmitkDenoisingView *view)
: m_View(view)
{
}
void QmitkDenoisingWorker::run()
{
if (m_View->m_ImageNode.IsNotNull())
{
switch (m_View->m_SelectedFilter)
{
case QmitkDenoisingView::NOFILTERSELECTED:
case QmitkDenoisingView::GAUSS:
{
break;
}
case QmitkDenoisingView::NLM:
{
try
{
m_View->m_CompletedCalculation = true;
m_View->m_NonLocalMeansFilter->Update();
}
catch (itk::ExceptionObject& e)
{
m_View->m_CompletedCalculation = false;
MITK_ERROR << e.what();
}
break;
}
}
m_View->m_DenoisingThread.quit();
}
}
const std::string QmitkDenoisingView::VIEW_ID = "org.mitk.views.denoisingview";
QmitkDenoisingView::QmitkDenoisingView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_ImageNode(NULL)
, m_BrainMaskNode(NULL)
, m_DenoisingWorker(this)
, m_ThreadIsRunning(false)
, m_NonLocalMeansFilter(NULL)
, m_InputImage(NULL)
, m_LastProgressCount(0)
, m_MaxProgressCount(0)
, m_SelectedFilter(NOFILTERSELECTED)
{
m_DenoisingWorker.moveToThread(&m_DenoisingThread);
connect(&m_DenoisingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
connect(&m_DenoisingThread, SIGNAL(started()), &m_DenoisingWorker, SLOT(run()));
connect(&m_DenoisingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
connect(&m_DenoisingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
m_DenoisingTimer = new QTimer(this);
}
QmitkDenoisingView::~QmitkDenoisingView()
{
delete m_DenoisingTimer;
}
void QmitkDenoisingView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkDenoisingViewControls;
m_Controls->setupUi( parent );
CreateConnections();
ResetParameterPanel();
}
}
void QmitkDenoisingView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_ApplyButton), SIGNAL(clicked()), this, SLOT(StartDenoising()));
connect( (QObject*)(m_Controls->m_SelectFilterComboBox), SIGNAL(activated(int)), this, SLOT(SelectFilter(int)));
connect( m_DenoisingTimer, SIGNAL(timeout()), this, SLOT(UpdateProgress()));
}
}
void QmitkDenoisingView::Activated()
{
QmitkFunctionality::Activated();
m_Controls->m_SelectFilterComboBox->clear();
m_Controls->m_SelectFilterComboBox->insertItem(NOFILTERSELECTED, "Please select a filter");
m_Controls->m_SelectFilterComboBox->insertItem(NLM, "Non-local means filter");
m_Controls->m_SelectFilterComboBox->insertItem(GAUSS, "Discrete gaussian filter");
}
void QmitkDenoisingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
if (m_ThreadIsRunning)
return;
if (m_SelectedFilter != NOFILTERSELECTED)
{
m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
}
else
{
m_Controls->m_InputImageLabel->setText("mandatory");
}
m_Controls->m_InputBrainMaskLabel->setText("optional");
m_Controls->m_ApplyButton->setEnabled(false);
m_ImageNode = NULL;
m_BrainMaskNode = NULL;
// iterate selection
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
- if( node.IsNotNull() && dynamic_cast<DiffusionImageType*>(node->GetData()))
+ bool isDiffusionImage(false);
+ if(node.IsNotNull())
+ {
+ isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
+ }
+
+ if( node.IsNotNull() && isDiffusionImage)
{
m_Controls->m_InputImageLabel->setText(node->GetName().c_str());
m_ImageNode = node;
}
bool isBinary = false;
node->GetBoolProperty("binary", isBinary);
// look for a brainmask in selection
if( node.IsNotNull() && static_cast<mitk::Image*>(node->GetData()) && isBinary)
{
m_Controls->m_InputBrainMaskLabel->setText(node->GetName().c_str());
m_BrainMaskNode = node;
}
}
// Preparation of GUI to start denoising if a filter is selected
if (m_ImageNode.IsNotNull() && m_SelectedFilter != NOFILTERSELECTED)
{
m_Controls->m_ApplyButton->setEnabled(true);
}
}
void QmitkDenoisingView::StartDenoising()
{
if (!m_ThreadIsRunning)
{
if (m_ImageNode.IsNotNull())
{
m_LastProgressCount = 0;
switch (m_SelectedFilter)
{
case NOFILTERSELECTED:
{
break;
}
case NLM:
{
// initialize NLM
- m_InputImage = dynamic_cast<DiffusionImageType*> (m_ImageNode->GetData());
+ m_InputImage = dynamic_cast<mitk::Image*> (m_ImageNode->GetData());
m_NonLocalMeansFilter = NonLocalMeansDenoisingFilterType::New();
if (m_BrainMaskNode.IsNotNull())
{
// use brainmask if set
m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
itk::Image<DiffusionPixelType, 3>::Pointer itkMask;
mitk::CastToItkImage(m_ImageMask, itkMask);
m_NonLocalMeansFilter->SetInputMask(itkMask);
itk::ImageRegionIterator< itk::Image<DiffusionPixelType, 3> > mit(itkMask, itkMask->GetLargestPossibleRegion());
mit.GoToBegin();
itk::Image<DiffusionPixelType, 3>::IndexType minIndex;
itk::Image<DiffusionPixelType, 3>::IndexType maxIndex;
minIndex.Fill(10000);
maxIndex.Fill(0);
while (!mit.IsAtEnd())
{
if (mit.Get())
{
// calculation of the start & end index of the smallest masked region
minIndex[0] = minIndex[0] < mit.GetIndex()[0] ? minIndex[0] : mit.GetIndex()[0];
minIndex[1] = minIndex[1] < mit.GetIndex()[1] ? minIndex[1] : mit.GetIndex()[1];
minIndex[2] = minIndex[2] < mit.GetIndex()[2] ? minIndex[2] : mit.GetIndex()[2];
maxIndex[0] = maxIndex[0] > mit.GetIndex()[0] ? maxIndex[0] : mit.GetIndex()[0];
maxIndex[1] = maxIndex[1] > mit.GetIndex()[1] ? maxIndex[1] : mit.GetIndex()[1];
maxIndex[2] = maxIndex[2] > mit.GetIndex()[2] ? maxIndex[2] : mit.GetIndex()[2];
}
++mit;
}
itk::Image<DiffusionPixelType, 3>::SizeType size;
size[0] = maxIndex[0] - minIndex[0] + 1;
size[1] = maxIndex[1] - minIndex[1] + 1;
size[2] = maxIndex[2] - minIndex[2] + 1;
m_MaxProgressCount = size[0] * size[1] * size[2];
}
else
{
// initialize the progressbar
m_MaxProgressCount = m_InputImage->GetDimension(0) * m_InputImage->GetDimension(1) * m_InputImage->GetDimension(2);
}
mitk::ProgressBar::GetInstance()->AddStepsToDo(m_MaxProgressCount);
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(m_InputImage, itkVectorImagePointer);
- m_NonLocalMeansFilter->SetInputImage(m_InputImage->GetVectorImage());
+ m_NonLocalMeansFilter->SetInputImage( itkVectorImagePointer );
m_NonLocalMeansFilter->SetUseRicianAdaption(m_Controls->m_RicianCheckbox->isChecked());
m_NonLocalMeansFilter->SetUseJointInformation(m_Controls->m_JointInformationCheckbox->isChecked());
m_NonLocalMeansFilter->SetSearchRadius(m_Controls->m_SpinBoxParameter1->value());
m_NonLocalMeansFilter->SetComparisonRadius(m_Controls->m_SpinBoxParameter2->value());
m_NonLocalMeansFilter->SetVariance(m_Controls->m_DoubleSpinBoxParameter3->value());
// start denoising in detached thread
m_DenoisingThread.start(QThread::HighestPriority);
break;
}
case GAUSS:
{
// initialize GAUSS and run
- m_InputImage = dynamic_cast<DiffusionImageType*> (m_ImageNode->GetData());
+ m_InputImage = dynamic_cast<mitk::Image*> (m_ImageNode->GetData());
+
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(m_InputImage, itkVectorImagePointer);
ExtractFilterType::Pointer extractor = ExtractFilterType::New();
- extractor->SetInput(m_InputImage->GetVectorImage());
+ extractor->SetInput( itkVectorImagePointer );
ComposeFilterType::Pointer composer = ComposeFilterType::New();
- for (unsigned int i = 0; i < m_InputImage->GetVectorImage()->GetVectorLength(); ++i)
+ for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i)
{
extractor->SetIndex(i);
extractor->Update();
m_GaussianFilter = GaussianFilterType::New();
m_GaussianFilter->SetVariance(m_Controls->m_SpinBoxParameter1->value());
if (m_BrainMaskNode.IsNotNull())
{
m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
itk::Image<DiffusionPixelType, 3>::Pointer itkMask = itk::Image<DiffusionPixelType, 3>::New();
mitk::CastToItkImage(m_ImageMask, itkMask);
itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::Pointer maskImageFilter = itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::New();
maskImageFilter->SetInput(extractor->GetOutput());
maskImageFilter->SetMaskImage(itkMask);
maskImageFilter->Update();
m_GaussianFilter->SetInput(maskImageFilter->GetOutput());
}
else
{
m_GaussianFilter->SetInput(extractor->GetOutput());
}
m_GaussianFilter->Update();
composer->SetInput(i, m_GaussianFilter->GetOutput());
}
composer->Update();
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage(composer->GetOutput());
- image->SetReferenceBValue(m_InputImage->GetReferenceBValue());
- image->SetDirections(m_InputImage->GetDirections());
- image->InitializeFromVectorImage();
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory(composer->GetOutput());
+
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
QString name = m_ImageNode->GetName().c_str();
imageNode->SetName((name+"_gauss_"+QString::number(m_Controls->m_SpinBoxParameter1->value())).toStdString().c_str());
GetDefaultDataStorage()->Add(imageNode);
break;
}
}
}
}
else
{
m_NonLocalMeansFilter->AbortGenerateDataOn();
m_CompletedCalculation = false;
}
}
void QmitkDenoisingView::ResetParameterPanel()
{
m_Controls->m_DwiLabel->setEnabled(false);
m_Controls->m_InputImageLabel->setEnabled(false);
m_Controls->m_BrainMaskLabel->setEnabled(false);
m_Controls->m_InputBrainMaskLabel->setEnabled(false);
m_Controls->m_ParameterBox->hide();
m_Controls->m_LabelParameter_1->hide();
m_Controls->m_LabelParameter_2->hide();
m_Controls->m_LabelParameter_3->hide();
m_Controls->m_SpinBoxParameter1->hide();
m_Controls->m_SpinBoxParameter2->hide();
m_Controls->m_DoubleSpinBoxParameter3->hide();
m_Controls->m_RicianLabel->hide();
m_Controls->m_RicianCheckbox->hide();
m_Controls->m_JointInformationLabel->hide();
m_Controls->m_JointInformationCheckbox->hide();
m_Controls->m_ApplyButton->setEnabled(false);
}
void QmitkDenoisingView::SelectFilter(int filter)
{
if (m_ThreadIsRunning)
return;
//Prepare GUI
this->ResetParameterPanel();
switch (filter)
{
case 0:
{
m_SelectedFilter = NOFILTERSELECTED;
break;
}
case 1:
{
m_SelectedFilter = NLM;
m_Controls->m_DwiLabel->setEnabled(true);
m_Controls->m_InputImageLabel->setEnabled(true);
m_Controls->m_BrainMaskLabel->setEnabled(true);
m_Controls->m_InputBrainMaskLabel->setEnabled(true);
m_Controls->m_ParameterBox->show();
m_Controls->m_LabelParameter_1->show();
m_Controls->m_LabelParameter_1->setText("Search Radius:");
m_Controls->m_LabelParameter_2->show();
m_Controls->m_LabelParameter_2->setText("Comparision Radius:");
m_Controls->m_LabelParameter_3->show();
m_Controls->m_LabelParameter_3->setText("Noise variance:");
m_Controls->m_SpinBoxParameter1->show();
m_Controls->m_SpinBoxParameter1->setValue(4);
m_Controls->m_SpinBoxParameter2->show();
m_Controls->m_SpinBoxParameter2->setValue(1);
m_Controls->m_DoubleSpinBoxParameter3->show();
m_Controls->m_DoubleSpinBoxParameter3->setValue(1.0);
m_Controls->m_RicianLabel->show();
m_Controls->m_RicianCheckbox->show();
m_Controls->m_RicianCheckbox->setChecked(true);
m_Controls->m_JointInformationLabel->show();
m_Controls->m_JointInformationCheckbox->show();
m_Controls->m_JointInformationCheckbox->setChecked(false);
break;
}
case 2:
{
m_SelectedFilter = GAUSS;
m_Controls->m_DwiLabel->setEnabled(true);
m_Controls->m_InputImageLabel->setEnabled(true);
m_Controls->m_BrainMaskLabel->setEnabled(true);
m_Controls->m_InputBrainMaskLabel->setEnabled(true);
m_Controls->m_ParameterBox->show();
m_Controls->m_LabelParameter_1->show();
m_Controls->m_LabelParameter_1->setText("Variance:");
m_Controls->m_SpinBoxParameter1->show();
m_Controls->m_SpinBoxParameter1->setValue(2);
break;
}
}
if (m_ImageNode.IsNull())
{
if (m_SelectedFilter != NOFILTERSELECTED)
m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
else
m_Controls->m_InputImageLabel->setText("mandatory");
}
if (m_ImageNode.IsNotNull())
{
m_Controls->m_ApplyButton->setEnabled(false);
switch(filter)
{
case NOFILTERSELECTED:
{
break;
}
case NLM:
case GAUSS:
{
m_Controls->m_ApplyButton->setEnabled(true);
break;
}
}
}
}
void QmitkDenoisingView::BeforeThread()
{
m_ThreadIsRunning = true;
// initialize timer to update the progressbar at each timestep
m_DenoisingTimer->start(500);
m_Controls->m_ParameterBox->setEnabled(false);
m_Controls->m_ApplyButton->setText("Abort");
}
void QmitkDenoisingView::AfterThread()
{
m_ThreadIsRunning = false;
// stop timer to stop updates of progressbar
m_DenoisingTimer->stop();
// make sure progressbar is finished
mitk::ProgressBar::GetInstance()->Progress(m_MaxProgressCount);
if (m_CompletedCalculation)
{
switch (m_SelectedFilter)
{
case NOFILTERSELECTED:
case GAUSS:
{
break;
}
case NLM:
- {
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage(m_NonLocalMeansFilter->GetOutput());
- image->SetReferenceBValue(m_InputImage->GetReferenceBValue());
- image->SetDirections(m_InputImage->GetDirections());
- image->InitializeFromVectorImage();
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
+ {
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( m_NonLocalMeansFilter->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
QString name = m_ImageNode->GetName().c_str();
//TODO: Rician adaption & joint information in name
if (m_Controls->m_RicianCheckbox->isChecked() && !m_Controls->m_JointInformationCheckbox->isChecked())
{
imageNode->SetName((name+"_NLMr_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
}
else if(!m_Controls->m_RicianCheckbox->isChecked() && m_Controls->m_JointInformationCheckbox->isChecked())
{
imageNode->SetName((name+"_NLMv_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
}
else if(m_Controls->m_RicianCheckbox->isChecked() && m_Controls->m_JointInformationCheckbox->isChecked())
{
imageNode->SetName((name+"_NLMvr_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
}
else
{
imageNode->SetName((name+"_NLM_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
}
GetDefaultDataStorage()->Add(imageNode);
break;
}
}
}
m_Controls->m_ParameterBox->setEnabled(true);
m_Controls->m_ApplyButton->setText("Apply");
}
void QmitkDenoisingView::UpdateProgress()
{
switch (m_SelectedFilter)
{
case NOFILTERSELECTED:
case GAUSS:
{
break;
}
case NLM:
{
unsigned int currentProgressCount = m_NonLocalMeansFilter->GetCurrentVoxelCount();
mitk::ProgressBar::GetInstance()->Progress(currentProgressCount-m_LastProgressCount);
m_LastProgressCount = currentProgressCount;
break;
}
}
-}
\ No newline at end of file
+}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
index ba63e1a8b3..172b39bd38 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
@@ -1,133 +1,134 @@
/*===================================================================
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 _QMITKQmitkDenoisingView_H_INCLUDED
#define _QMITKQmitkDenoisingView_H_INCLUDED
#include <berryISelectionListener.h>
#include <QmitkFunctionality.h>
#include "ui_QmitkDenoisingViewControls.h"
#include <itkVectorImage.h>
#include <itkImage.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
#include <itkNonLocalMeansDenoisingFilter.h>
#include <itkMaskImageFilter.h>
#include <itkDiscreteGaussianImageFilter.h>
#include <itkVectorImageToImageFilter.h>
#include <itkComposeImageFilter.h>
#include <QThread>
#include <QTimer>
/**
* \class QmitkDenoisingView
* \brief View displaying details to denoise diffusionweighted images.
*
* \sa QmitkFunctionality
* \ingroup Functionalities
*/
class QmitkDenoisingView;
class QmitkDenoisingWorker : public QObject
{
Q_OBJECT
public:
QmitkDenoisingWorker(QmitkDenoisingView* view);
public slots:
void run();
private:
QmitkDenoisingView* m_View;
};
class QmitkDenoisingView : public QmitkFunctionality
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkDenoisingView();
virtual ~QmitkDenoisingView();
/** Typedefs */
typedef short DiffusionPixelType;
- typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
typedef mitk::Image MaskImageType;
typedef itk::NonLocalMeansDenoisingFilter< DiffusionPixelType > NonLocalMeansDenoisingFilterType;
typedef itk::DiscreteGaussianImageFilter < itk::Image< DiffusionPixelType, 3>, itk::Image< DiffusionPixelType, 3> > GaussianFilterType;
typedef itk::VectorImageToImageFilter < DiffusionPixelType > ExtractFilterType;
typedef itk::ComposeImageFilter < itk::Image<DiffusionPixelType, 3> > ComposeFilterType;
+ typedef itk::VectorImage<DiffusionPixelType, 3>
+ ITKDiffusionImageType;
virtual void CreateQtPartControl(QWidget *parent);
/// \brief Creation of the connections of main and control widget
virtual void CreateConnections();
/// \brief Creation of the connections of the FilterComboBox
virtual void Activated();
private slots:
void StartDenoising(); //< prepares filter condition and starts thread for denoising
void SelectFilter(int filter); //< updates which filter is selected
void BeforeThread(); //< starts timer & disables all buttons while denoising
void AfterThread(); //< stops timer & creates a new datanode of the denoised image
void UpdateProgress(); //< updates the progressbar each timestep
private:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
void ResetParameterPanel();
Ui::QmitkDenoisingViewControls* m_Controls;
mitk::DataNode::Pointer m_ImageNode;
mitk::DataNode::Pointer m_BrainMaskNode;
QmitkDenoisingWorker m_DenoisingWorker;
QThread m_DenoisingThread;
bool m_ThreadIsRunning;
bool m_CompletedCalculation;
NonLocalMeansDenoisingFilterType::Pointer m_NonLocalMeansFilter;
GaussianFilterType::Pointer m_GaussianFilter;
- DiffusionImageType::Pointer m_InputImage;
+ mitk::Image::Pointer m_InputImage;
MaskImageType::Pointer m_ImageMask;
QTimer* m_DenoisingTimer;
unsigned int m_LastProgressCount;
unsigned int m_MaxProgressCount;
enum FilterType {
NOFILTERSELECTED,
NLM,
GAUSS
}m_SelectedFilter;
friend class QmitkDenoisingWorker;
};
#endif // _QmitkDenoisingView_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
index 4ae704a475..6930ce34df 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
@@ -1,558 +1,558 @@
/*===================================================================
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 "QmitkDiffusionDicomImportView.h"
// qt includes
#include <QFileDialog>
// itk includes
#include "itkTimeProbesCollectorBase.h"
#include "itkGDCMSeriesFileNames.h"
#include "itksys/SystemTools.hxx"
// mitk includes
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include "mitkMemoryUtilities.h"
#include "mitkIOUtil.h"
// diffusion module includes
#include "mitkDicomDiffusionImageHeaderReader.h"
#include "mitkDicomDiffusionImageReader.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
+#include <mitkDiffusionPropertyHelper.h>
#include "mitkDiffusionDICOMFileReader.h"
#include "mitkDICOMTagBasedSorter.h"
#include "mitkDICOMSortByTag.h"
#include "mitkSortByImagePositionPatient.h"
#include "gdcmDirectory.h"
#include "gdcmScanner.h"
#include "gdcmSorter.h"
#include "gdcmIPPSorter.h"
#include "gdcmAttribute.h"
#include "gdcmVersion.h"
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
#include <QMessageBox>
const std::string QmitkDiffusionDicomImport::VIEW_ID = "org.mitk.views.diffusiondicomimport";
QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(QObject* /*parent*/, const char* /*name*/)
: QmitkFunctionality(), m_Controls(NULL), m_MultiWidget(NULL),
m_OutputFolderName(""), m_OutputFolderNameSet(false)
{
}
QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkDiffusionDicomImport::~QmitkDiffusionDicomImport()
{}
void QmitkDiffusionDicomImport::CreateQtPartControl(QWidget *parent)
{
m_Parent = parent;
if (m_Controls == NULL)
{
m_Controls = new Ui::QmitkDiffusionDicomImportControls;
m_Controls->setupUi(parent);
this->CreateConnections();
m_Controls->m_DicomLoadRecursiveCheckbox->setChecked(false);
m_Controls->m_DicomLoadAverageDuplicatesCheckbox->setChecked(false);
m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(true);
m_Controls->m_OverrideOptionCheckbox->setVisible(false);
m_Controls->m_SubdirPrefixLineEdit->setVisible(false);
m_Controls->m_SetPrefixButton->setVisible(false);
m_Controls->m_ResetPrefixButton->setVisible(false);
AverageClicked();
}
}
void QmitkDiffusionDicomImport::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_AddFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadAddFolderNames()) );
connect( m_Controls->m_DeleteFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadDeleteFolderNames()) );
//connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(DicomLoadStartLoad()) );
connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(NewDicomLoadStartLoad()) );
connect( m_Controls->m_DicomLoadAverageDuplicatesCheckbox, SIGNAL(clicked()), this, SLOT(AverageClicked()) );
connect( m_Controls->m_OutputSetButton, SIGNAL(clicked()), this, SLOT(OutputSet()) );
connect( m_Controls->m_OutputClearButton, SIGNAL(clicked()), this, SLOT(OutputClear()) );
connect( m_Controls->m_Remove, SIGNAL(clicked()), this, SLOT(Remove()) );
connect( m_Controls->m_SetPrefixButton, SIGNAL(clicked()), this, SLOT(SetPrefixButtonPushed()));
connect( m_Controls->m_ResetPrefixButton, SIGNAL(clicked()), this, SLOT(ResetPrefixButtonPushed()));
connect( m_Controls->m_DicomLoadRecursiveCheckbox, SIGNAL(clicked()), this, SLOT(RecursiveSettingsChanged()) );
}
}
void QmitkDiffusionDicomImport::RecursiveSettingsChanged()
{
m_Controls->m_SubdirPrefixLineEdit->setVisible( m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() );
m_Controls->m_SetPrefixButton->setVisible( m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() );
m_Controls->m_SubdirPrefixLineEdit->clear();
this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(true);
}
void QmitkDiffusionDicomImport::SetPrefixButtonPushed()
{
m_Prefix = this->m_Controls->m_SubdirPrefixLineEdit->text().toStdString();
if( !this->m_Controls->m_ResetPrefixButton->isVisible() )
this->m_Controls->m_ResetPrefixButton->setVisible(true);
this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(false);
this->m_Controls->m_ResetPrefixButton->setEnabled(true);
this->m_Controls->m_SetPrefixButton->setEnabled(false);
}
void QmitkDiffusionDicomImport::ResetPrefixButtonPushed()
{
m_Controls->m_SubdirPrefixLineEdit->clear();
this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(true);
this->m_Controls->m_ResetPrefixButton->setEnabled(false);
this->m_Controls->m_SetPrefixButton->setEnabled(true);
}
void QmitkDiffusionDicomImport::Remove()
{
int i = m_Controls->listWidget->currentRow();
m_Controls->listWidget->takeItem(i);
}
void QmitkDiffusionDicomImport::OutputSet()
{
// SELECT FOLDER DIALOG
QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
w->setFileMode( QFileDialog::Directory );
// RETRIEVE SELECTION
if ( w->exec() != QDialog::Accepted )
return;
m_OutputFolderName = w->selectedFiles()[0];
m_OutputFolderNameSet = true;
m_Controls->m_OutputLabel->setText(m_OutputFolderName);
// show file override option checkbox
m_Controls->m_OverrideOptionCheckbox->setVisible(true);
}
void QmitkDiffusionDicomImport::OutputClear()
{
m_OutputFolderName = "";
m_OutputFolderNameSet = false;
m_Controls->m_OutputLabel->setText("... optional out-folder ...");
// hide file override option checkbox - no output specified
m_Controls->m_OverrideOptionCheckbox->setVisible(false);
}
void QmitkDiffusionDicomImport::AverageClicked()
{
m_Controls->m_Blur->setEnabled(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked());
}
void QmitkDiffusionDicomImport::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkDiffusionDicomImport::DicomLoadDeleteFolderNames()
{
m_Controls->listWidget->clear();
}
void QmitkDiffusionDicomImport::DicomLoadAddFolderNames()
{
// SELECT FOLDER DIALOG
QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
w->setFileMode( QFileDialog::Directory );
// RETRIEVE SELECTION
if ( w->exec() != QDialog::Accepted )
return;
m_Controls->listWidget->addItems(w->selectedFiles());
}
bool SortBySeriesUID(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
{
gdcm::Attribute<0x0020,0x000e> at1;
at1.Set( ds1 );
gdcm::Attribute<0x0020,0x000e> at2;
at2.Set( ds2 );
return at1 < at2;
}
bool SortByAcquisitionNumber(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
{
gdcm::Attribute<0x0020,0x0012> at1;
at1.Set( ds1 );
gdcm::Attribute<0x0020,0x0012> at2;
at2.Set( ds2 );
return at1 < at2;
}
bool SortBySeqName(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
{
gdcm::Attribute<0x0018, 0x0024> at1;
at1.Set( ds1 );
gdcm::Attribute<0x0018, 0x0024> at2;
at2.Set( ds2 );
std::string str1 = at1.GetValue().Trim();
std::string str2 = at2.GetValue().Trim();
return std::lexicographical_compare(str1.begin(), str1.end(),
str2.begin(), str2.end() );
}
void QmitkDiffusionDicomImport::Status(QString status)
{
mitk::StatusBar::GetInstance()->DisplayText(status.toLatin1());
MITK_INFO << status.toStdString().c_str();
}
void QmitkDiffusionDicomImport::Status(std::string status)
{
mitk::StatusBar::GetInstance()->DisplayText(status.c_str());
MITK_INFO << status.c_str();
}
void QmitkDiffusionDicomImport::Status(const char* status)
{
mitk::StatusBar::GetInstance()->DisplayText(status);
MITK_INFO << status;
}
void QmitkDiffusionDicomImport::Error(QString status)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(status.toLatin1());
MITK_ERROR << status.toStdString().c_str();
}
void QmitkDiffusionDicomImport::Error(std::string status)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(status.c_str());
MITK_ERROR << status.c_str();
}
void QmitkDiffusionDicomImport::Error(const char* status)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(status);
MITK_ERROR << status;
}
void QmitkDiffusionDicomImport::PrintMemoryUsage()
{
size_t processSize = mitk::MemoryUtilities::GetProcessMemoryUsage();
size_t totalSize = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
float percentage = ( (float) processSize / (float) totalSize ) * 100.0;
MITK_INFO << "Current memory usage: " << GetMemoryDescription( processSize, percentage );
}
std::string QmitkDiffusionDicomImport::FormatMemorySize( size_t size )
{
double val = size;
std::string descriptor("B");
if ( val >= 1000.0 )
{
val /= 1024.0;
descriptor = "KB";
}
if ( val >= 1000.0 )
{
val /= 1024.0;
descriptor = "MB";
}
if ( val >= 1000.0 )
{
val /= 1024.0;
descriptor = "GB";
}
std::ostringstream str;
str << std::fixed << std::setprecision(2) << val << " " << descriptor;
return str.str();
}
std::string QmitkDiffusionDicomImport::FormatPercentage( double val )
{
std::ostringstream str;
str << std::fixed << std::setprecision(2) << val << " " << "%";
return str.str();
}
std::string QmitkDiffusionDicomImport::GetMemoryDescription( size_t processSize, float percentage )
{
std::ostringstream str;
str << FormatMemorySize(processSize) << " (" << FormatPercentage( percentage ) <<")" ;
return str.str();
}
void QmitkDiffusionDicomImport::NewDicomLoadStartLoad()
{
itk::TimeProbesCollectorBase clock;
bool imageSuccessfullySaved = true;
bool has_prefix = true;
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
int nrFolders = m_Controls->listWidget->count();
if(!nrFolders)
{
Error(QString("No input folders were selected. ABORTING."));
return;
}
Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
PrintMemoryUsage();
QString status;
mitk::DataNode::Pointer node;
mitk::ProgressBar::GetInstance()->AddStepsToDo(2*nrFolders);
gdcm::Directory::FilenamesType complete_list;
while(m_Controls->listWidget->count())
{
// RETREIVE FOLDERNAME
QListWidgetItem * item = m_Controls->listWidget->takeItem(0);
QString folderName = item->text();
if( this->m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() )
{
std::string subdir_prefix = "";
if( has_prefix )
{
subdir_prefix = this->m_Prefix;
}
itksys::Directory rootdir;
rootdir.Load( folderName.toStdString().c_str() );
for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
{
std::string current_path = rootdir.GetFile(idx);
std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath: " << current_path;
MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
<< " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
// test for prefix
if( itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
&& itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() )
)
{
gdcm::Directory d;
d.Load( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) , false);
MITK_INFO("dicom.load.subdir.attempt") << "In directory " << itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() );
const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
const unsigned int ntotalfiles = l1.size();
Status(QString(" ... found %1 different files").arg(ntotalfiles));
for( unsigned int i=0; i< ntotalfiles; i++)
{
complete_list.push_back( l1.at(i) );
}
}
}
}
else
{
gdcm::Directory d;
d.Load( folderName.toStdString().c_str(), this->m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() ); // recursive !
const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
const unsigned int ntotalfiles = l1.size();
Status(QString(" ... found %1 different files").arg(ntotalfiles));
for( unsigned int i=0; i< ntotalfiles; i++)
{
complete_list.push_back( l1.at(i) );
}
}
}
{
mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New();
mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
// Use tags as in Qmitk
// all the things that split by tag in DicomSeriesReader
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
// TODO handle as real vectors! cluster with configurable errors!
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x000e) ); // Series Instance UID
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
//tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
// gdcmReader->AddSortingElement( tagSorter );
//mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
mitk::DICOMSortCriterion::ConstPointer sorting =
mitk::SortByImagePositionPatient::New( // Image Position (Patient)
//mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0013), // instance number
mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012), // aqcuisition number
mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0032), // aqcuisition time
mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0018, 0x1060), // trigger time
mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
).GetPointer()
).GetPointer()
).GetPointer()
).GetPointer()
// ).GetPointer()
).GetPointer();
tagSorter->SetSortCriterion( sorting );
// mosaic
gdcmReader->SetResolveMosaic( this->m_Controls->m_SplitMosaicCheckBox->isChecked() );
gdcmReader->AddSortingElement( tagSorter );
gdcmReader->SetInputFiles( complete_list );
try
{
gdcmReader->AnalyzeInputFiles();
}
catch( const itk::ExceptionObject &e)
{
MITK_ERROR << "Failed to analyze data. " << e.what();
}
catch( const std::exception &se)
{
MITK_ERROR << "Std Exception " << se.what();
}
gdcmReader->LoadImages();
for( int o = 0; o < gdcmReader->GetNumberOfOutputs(); o++ )
{
mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(o).GetMitkImage();
- mitk::DiffusionImage<short>::Pointer d_img = static_cast<mitk::DiffusionImage<short>*>( loaded_image.GetPointer() );
std::stringstream ss;
ss << "ImportedData_" << o;
node = mitk::DataNode::New();
- node->SetData( d_img );
+ node->SetData( loaded_image );
std::string outname;
- d_img->GetPropertyList()->GetStringProperty("diffusion.dicom.importname", outname );
+ loaded_image->GetPropertyList()->GetStringProperty("diffusion.dicom.importname", outname );
node->SetName( outname.c_str() );
GetDefaultDataStorage()->Add(node);
//SetDwiNodeProperties(node, ss.str() );
//Status(QString("Image %1 added to datastorage").arg(descr));
}
}
Status("Timing information");
clock.Report();
if(!m_OutputFolderNameSet && node.IsNotNull())
{
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
try
{
MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
catch (itk::ExceptionObject &ex)
{
Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
return ;
}
if (!imageSuccessfullySaved)
QMessageBox::warning(NULL,"WARNING","One or more files could not be saved! The according files where moved to the datastorage.");
Status(QString("Finished import with memory:"));
PrintMemoryUsage();
}
void QmitkDiffusionDicomImport::SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name)
{
node->SetProperty( "IsDWIRawVolume", mitk::BoolProperty::New( true ) );
// set foldername as string property
mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
node->SetProperty( "name", nameProp );
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
index 7b71f5bbe4..a99cb6032d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
@@ -1,482 +1,488 @@
/*===================================================================
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.
===================================================================*/
//misc
#define _USE_MATH_DEFINES
#include <math.h>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkDiffusionRegistrationView.h"
#include <QmitkStdMultiWidget.h>
// MITK
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <mitkImageAccessByItk.h>
#include <mitkProgressBar.h>
#include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QDir>
#include <QDirIterator>
#include <mitkDWIHeadMotionCorrectionFilter.h>
#define _USE_MATH_DEFINES
#include <math.h>
QmitkRegistrationWorker::QmitkRegistrationWorker(QmitkDiffusionRegistrationView* view)
: m_View(view)
{
}
void QmitkRegistrationWorker::run()
{
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef DiffusionImageType::BValueMap BValueMap;
+ typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMap;
unsigned int totalImagesCount;
if( !m_View->m_IsBatch )
{
totalImagesCount = m_View->m_SelectedDiffusionNodes.size();
}
else
{
totalImagesCount = m_View->m_BatchList.size();
}
m_View->m_TotalFiles = totalImagesCount;
QString inputPath = m_View->m_Controls->m_InputFolderTextbox->text();
QString outputPath = m_View->m_Controls->m_OutputFolderTextbox->text();
for(unsigned int i=0; i< totalImagesCount; i++)
{
if(m_View->m_IsAborted){
m_View->m_RegistrationThread.quit();
return;
}
m_View->m_CurrentFile = i+1;
m_View->m_GlobalRegisterer = QmitkDiffusionRegistrationView::DWIHeadMotionCorrectionFilterType::New();
//mitk::DataNode::Pointer node = m_View->m_SelectedDiffusionNodes.at(i);
- DiffusionImageType::Pointer inImage;
+ mitk::Image::Pointer inImage;
mitk::DataNode::Pointer node;
if( !m_View->m_IsBatch )
{
node = m_View->m_SelectedDiffusionNodes.at(i);
- inImage = dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData());
+ inImage = dynamic_cast<mitk::Image*>(node->GetData());
}
else
{
- mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( m_View->m_BatchList.at(i).toStdString() );
- inImage = static_cast<DiffusionImageType*>( inputImage.GetPointer() );
+ mitk::Image::Pointer inImage = mitk::IOUtil::LoadImage( m_View->m_BatchList.at(i).toStdString() );
+ mitk::GradientDirectionsProperty::Pointer gradDir = static_cast<mitk::GradientDirectionsProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer());
}
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( inImage ) );
- if(inImage.IsNull())
+ if(!isDiffusionImage)
{
MITK_ERROR << "Error occured: can't get input image. \nAborting";
return;
}
m_View->m_GlobalRegisterer->SetInput(inImage);
try
{
m_View->m_GlobalRegisterer->Update();
}
catch( mitk::Exception e )
{
MITK_ERROR << "Internal error occured: " << e.what() << "\nAborting";
}
if( m_View->m_GlobalRegisterer->GetIsInValidState() )
{
-
if(! m_View->m_IsBatch)
{
- DiffusionImageType::Pointer image = m_View->m_GlobalRegisterer->GetOutput();
+ mitk::Image::Pointer image = m_View->m_GlobalRegisterer->GetOutput();
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
QString name = node->GetName().c_str();
imageNode->SetName((name+"_MC").toStdString().c_str());
m_View->GetDataStorage()->Add(imageNode);
}
else
{
QString name = m_View->m_BatchList.at(i);
name = name.replace(".dwi", "_MC.dwi", Qt::CaseInsensitive);
name = name.replace(inputPath, outputPath, Qt::CaseInsensitive);
try
{
mitk::IOUtil::Save(m_View->m_GlobalRegisterer->GetOutput(), name.toStdString().c_str());
}
catch( const itk::ExceptionObject& e)
{
MITK_ERROR << "Catched exception: " << e.what();
mitkThrow() << "Failed with exception from subprocess!";
}
}
}
}
m_View->m_RegistrationThread.quit();
}
const std::string QmitkDiffusionRegistrationView::VIEW_ID = "org.mitk.views.diffusionregistrationview";
QmitkDiffusionRegistrationView::QmitkDiffusionRegistrationView()
: QmitkAbstractView()
, m_Controls( 0 )
, m_DiffusionImage( NULL )
, m_ThreadIsRunning(false)
, m_Steps(100)
, m_LastStep(0)
, m_GlobalRegisterer(NULL)
, m_RegistrationWorker(this)
{
m_RegistrationWorker.moveToThread(&m_RegistrationThread);
connect(&m_RegistrationThread, SIGNAL(started()), this, SLOT(BeforeThread()));
connect(&m_RegistrationThread, SIGNAL(started()), &m_RegistrationWorker, SLOT(run()));
connect(&m_RegistrationThread, SIGNAL(finished()), this, SLOT(AfterThread()));
connect(&m_RegistrationThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
m_RegistrationTimer = new QTimer(this);
}
// Destructor
QmitkDiffusionRegistrationView::~QmitkDiffusionRegistrationView()
{
delete m_RegistrationTimer;
}
// update Registration status and generate fiber bundle
void QmitkDiffusionRegistrationView::TimerUpdate()
{
int currentStep = m_GlobalRegisterer->GetCurrentStep();
mitk::ProgressBar::GetInstance()->Progress(currentStep-m_LastStep);
UpdateRegistrationStatus();
m_LastStep = currentStep;
}
// update gui elements after registration is finished
void QmitkDiffusionRegistrationView::AfterThread()
{
m_ThreadIsRunning = false;
m_RegistrationTimer->stop();
mitk::ProgressBar::GetInstance()->Progress(m_GlobalRegisterer->GetSteps()-m_LastStep+1);
UpdateGUI();
if( !m_GlobalRegisterer->GetIsInValidState() )
{
QMessageBox::critical( NULL, "Registration", "An internal error occured, or user canceled the Registration.\n Please check the log for details." );
return;
}
UpdateRegistrationStatus();
m_GlobalRegisterer = 0;
}
// start Registration timer and update gui elements before Registration is started
void QmitkDiffusionRegistrationView::BeforeThread()
{
m_ThreadIsRunning = true;
m_RegistrationTime = QTime::currentTime();
m_ElapsedTime = 0;
m_RegistrationTimer->start(1000);
m_LastStep = 0;
UpdateGUI();
}
void QmitkDiffusionRegistrationView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkDiffusionRegistrationViewControls;
m_Controls->setupUi( parent );
AdvancedSettings();
connect( m_RegistrationTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
connect( m_Controls->m_RegistrationStopButton, SIGNAL(clicked()), this, SLOT(StopRegistration()) );
connect( m_Controls->m_RegistrationStartButton, SIGNAL(clicked()), this, SLOT(StartRegistration()) );
connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
connect( m_Controls->m_SelectInputButton, SIGNAL(clicked()), this, SLOT(AddInputFolderName()) );
connect( m_Controls->m_SelectOutputButton, SIGNAL(clicked()), this, SLOT(AddOutputFolderName()) );
connect( m_Controls->m_StartBatchButton, SIGNAL(clicked()), this, SLOT(StartBatch()) );
this->m_Parent = parent;
}
}
// show/hide advanced settings frame
void QmitkDiffusionRegistrationView::AdvancedSettings()
{
m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
}
void QmitkDiffusionRegistrationView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
{
if (m_ThreadIsRunning)
return;
bool foundDwiVolume = false;
QString tempSelectedNames = "";
m_DiffusionImage = NULL;
m_SelectedDiffusionNodes.clear();
// iterate selection
for( int i=0; i<nodes.size(); i++)
{
mitk::DataNode::Pointer node = nodes.at(i);
- if( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+ bool isDiffusionImage(false);
+ if( node.IsNotNull() )
+ {
+ isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
+ }
+
+ if( isDiffusionImage )
{
foundDwiVolume = true;
m_SelectedDiffusionNodes.push_back(node);
if(m_SelectedDiffusionNodes.size() > 0){tempSelectedNames += "\n";}
tempSelectedNames += (node->GetName().c_str());
}
}
m_Controls->m_RegistrationStartButton->setEnabled(foundDwiVolume);
if (foundDwiVolume)
{
m_Controls->m_DiffusionImageLabel->setText(tempSelectedNames);
m_Controls->m_InputData->setTitle("Input Data");
}
else
{
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_InputData->setTitle("Please Select Input Data");
}
UpdateGUI();
}
// update gui elements displaying Registrations status
void QmitkDiffusionRegistrationView::UpdateRegistrationStatus()
{
if (m_GlobalRegisterer.IsNull())
return;
m_ElapsedTime += m_RegistrationTime.elapsed()/1000;
m_RegistrationTime.restart();
unsigned long hours = m_ElapsedTime/3600;
unsigned long minutes = (m_ElapsedTime%3600)/60;
unsigned long seconds = m_ElapsedTime%60;
m_Controls->m_RegistrationTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
m_Controls->m_CurrentStepLabel->setText( QString::number((int)(100*(float)(m_GlobalRegisterer->GetCurrentStep()-1)/m_GlobalRegisterer->GetSteps()))+"%" );
m_Controls->m_CurrentFileLabel->setText( QString::number(m_CurrentFile)+" / "+QString::number(m_TotalFiles) );
}
void QmitkDiffusionRegistrationView::UpdateGUI()
{
if (!m_ThreadIsRunning && (m_SelectedDiffusionNodes.size() > 0) )
{
m_Controls->m_RegistrationStopButton->setEnabled(false);
m_Controls->m_RegistrationStartButton->setEnabled(true);
m_Controls->m_StartBatchButton->setEnabled(true);
m_Controls->m_AdvancedFrame->setEnabled(true);
m_Controls->m_RegistrationStopButton->setText("Stop");
m_Controls->m_RegistrationStartButton->setToolTip("Start Registration");
m_Controls->m_RegistrationStopButton->setToolTip("");
}
else if (!m_ThreadIsRunning)
{
m_Controls->m_RegistrationStopButton->setEnabled(false);
m_Controls->m_RegistrationStartButton->setEnabled(false);
m_Controls->m_StartBatchButton->setEnabled(true);
m_Controls->m_AdvancedFrame->setEnabled(true);
m_Controls->m_RegistrationStopButton->setText("Stop");
m_Controls->m_RegistrationStartButton->setToolTip("No Diffusion image selected.");
m_Controls->m_RegistrationStopButton->setToolTip("");
}
else
{
m_Controls->m_RegistrationStopButton->setEnabled(true);
m_Controls->m_RegistrationStartButton->setEnabled(false);
m_Controls->m_StartBatchButton->setEnabled(false);
m_Controls->m_AdvancedFrame->setEnabled(false);
m_Controls->m_RegistrationStartButton->setToolTip("Registration in progress.");
m_Controls->m_RegistrationStopButton->setToolTip("Cancel Registration");
}
}
void QmitkDiffusionRegistrationView::SetFocus()
{
m_Controls->m_RegistrationStartButton->setFocus();
}
void QmitkDiffusionRegistrationView::StartRegistration()
{
if(m_ThreadIsRunning)
{
MITK_WARN("QmitkDiffusionRegistrationView")<<"Thread already running!";
return;
}
m_GlobalRegisterer = NULL;
if (m_SelectedDiffusionNodes.size()<1)
{
QMessageBox::information( NULL, "Warning", "Please load and select a diffusion image before starting image processing.");
return;
}
m_IsBatch = false;
m_IsAborted = false;
m_Controls->m_RegistrationStartButton->setEnabled(false);
m_Controls->m_StartBatchButton->setEnabled(false);
// start worker thread
m_RegistrationThread.start(QThread::NormalPriority);
return;
}
void QmitkDiffusionRegistrationView::StopRegistration()
{
if (m_GlobalRegisterer.IsNull())
return;
m_IsAborted = true;
m_GlobalRegisterer->SetAbortRegistration(true);
m_Controls->m_RegistrationStopButton->setEnabled(false);
m_Controls->m_RegistrationStopButton->setText("Stopping ...");
return;
}
void QmitkDiffusionRegistrationView::AddInputFolderName()
{
// SELECT FOLDER DIALOG
QFileDialog* w = new QFileDialog( m_Parent, QString("Select the input folder with DWI files within") );
w->setFileMode( QFileDialog::Directory );
// RETRIEVE SELECTION
if ( w->exec() != QDialog::Accepted )
return;
m_Controls->m_InputFolderTextbox->setText(w->selectedFiles()[0]);
}
void QmitkDiffusionRegistrationView::AddOutputFolderName()
{
// SELECT FOLDER DIALOG
QFileDialog* w = new QFileDialog( m_Parent, QString("Select the output folder") );
w->setFileMode( QFileDialog::Directory );
// RETRIEVE SELECTION
if ( w->exec() != QDialog::Accepted )
return;
m_Controls->m_OutputFolderTextbox->setText(w->selectedFiles()[0]);
}
void QmitkDiffusionRegistrationView::StartBatch()
{
QString inputPath = m_Controls->m_InputFolderTextbox->text();
QString outputPath = m_Controls->m_OutputFolderTextbox->text();
if(inputPath == outputPath){
QMessageBox::information( NULL, "Error", "Input and Output folders can't be the same");
return;
}
QStringList list, filters;
filters<<"*.dwi";
QDirIterator dirIterator(inputPath,
filters,
QDir::Files|QDir::NoSymLinks);
while (dirIterator.hasNext())
{
dirIterator.next();
list.append(dirIterator.fileInfo().absoluteFilePath());
std::cout << dirIterator.fileInfo().absoluteFilePath().toStdString() << endl;
m_BatchList = list;
m_IsBatch = true;
m_IsAborted = false;
if(m_ThreadIsRunning)
{
MITK_WARN("QmitkDiffusionRegistrationView")<<"Thread already running!";
return;
}
m_GlobalRegisterer = NULL;
if (m_BatchList.size()<1)
{
QMessageBox::information( NULL, "Error", "No diffusion images were found in the selected input folder.");
return;
}
m_Controls->m_RegistrationStartButton->setEnabled(false);
m_Controls->m_StartBatchButton->setEnabled(false);
// start worker thread
m_RegistrationThread.start(QThread::NormalPriority);
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
index e21ca6bb75..1efcb21dff 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
@@ -1,135 +1,135 @@
/*===================================================================
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 <berryISelectionListener.h>
#include <berryIStructuredSelection.h>
#include <QmitkAbstractView.h>
#include "ui_QmitkDiffusionRegistrationViewControls.h"
-#include "mitkDiffusionImage.h"
+#include <mitkImage.h>
#include <mitkDWIHeadMotionCorrectionFilter.h>
#include <QThread>
#include <QTime>
typedef short DiffusionPixelType;
/*!
\brief View for diffusion image registration / head motion correction
\sa QmitkFunctionality
\ingroup Functionalities
*/
// Forward Qt class declarations
using namespace std;
class QmitkDiffusionRegistrationView;
class QmitkRegistrationWorker : public QObject
{
Q_OBJECT
public:
QmitkRegistrationWorker(QmitkDiffusionRegistrationView* view);
public slots:
void run();
private:
QmitkDiffusionRegistrationView* m_View;
};
class QmitkDiffusionRegistrationView : public QmitkAbstractView
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const string VIEW_ID;
QmitkDiffusionRegistrationView();
virtual ~QmitkDiffusionRegistrationView();
virtual void CreateQtPartControl(QWidget *parent);
void SetFocus();
- typedef mitk::DWIHeadMotionCorrectionFilter< DiffusionPixelType > DWIHeadMotionCorrectionFilterType;
+ typedef mitk::DWIHeadMotionCorrectionFilter DWIHeadMotionCorrectionFilterType;
protected slots:
void StartRegistration();
void StopRegistration();
void AfterThread(); ///< update gui etc. after registrations has finished
void BeforeThread(); ///< start timer etc.
void TimerUpdate();
void AddInputFolderName();
void AddOutputFolderName();
void StartBatch();
void AdvancedSettings();
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&);
Ui::QmitkDiffusionRegistrationViewControls* m_Controls;
- mitk::DiffusionImage<DiffusionPixelType>::Pointer m_DiffusionImage;
+ mitk::Image::Pointer m_DiffusionImage;
std::vector< mitk::DataNode::Pointer > m_SelectedDiffusionNodes;
private:
void UpdateRegistrationStatus(); ///< update textual status display of the Registration process
void UpdateGUI(); ///< update button activity etc. dpending on current datamanager selection
/** flags etc. */
bool m_IsBatch, m_IsAborted;
QStringList m_BatchList;
bool m_ThreadIsRunning;
QTimer* m_RegistrationTimer;
QTime m_RegistrationTime;
unsigned long m_ElapsedTime;
unsigned long m_Steps;
int m_LastStep;
unsigned int m_CurrentFile;
unsigned int m_TotalFiles;
// the Qt parent of our GUI (NOT of this object)
QWidget* m_Parent;
/** global Registerer and friends */
itk::SmartPointer<DWIHeadMotionCorrectionFilterType> m_GlobalRegisterer;
QmitkRegistrationWorker m_RegistrationWorker;
QThread m_RegistrationThread;
friend class QmitkRegistrationWorker;
};
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
index f644ca9fbc..ff342de343 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
@@ -1,496 +1,499 @@
/*===================================================================
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.
===================================================================*/
// Qmitk
#include "QmitkDwiSoftwarePhantomView.h"
// MITK
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
#include <mitkImageToItk.h>
#include <mitkImageCast.h>
#include <itkDwiPhantomGenerationFilter.h>
#define _USE_MATH_DEFINES
#include <math.h>
const std::string QmitkDwiSoftwarePhantomView::VIEW_ID = "org.mitk.views.dwisoftwarephantomview";
QmitkDwiSoftwarePhantomView::QmitkDwiSoftwarePhantomView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
}
// Destructor
QmitkDwiSoftwarePhantomView::~QmitkDwiSoftwarePhantomView()
{
}
void QmitkDwiSoftwarePhantomView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkDwiSoftwarePhantomViewControls;
m_Controls->setupUi( parent );
m_Controls->m_SignalRegionBox->setVisible(false);
connect((QObject*) m_Controls->m_GeneratePhantomButton, SIGNAL(clicked()), (QObject*) this, SLOT(GeneratePhantom()));
connect((QObject*) m_Controls->m_SimulateBaseline, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnSimulateBaselineToggle(int)));
}
}
QmitkDwiSoftwarePhantomView::GradientListType QmitkDwiSoftwarePhantomView::GenerateHalfShell(int NPoints)
{
NPoints *= 2;
vnl_vector<double> theta; theta.set_size(NPoints);
vnl_vector<double> phi; phi.set_size(NPoints);
double C = sqrt(4*M_PI);
phi(0) = 0.0;
phi(NPoints-1) = 0.0;
for(int i=0; i<NPoints; i++)
{
theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
if( i>0 && i<NPoints-1)
{
phi(i) = (phi(i-1) + C /
sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
// % (2*DIST_POINTSHELL_PI);
}
}
GradientListType pointshell;
int numB0 = NPoints/10;
if (numB0==0)
numB0=1;
GradientType g;
g.Fill(0.0);
for (int i=0; i<numB0; i++)
pointshell.push_back(g);
for(int i=0; i<NPoints; i++)
{
g[2] = sin(theta(i));
if (g[2]<0)
continue;
g[0] = cos(theta(i)) * cos(phi(i));
g[1] = cos(theta(i)) * sin(phi(i));
pointshell.push_back(g);
}
return pointshell;
}
template<int ndirs>
std::vector<itk::Vector<double,3> > QmitkDwiSoftwarePhantomView::MakeGradientList()
{
std::vector<itk::Vector<double,3> > retval;
vnl_matrix_fixed<double, 3, ndirs>* U =
itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
// Add 0 vector for B0
int numB0 = ndirs/10;
if (numB0==0)
numB0=1;
itk::Vector<double,3> v;
v.Fill(0.0);
for (int i=0; i<numB0; i++)
{
retval.push_back(v);
}
for(int i=0; i<ndirs;i++)
{
itk::Vector<double,3> v;
v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
retval.push_back(v);
}
return retval;
}
void QmitkDwiSoftwarePhantomView::OnSimulateBaselineToggle(int state)
{
if (state)
{
m_Controls->m_NoiseLabel->setText("Noise Variance:");
m_Controls->m_NoiseLevel->setValue(1.0/(m_Controls->m_NoiseLevel->value()*m_Controls->m_NoiseLevel->value()));
m_Controls->m_NoiseLevel->setToolTip("Variance of Rician noise.");
}
else
{
m_Controls->m_NoiseLabel->setText("SNR:");
if (m_Controls->m_NoiseLevel->value()>0)
m_Controls->m_NoiseLevel->setValue(1.0/(sqrt(m_Controls->m_NoiseLevel->value())));
else
m_Controls->m_NoiseLevel->setValue(0.0001);
m_Controls->m_NoiseLevel->setToolTip("Signal to noise ratio (for values > 99, no noise at all is added to the image).");
}
}
void QmitkDwiSoftwarePhantomView::GeneratePhantom()
{
typedef itk::DwiPhantomGenerationFilter< short > FilterType;
FilterType::GradientListType gradientList;
m_SignalRegions.clear();
for (int i=0; i<m_SignalRegionNodes.size(); i++)
{
mitk::Image::Pointer mitkBinaryImg = dynamic_cast<mitk::Image*>(m_SignalRegionNodes.at(i)->GetData());
ItkUcharImgType::Pointer signalRegion = ItkUcharImgType::New();
mitk::CastToItkImage(mitkBinaryImg, signalRegion);
m_SignalRegions.push_back(signalRegion);
}
gradientList = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
// switch(m_Controls->m_NumGradientsBox->value())
// {
// case 0:
// gradientList = MakeGradientList<12>();
// break;
// case 1:
// gradientList = MakeGradientList<42>();
// break;
// case 2:
// gradientList = MakeGradientList<92>();
// break;
// case 3:
// gradientList = MakeGradientList<162>();
// break;
// case 4:
// gradientList = MakeGradientList<252>();
// break;
// case 5:
// gradientList = MakeGradientList<362>();
// break;
// case 6:
// gradientList = MakeGradientList<492>();
// break;
// case 7:
// gradientList = MakeGradientList<642>();
// break;
// case 8:
// gradientList = MakeGradientList<812>();
// break;
// case 9:
// gradientList = MakeGradientList<1002>();
// break;
// default:
// gradientList = MakeGradientList<92>();
// }
double bVal = m_Controls->m_TensorsToDWIBValueEdit->value();
itk::ImageRegion<3> imageRegion;
imageRegion.SetSize(0, m_Controls->m_SizeX->value());
imageRegion.SetSize(1, m_Controls->m_SizeY->value());
imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
mitk::Vector3D spacing;
spacing[0] = m_Controls->m_SpacingX->value();
spacing[1] = m_Controls->m_SpacingY->value();
spacing[2] = m_Controls->m_SpacingZ->value();
FilterType::Pointer filter = FilterType::New();
filter->SetGradientList(gradientList);
filter->SetBValue(bVal);
filter->SetNoiseVariance(m_Controls->m_NoiseLevel->value());
filter->SetImageRegion(imageRegion);
filter->SetSpacing(spacing);
filter->SetSignalRegions(m_SignalRegions);
filter->SetGreyMatterAdc(m_Controls->m_GmAdc->value());
std::vector< float > tensorFA;
std::vector< float > tensorADC;
std::vector< float > tensorWeight;
std::vector< vnl_vector_fixed<double, 3> > tensorDirection;
for (int i=0; i<m_SpinFa.size(); i++)
{
tensorFA.push_back(m_SpinFa.at(i)->value());
tensorADC.push_back(m_SpinAdc.at(i)->value());
vnl_vector_fixed<double, 3> dir;
dir[0] = m_SpinX.at(i)->value();
dir[1] = m_SpinY.at(i)->value();
dir[2] = m_SpinZ.at(i)->value();
dir.normalize();
tensorDirection.push_back(dir);
tensorWeight.push_back(m_SpinWeight.at(i)->value());
}
filter->SetTensorFA(tensorFA);
filter->SetTensorADC(tensorADC);
filter->SetTensorWeight(tensorWeight);
filter->SetTensorDirection(tensorDirection);
if (!m_Controls->m_SimulateBaseline->isChecked())
filter->SetSimulateBaseline(false);
else
filter->SetSimulateBaseline(true);
filter->Update();
- mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue(bVal);
- image->SetDirections(gradientList);
- image->InitializeFromVectorImage();
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory(filter->GetOutput());
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientList ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( bVal ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( image );
node->SetName(m_Controls->m_ImageName->text().toStdString());
GetDataStorage()->Add(node);
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk( numDirImage.GetPointer() );
image->SetVolume( numDirImage->GetBufferPointer() );
mitk::DataNode::Pointer node2 = mitk::DataNode::New();
node2->SetData(image);
QString name(m_Controls->m_ImageName->text());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_Controls->m_OutputSnrImageBox->isChecked())
{
ItkFloatImgType::Pointer snrImage = filter->GetSNRImage();
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk( snrImage.GetPointer() );
image->SetVolume( snrImage->GetBufferPointer() );
mitk::DataNode::Pointer node2 = mitk::DataNode::New();
node2->SetData(image);
QString name(m_Controls->m_ImageName->text());
name += "_SNR";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_SignalRegionNodes.size()==0)
return;
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
typedef FilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
FilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
QString name(m_Controls->m_ImageName->text());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::BaseGeometry::Pointer geometry = image->GetGeometry();
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
directions->SetGeometry(geometry);
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(directions);
QString name(m_Controls->m_ImageName->text());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkDwiSoftwarePhantomView::UpdateGui()
{
if (!m_SignalRegionNodes.empty())
{
m_Controls->m_SignalRegionBox->setVisible(true);
m_Controls->m_Instruction->setVisible(false);
}
else
{
m_Controls->m_SignalRegionBox->setVisible(false);
m_Controls->m_Instruction->setVisible(true);
}
QLayout* layout = m_Controls->m_SignalRegionBox->layout();
for (int i=0; i<m_Labels.size(); i++)
{
delete m_Labels.at(i);
}
for (int i=0; i<m_SpinFa.size(); i++)
{
delete m_SpinFa.at(i);
delete m_SpinAdc.at(i);
delete m_SpinX.at(i);
delete m_SpinY.at(i);
delete m_SpinZ.at(i);
delete m_SpinWeight.at(i);
}
m_Labels.clear();
m_SpinFa.clear();
m_SpinAdc.clear();
m_SpinX.clear();
m_SpinY.clear();
m_SpinZ.clear();
m_SpinWeight.clear();
if (layout)
delete layout;
QGridLayout* newlayout = new QGridLayout();
m_Controls->m_SignalRegionBox->setLayout(newlayout);
if (!m_SignalRegionNodes.empty())
{
QLabel* label1 = new QLabel("Image");
newlayout->addWidget(label1,0,0);
m_Labels.push_back(label1);
QLabel* label2 = new QLabel("FA");
newlayout->addWidget(label2,0,1);
m_Labels.push_back(label2);
QLabel* label3 = new QLabel("ADC");
newlayout->addWidget(label3,0,2);
m_Labels.push_back(label3);
QLabel* label4 = new QLabel("X");
newlayout->addWidget(label4,0,03);
m_Labels.push_back(label4);
QLabel* label5 = new QLabel("Y");
newlayout->addWidget(label5,0,4);
m_Labels.push_back(label5);
QLabel* label6 = new QLabel("Z");
newlayout->addWidget(label6,0,5);
m_Labels.push_back(label6);
QLabel* label7 = new QLabel("Weight");
newlayout->addWidget(label7,0,6);
m_Labels.push_back(label7);
}
for (int i=0; i<m_SignalRegionNodes.size(); i++)
{
QLabel* label = new QLabel(m_SignalRegionNodes.at(i)->GetName().c_str());
newlayout->addWidget(label,i+1,0);
m_Labels.push_back(label);
QDoubleSpinBox* spinFa = new QDoubleSpinBox();
spinFa->setValue(0.7);
spinFa->setMinimum(0);
spinFa->setMaximum(1);
spinFa->setSingleStep(0.1);
newlayout->addWidget(spinFa,i+1,1);
m_SpinFa.push_back(spinFa);
QDoubleSpinBox* spinAdc = new QDoubleSpinBox();
newlayout->addWidget(spinAdc,i+1,2);
spinAdc->setMinimum(0);
spinAdc->setMaximum(1);
spinAdc->setSingleStep(0.001);
spinAdc->setDecimals(3);
spinAdc->setValue(0.001); ///// ???????????????????????????
m_SpinAdc.push_back(spinAdc);
QDoubleSpinBox* spinX = new QDoubleSpinBox();
newlayout->addWidget(spinX,i+1,3);
spinX->setValue(1);
spinX->setMinimum(-1);
spinX->setMaximum(1);
spinX->setSingleStep(0.1);
m_SpinX.push_back(spinX);
QDoubleSpinBox* spinY = new QDoubleSpinBox();
newlayout->addWidget(spinY,i+1,4);
spinY->setMinimum(-1);
spinY->setMaximum(1);
spinY->setSingleStep(0.1);
m_SpinY.push_back(spinY);
QDoubleSpinBox* spinZ = new QDoubleSpinBox();
newlayout->addWidget(spinZ,i+1,5);
spinZ->setMinimum(-1);
spinZ->setMaximum(1);
spinZ->setSingleStep(0.1);
m_SpinZ.push_back(spinZ);
QDoubleSpinBox* spinWeight = new QDoubleSpinBox();
newlayout->addWidget(spinWeight,i+1,6);
spinWeight->setMinimum(0);
spinWeight->setMaximum(1);
spinWeight->setSingleStep(0.1);
spinWeight->setValue(1.0);
m_SpinWeight.push_back(spinWeight);
}
}
void QmitkDwiSoftwarePhantomView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkDwiSoftwarePhantomView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkDwiSoftwarePhantomView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_SignalRegionNodes.clear();
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
m_SignalRegionNodes.push_back(node);
}
}
UpdateGui();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
index 8e16a7bbd6..f959406314 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
@@ -1,1471 +1,1470 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberProcessingView.h"
#include <QmitkStdMultiWidget.h>
// Qt
#include <QMessageBox>
// MITK
#include <mitkNodePredicateProperty.h>
#include <mitkImageCast.h>
#include <mitkPointSet.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarRectangle.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkGlobalInteraction.h>
#include <mitkImageAccessByItk.h>
#include <mitkDataNodeObject.h>
-#include <mitkDiffusionImage.h>
#include <mitkTensorImage.h>
#include "usModuleRegistry.h"
#include <itkFiberCurvatureFilter.h>
#include "mitkNodePredicateDataType.h"
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateOr.h>
// ITK
#include <itkResampleImageFilter.h>
#include <itkGaussianInterpolateImageFunction.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkTractsToFiberEndingsImageFilter.h>
#include <itkTractDensityImageFilter.h>
#include <itkImageRegion.h>
#include <itkTractsToRgbaImageFilter.h>
#define _USE_MATH_DEFINES
#include <math.h>
const std::string QmitkFiberProcessingView::VIEW_ID = "org.mitk.views.fiberprocessing";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace mitk;
QmitkFiberProcessingView::QmitkFiberProcessingView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_CircleCounter(0)
, m_PolygonCounter(0)
, m_UpsamplingFactor(1)
{
}
// Destructor
QmitkFiberProcessingView::~QmitkFiberProcessingView()
{
}
void QmitkFiberProcessingView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberProcessingViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
connect(m_Controls->m_ExtractFibersButton, SIGNAL(clicked()), this, SLOT(Extract()));
connect(m_Controls->m_RemoveButton, SIGNAL(clicked()), this, SLOT(Remove()));
connect(m_Controls->m_ModifyButton, SIGNAL(clicked()), this, SLOT(Modify()));
connect(m_Controls->m_ExtractionMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
connect(m_Controls->m_RemovalMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
connect(m_Controls->m_ModificationMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
m_Controls->m_ColorMapBox->SetDataStorage(this->GetDataStorage());
mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
m_Controls->m_ColorMapBox->SetPredicate(finalPredicate);
}
UpdateGui();
}
void QmitkFiberProcessingView::Modify()
{
switch (m_Controls->m_ModificationMethodBox->currentIndex())
{
case 0:
{
ResampleSelectedBundles();
break;
}
case 1:
{
CompressSelectedBundles();
break;
}
case 2:
{
DoImageColorCoding();
break;
}
case 3:
{
MirrorFibers();
break;
}
}
}
void QmitkFiberProcessingView::Remove()
{
switch (m_Controls->m_RemovalMethodBox->currentIndex())
{
case 0:
{
RemoveDir();
break;
}
case 1:
{
PruneBundle();
break;
}
case 2:
{
ApplyCurvatureThreshold();
break;
}
case 3:
{
RemoveWithMask(false);
break;
}
case 4:
{
RemoveWithMask(true);
break;
}
}
}
void QmitkFiberProcessingView::Extract()
{
switch (m_Controls->m_ExtractionMethodBox->currentIndex())
{
case 0:
{
ExtractWithPlanarFigure();
break;
}
case 1:
{
switch (m_Controls->m_ExtractionBoxMask->currentIndex())
{
{
case 0:
ExtractWithMask(true, false);
break;
}
{
case 1:
ExtractWithMask(true, true);
break;
}
{
case 2:
ExtractWithMask(false, false);
break;
}
{
case 3:
ExtractWithMask(false, true);
break;
}
}
break;
}
}
}
void QmitkFiberProcessingView::PruneBundle()
{
int minLength = this->m_Controls->m_PruneFibersMinBox->value();
int maxLength = this->m_Controls->m_PruneFibersMaxBox->value();
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
if (!fib->RemoveShortFibers(minLength))
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
else if (!fib->RemoveLongFibers(maxLength))
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::ApplyCurvatureThreshold()
{
int angle = this->m_Controls->m_CurvSpinBox->value();
int dist = this->m_Controls->m_CurvDistanceSpinBox->value();
std::vector< DataNode::Pointer > nodes = m_SelectedFB;
for (int i=0; i<nodes.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(nodes.at(i)->GetData());
itk::FiberCurvatureFilter::Pointer filter = itk::FiberCurvatureFilter::New();
filter->SetInputFiberBundle(fib);
filter->SetAngularDeviation(angle);
filter->SetDistance(dist);
filter->SetRemoveFibers(m_Controls->m_RemoveCurvedFibersBox->isChecked());
filter->Update();
mitk::FiberBundleX::Pointer newFib = filter->GetOutputFiberBundle();
if (newFib->GetNumFibers()>0)
{
nodes.at(i)->SetVisibility(false);
DataNode::Pointer newNode = DataNode::New();
newNode->SetData(newFib);
newNode->SetName(nodes.at(i)->GetName()+"_Curvature");
GetDefaultDataStorage()->Add(newNode, nodes.at(i));
}
else
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
// if (!fib->ApplyCurvatureThreshold(mm, this->m_Controls->m_RemoveCurvedFibersBox->isChecked()))
// QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::RemoveDir()
{
for (unsigned int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
vnl_vector_fixed<double,3> dir;
dir[0] = m_Controls->m_ExtractDirX->value();
dir[1] = m_Controls->m_ExtractDirY->value();
dir[2] = m_Controls->m_ExtractDirZ->value();
fib->RemoveDir(dir,cos((float)m_Controls->m_ExtractAngle->value()*M_PI/180));
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::RemoveWithMask(bool removeInside)
{
if (m_MaskImageNode.IsNull())
return;
mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
for (unsigned int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
QString name(m_SelectedFB.at(i)->GetName().c_str());
itkUCharImageType::Pointer mask = itkUCharImageType::New();
mitk::CastToItkImage(mitkMask, mask);
mitk::FiberBundleX::Pointer newFib = fib->RemoveFibersOutside(mask, removeInside);
if (newFib->GetNumFibers()<=0)
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
continue;
}
DataNode::Pointer newNode = DataNode::New();
newNode->SetData(newFib);
if (removeInside)
name += "_Inside";
else
name += "_Outside";
newNode->SetName(name.toStdString());
GetDefaultDataStorage()->Add(newNode);
m_SelectedFB.at(i)->SetVisibility(false);
}
}
void QmitkFiberProcessingView::ExtractWithMask(bool onlyEnds, bool invert)
{
if (m_MaskImageNode.IsNull())
return;
mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
for (unsigned int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
QString name(m_SelectedFB.at(i)->GetName().c_str());
itkUCharImageType::Pointer mask = itkUCharImageType::New();
mitk::CastToItkImage(mitkMask, mask);
mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, onlyEnds, invert);
if (newFib->GetNumFibers()<=0)
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
continue;
}
DataNode::Pointer newNode = DataNode::New();
newNode->SetData(newFib);
if (invert)
{
name += "_not";
if (onlyEnds)
name += "-ending-in-mask";
else
name += "-passing-mask";
}
else
{
if (onlyEnds)
name += "_ending-in-mask";
else
name += "_passing-mask";
}
newNode->SetName(name.toStdString());
GetDefaultDataStorage()->Add(newNode);
m_SelectedFB.at(i)->SetVisibility(false);
}
}
void QmitkFiberProcessingView::GenerateRoiImage()
{
if (m_SelectedPF.empty())
return;
mitk::BaseGeometry::Pointer geometry;
if (!m_SelectedFB.empty())
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.front()->GetData());
geometry = fib->GetGeometry();
}
else if (m_SelectedImage)
geometry = m_SelectedImage->GetGeometry();
else
return;
itk::Vector<double,3> spacing = geometry->GetSpacing();
spacing /= m_UpsamplingFactor;
mitk::Point3D newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
itk::Matrix<double, 3, 3> direction;
itk::ImageRegion<3> imageRegion;
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
m_PlanarFigureImage = itkUCharImageType::New();
m_PlanarFigureImage->SetSpacing( spacing ); // Set the image spacing
m_PlanarFigureImage->SetOrigin( newOrigin ); // Set the image origin
m_PlanarFigureImage->SetDirection( direction ); // Set the image direction
m_PlanarFigureImage->SetRegions( imageRegion );
m_PlanarFigureImage->Allocate();
m_PlanarFigureImage->FillBuffer( 0 );
Image::Pointer tmpImage = Image::New();
tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
std::string name = m_SelectedPF.at(0)->GetName();
WritePfToImage(m_SelectedPF.at(0), tmpImage);
for (unsigned int i=1; i<m_SelectedPF.size(); i++)
{
name += "+";
name += m_SelectedPF.at(i)->GetName();
WritePfToImage(m_SelectedPF.at(i), tmpImage);
}
DataNode::Pointer node = DataNode::New();
tmpImage = Image::New();
tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
node->SetData(tmpImage);
node->SetName(name);
this->GetDefaultDataStorage()->Add(node);
}
void QmitkFiberProcessingView::WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image)
{
if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
{
m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
AccessFixedDimensionByItk_2(
image,
InternalReorientImagePlane, 3,
m_PlanarFigure->GetGeometry(), -1);
AccessFixedDimensionByItk_2(
m_InternalImage,
InternalCalculateMaskFromPlanarFigure,
3, 2, node->GetName() );
}
else if (dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()))
{
mitk::PlanarFigureComposite* pfc = dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData());
for (int j=0; j<pfc->getNumberOfChildren(); j++)
{
WritePfToImage(pfc->getDataNodeAt(j), image);
}
}
}
template < typename TPixel, unsigned int VImageDimension >
void QmitkFiberProcessingView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::Image< float, VImageDimension > FloatImageType;
typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
typename ResamplerType::Pointer resampler = ResamplerType::New();
mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
float upsamp = m_UpsamplingFactor;
float gausssigma = 0.5;
// Spacing
typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
spacing[0] = image->GetSpacing()[0] / upsamp;
spacing[1] = image->GetSpacing()[1] / upsamp;
spacing[2] = image->GetSpacing()[2];
resampler->SetOutputSpacing( spacing );
// Size
typename ResamplerType::SizeType size;
size[0] = planegeo->GetExtentInMM(0) / spacing[0];
size[1] = planegeo->GetExtentInMM(1) / spacing[1];
size[2] = 1;
resampler->SetSize( size );
// Origin
typename mitk::Point3D orig = planegeo->GetOrigin();
typename mitk::Point3D corrorig;
planegeo3D->WorldToIndex(orig,corrorig);
corrorig[0] += 0.5/upsamp;
corrorig[1] += 0.5/upsamp;
corrorig[2] += 0;
planegeo3D->IndexToWorld(corrorig,corrorig);
resampler->SetOutputOrigin(corrorig );
// Direction
typename ResamplerType::DirectionType direction;
typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
for(int c=0; c<matrix.ColumnDimensions; c++)
{
double sum = 0;
for(int r=0; r<matrix.RowDimensions; r++)
sum += matrix(r,c)*matrix(r,c);
for(int r=0; r<matrix.RowDimensions; r++)
direction(r,c) = matrix(r,c)/sqrt(sum);
}
resampler->SetOutputDirection( direction );
// Gaussian interpolation
if(gausssigma != 0)
{
double sigma[3];
for( unsigned int d = 0; d < 3; d++ )
sigma[d] = gausssigma * image->GetSpacing()[d];
double alpha = 2.0;
typedef itk::GaussianInterpolateImageFunction<ImageType, double> GaussianInterpolatorType;
typename GaussianInterpolatorType::Pointer interpolator = GaussianInterpolatorType::New();
interpolator->SetInputImage( image );
interpolator->SetParameters( sigma, alpha );
resampler->SetInterpolator( interpolator );
}
else
{
typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
interpolator->SetInputImage( image );
resampler->SetInterpolator( interpolator );
}
resampler->SetInput( image );
resampler->SetDefaultPixelValue(0);
resampler->Update();
if(additionalIndex < 0)
{
this->m_InternalImage = mitk::Image::New();
this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
}
}
template < typename TPixel, unsigned int VImageDimension >
void QmitkFiberProcessingView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
// Generate mask image as new image with same header as input image and
// initialize with "1".
itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
newMaskImage->SetSpacing( image->GetSpacing() ); // Set the image spacing
newMaskImage->SetOrigin( image->GetOrigin() ); // Set the image origin
newMaskImage->SetDirection( image->GetDirection() ); // Set the image direction
newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
newMaskImage->Allocate();
newMaskImage->FillBuffer( 1 );
// Generate VTK polygon from (closed) PlanarFigure polyline
// (The polyline points are shifted by -0.5 in z-direction to make sure
// that the extrusion filter, which afterwards elevates all points by +0.5
// in z-direction, creates a 3D object which is cut by the the plane z=0)
const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
const BaseGeometry *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
vtkPolyData *polyline = vtkPolyData::New();
polyline->Allocate( 1, 1 );
// Determine x- and y-dimensions depending on principal axis
int i0, i1;
switch ( axis )
{
case 0:
i0 = 1;
i1 = 2;
break;
case 1:
i0 = 0;
i1 = 2;
break;
case 2:
default:
i0 = 0;
i1 = 1;
break;
}
// Create VTK polydata object of polyline contour
vtkPoints *points = vtkPoints::New();
PlanarFigure::PolyLineType::const_iterator it;
unsigned int numberOfPoints = 0;
for ( it = planarFigurePolyline.begin(); it != planarFigurePolyline.end(); ++it )
{
Point3D point3D;
// Convert 2D point back to the local index coordinates of the selected image
Point2D point2D = *it;
planarFigurePlaneGeometry->WorldToIndex(point2D, point2D);
point2D[0] -= 0.5/m_UpsamplingFactor;
point2D[1] -= 0.5/m_UpsamplingFactor;
planarFigurePlaneGeometry->IndexToWorld(point2D, point2D);
planarFigurePlaneGeometry->Map( point2D, point3D );
// Polygons (partially) outside of the image bounds can not be processed further due to a bug in vtkPolyDataToImageStencil
if ( !imageGeometry3D->IsInside( point3D ) )
{
float bounds[2] = {0,0};
bounds[0] =
this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
bounds[1] =
this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
imageGeometry3D->WorldToIndex( point3D, point3D );
if (point3D[i0]<0)
point3D[i0] = 0.0;
else if (point3D[i0]>bounds[0])
point3D[i0] = bounds[0]-0.001;
if (point3D[i1]<0)
point3D[i1] = 0.0;
else if (point3D[i1]>bounds[1])
point3D[i1] = bounds[1]-0.001;
points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
numberOfPoints++;
}
else
{
imageGeometry3D->WorldToIndex( point3D, point3D );
// Add point to polyline array
points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
numberOfPoints++;
}
}
polyline->SetPoints( points );
points->Delete();
vtkIdType *ptIds = new vtkIdType[numberOfPoints];
for ( vtkIdType i = 0; i < numberOfPoints; ++i )
ptIds[i] = i;
polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
// Extrude the generated contour polygon
vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
extrudeFilter->SetInputData( polyline );
extrudeFilter->SetScaleFactor( 1 );
extrudeFilter->SetExtrusionTypeToNormalExtrusion();
extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
// Make a stencil from the extruded polygon
vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
polyDataToImageStencil->SetInputConnection( extrudeFilter->GetOutputPort() );
// Export from ITK to VTK (to use a VTK filter)
typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
typename ImageExportType::Pointer itkExporter = ImageExportType::New();
itkExporter->SetInput( newMaskImage );
vtkImageImport *vtkImporter = vtkImageImport::New();
this->ConnectPipelines( itkExporter, vtkImporter );
vtkImporter->Update();
// Apply the generated image stencil to the input image
vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
imageStencilFilter->SetStencilConnection(polyDataToImageStencil->GetOutputPort() );
imageStencilFilter->ReverseStencilOff();
imageStencilFilter->SetBackgroundValue( 0 );
imageStencilFilter->Update();
// Export from VTK back to ITK
vtkImageExport *vtkExporter = vtkImageExport::New();
vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
vtkExporter->Update();
typename ImageImportType::Pointer itkImporter = ImageImportType::New();
this->ConnectPipelines( vtkExporter, itkImporter );
itkImporter->Update();
// calculate cropping bounding box
m_InternalImageMask3D = itkImporter->GetOutput();
m_InternalImageMask3D->SetDirection(image->GetDirection());
itk::ImageRegionConstIterator<itkUCharImageType>
itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType>
itimage(image, image->GetLargestPossibleRegion());
itmask.GoToBegin();
itimage.GoToBegin();
typename ImageType::SizeType lowersize = {{9999999999,9999999999,9999999999}};
typename ImageType::SizeType uppersize = {{0,0,0}};
while( !itmask.IsAtEnd() )
{
if(itmask.Get() == 0)
itimage.Set(0);
else
{
typename ImageType::IndexType index = itimage.GetIndex();
typename ImageType::SizeType signedindex;
signedindex[0] = index[0];
signedindex[1] = index[1];
signedindex[2] = index[2];
lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
}
++itmask;
++itimage;
}
typename ImageType::IndexType index;
index[0] = lowersize[0];
index[1] = lowersize[1];
index[2] = lowersize[2];
typename ImageType::SizeType size;
size[0] = uppersize[0] - lowersize[0] + 1;
size[1] = uppersize[1] - lowersize[1] + 1;
size[2] = uppersize[2] - lowersize[2] + 1;
itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
// crop internal mask
typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
roi2->SetRegionOfInterest(cropRegion);
roi2->SetInput(m_InternalImageMask3D);
roi2->Update();
m_InternalImageMask3D = roi2->GetOutput();
Image::Pointer tmpImage = Image::New();
tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
Image::Pointer tmpImage2 = Image::New();
tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
const BaseGeometry *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
const BaseGeometry *intImageGeometry3D = tmpImage->GetGeometry( 0 );
typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
imageIterator.GoToBegin();
while ( !imageIterator.IsAtEnd() )
{
unsigned char val = imageIterator.Value();
if (val>0)
{
itk::Index<3> index = imageIterator.GetIndex();
Point3D point;
point[0] = index[0];
point[1] = index[1];
point[2] = index[2];
intImageGeometry3D->IndexToWorld(point, point);
pfImageGeometry3D->WorldToIndex(point, point);
point[i0] += 0.5;
point[i1] += 0.5;
index[0] = point[0];
index[1] = point[1];
index[2] = point[2];
if (pfImageGeometry3D->IsIndexInside(index))
m_PlanarFigureImage->SetPixel(index, 1);
}
++imageIterator;
}
// Clean up VTK objects
polyline->Delete();
extrudeFilter->Delete();
polyDataToImageStencil->Delete();
vtkImporter->Delete();
imageStencilFilter->Delete();
//vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
delete[] ptIds;
}
void QmitkFiberProcessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkFiberProcessingView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkFiberProcessingView::UpdateGui()
{
m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_RemoveButton->setEnabled(false);
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
m_Controls->PFCompoANDButton->setEnabled(false);
m_Controls->PFCompoORButton->setEnabled(false);
m_Controls->PFCompoNOTButton->setEnabled(false);
m_Controls->m_GenerateRoiImage->setEnabled(false);
m_Controls->m_ExtractFibersButton->setEnabled(false);
m_Controls->m_ModifyButton->setEnabled(false);
m_Controls->m_JoinBundles->setEnabled(false);
m_Controls->m_SubstractBundles->setEnabled(false);
// disable alle frames
m_Controls->m_ExtractionBoxMask->setVisible(false);
m_Controls->m_ExtactionFramePF->setVisible(false);
m_Controls->m_RemoveDirectionFrame->setVisible(false);
m_Controls->m_RemoveLengthFrame->setVisible(false);
m_Controls->m_RemoveCurvatureFrame->setVisible(false);
m_Controls->m_SmoothFibersFrame->setVisible(false);
m_Controls->m_CompressFibersFrame->setVisible(false);
m_Controls->m_ColorFibersFrame->setVisible(false);
m_Controls->m_MirrorFibersFrame->setVisible(false);
bool pfSelected = !m_SelectedPF.empty();
bool fibSelected = !m_SelectedFB.empty();
bool multipleFibsSelected = (m_SelectedFB.size()>1);
bool maskSelected = m_MaskImageNode.IsNotNull();
bool imageSelected = m_SelectedImage.IsNotNull();
// toggle visibility of elements according to selected method
switch ( m_Controls->m_ExtractionMethodBox->currentIndex() )
{
case 0:
m_Controls->m_ExtactionFramePF->setVisible(true);
break;
case 1:
m_Controls->m_ExtractionBoxMask->setVisible(true);
break;
}
switch ( m_Controls->m_RemovalMethodBox->currentIndex() )
{
case 0:
m_Controls->m_RemoveDirectionFrame->setVisible(true);
if ( fibSelected )
m_Controls->m_RemoveButton->setEnabled(true);
break;
case 1:
m_Controls->m_RemoveLengthFrame->setVisible(true);
if ( fibSelected )
m_Controls->m_RemoveButton->setEnabled(true);
break;
case 2:
m_Controls->m_RemoveCurvatureFrame->setVisible(true);
if ( fibSelected )
m_Controls->m_RemoveButton->setEnabled(true);
break;
case 3:
break;
case 4:
break;
}
switch ( m_Controls->m_ModificationMethodBox->currentIndex() )
{
case 0:
m_Controls->m_SmoothFibersFrame->setVisible(true);
break;
case 1:
m_Controls->m_CompressFibersFrame->setVisible(true);
break;
case 2:
m_Controls->m_ColorFibersFrame->setVisible(true);
break;
case 3:
m_Controls->m_MirrorFibersFrame->setVisible(true);
break;
}
// are fiber bundles selected?
if ( fibSelected )
{
m_Controls->m_ModifyButton->setEnabled(true);
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
// one bundle and one planar figure needed to extract fibers
if (pfSelected)
{
m_Controls->m_InputData->setTitle("Input Data");
m_Controls->m_PfLabel->setText(QString(m_SelectedPF.at(0)->GetName().c_str()));
m_Controls->m_ExtractFibersButton->setEnabled(true);
}
// more than two bundles needed to join/subtract
if (multipleFibsSelected)
{
m_Controls->m_FibLabel->setText("multiple bundles selected");
m_Controls->m_JoinBundles->setEnabled(true);
m_Controls->m_SubstractBundles->setEnabled(true);
}
if (maskSelected)
{
m_Controls->m_RemoveButton->setEnabled(true);
m_Controls->m_ExtractFibersButton->setEnabled(true);
}
}
// are planar figures selected?
if (pfSelected)
{
if ( fibSelected || m_SelectedImage.IsNotNull())
m_Controls->m_GenerateRoiImage->setEnabled(true);
if (m_SelectedPF.size() > 1)
{
m_Controls->PFCompoANDButton->setEnabled(true);
m_Controls->PFCompoORButton->setEnabled(true);
}
else
m_Controls->PFCompoNOTButton->setEnabled(true);
}
// is image selected
if (imageSelected || maskSelected)
{
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
}
}
void QmitkFiberProcessingView::NodeRemoved(const mitk::DataNode* node)
{
std::vector<mitk::DataNode*> nodes;
OnSelectionChanged(nodes);
}
void QmitkFiberProcessingView::NodeAdded(const mitk::DataNode* node)
{
std::vector<mitk::DataNode*> nodes;
OnSelectionChanged(nodes);
}
void QmitkFiberProcessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
//reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
m_SelectedFB.clear();
m_SelectedPF.clear();
m_SelectedSurfaces.clear();
m_SelectedImage = NULL;
m_MaskImageNode = NULL;
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
m_SelectedFB.push_back(node);
else if (dynamic_cast<mitk::PlanarPolygon*>(node->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()) || dynamic_cast<mitk::PlanarCircle*>(node->GetData()))
m_SelectedPF.push_back(node);
else if (dynamic_cast<mitk::Image*>(node->GetData()))
{
m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
m_MaskImageNode = node;
}
else if (dynamic_cast<mitk::Surface*>(node->GetData()))
m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
}
if (m_SelectedFB.empty())
{
int maxLayer = 0;
itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
for (unsigned int i=0; i<nodes->Size(); i++)
if (dynamic_cast<mitk::FiberBundleX*>(nodes->at(i)->GetData()))
{
mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
if (sources->Size()>0)
continue;
int layer = 0;
nodes->at(i)->GetPropertyValue("layer", layer);
if (layer>=maxLayer)
{
maxLayer = layer;
m_SelectedFB.clear();
m_SelectedFB.push_back(nodes->at(i));
}
}
}
if (m_SelectedPF.empty())
{
int maxLayer = 0;
itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
for (unsigned int i=0; i<nodes->Size(); i++)
if (dynamic_cast<mitk::PlanarPolygon*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarCircle*>(nodes->at(i)->GetData()))
{
mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
if (sources->Size()>0)
continue;
int layer = 0;
nodes->at(i)->GetPropertyValue("layer", layer);
if (layer>=maxLayer)
{
maxLayer = layer;
m_SelectedPF.clear();
m_SelectedPF.push_back(nodes->at(i));
}
}
}
UpdateGui();
}
void QmitkFiberProcessingView::OnDrawPolygon()
{
mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
figure->ClosedOn();
this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
}
void QmitkFiberProcessingView::OnDrawCircle()
{
mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
}
void QmitkFiberProcessingView::Activated()
{
}
void QmitkFiberProcessingView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *, mitk::BaseProperty* )
{
// initialize figure's geometry with empty geometry
mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
figure->SetPlaneGeometry( emptygeometry );
//set desired data to DataNode where Planarfigure is stored
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
newNode->SetBoolProperty("planarfigure.3drendering", true);
mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(newNode->GetDataInteractor().GetPointer());
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New();
us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode(newNode);
}
// figure drawn on the topmost layer / image
GetDataStorage()->Add(newNode );
for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
m_SelectedPF[i]->SetSelected(false);
newNode->SetSelected(true);
m_SelectedPF.clear();
m_SelectedPF.push_back(newNode);
UpdateGui();
}
void QmitkFiberProcessingView::ExtractWithPlanarFigure()
{
if ( m_SelectedFB.empty() || m_SelectedPF.empty() ){
QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
return;
}
std::vector<mitk::DataNode::Pointer> fiberBundles = m_SelectedFB;
mitk::DataNode::Pointer planarFigure = m_SelectedPF.at(0);
for (unsigned int i=0; i<fiberBundles.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(fiberBundles.at(i)->GetData());
mitk::BaseData::Pointer roi = planarFigure->GetData();
mitk::FiberBundleX::Pointer extFB = fib->ExtractFiberSubset(roi);
if (extFB->GetNumFibers()<=0)
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
continue;
}
mitk::DataNode::Pointer node;
node = mitk::DataNode::New();
node->SetData(extFB);
QString name(fiberBundles.at(i)->GetName().c_str());
name += "_";
name += planarFigure->GetName().c_str();
node->SetName(name.toStdString());
fiberBundles.at(i)->SetVisibility(false);
GetDataStorage()->Add(node);
}
}
void QmitkFiberProcessingView::GenerateAndComposite()
{
mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
PFCAnd->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
{
mitk::DataNode::Pointer nodePF = *it;
PFCAnd->addPlanarFigure( nodePF->GetData() );
PFCAnd->addDataNode( nodePF );
PFCAnd->setDisplayName("AND");
}
AddCompositeToDatastorage(PFCAnd);
}
void QmitkFiberProcessingView::GenerateOrComposite()
{
mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
PFCOr->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
{
mitk::DataNode::Pointer nodePF = *it;
PFCOr->addPlanarFigure( nodePF->GetData() );
PFCOr->addDataNode( nodePF );
PFCOr->setDisplayName("OR");
}
AddCompositeToDatastorage(PFCOr);
}
void QmitkFiberProcessingView::GenerateNotComposite()
{
mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
PFCNot->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
{
mitk::DataNode::Pointer nodePF = *it;
PFCNot->addPlanarFigure( nodePF->GetData() );
PFCNot->addDataNode( nodePF );
PFCNot->setDisplayName("NOT");
}
AddCompositeToDatastorage(PFCNot);
}
/* CLEANUP NEEDED */
void QmitkFiberProcessingView::AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfc, mitk::DataNode::Pointer parentNode )
{
mitk::DataNode::Pointer newPFCNode;
newPFCNode = mitk::DataNode::New();
newPFCNode->SetName( pfc->getDisplayName() );
newPFCNode->SetData(pfc);
switch (pfc->getOperationType()) {
case 0:
{
if (parentNode.IsNotNull())
GetDataStorage()->Add(newPFCNode, parentNode);
else
GetDataStorage()->Add(newPFCNode);
//iterate through its childs
for(int i=0; i<pfc->getNumberOfChildren(); ++i)
{
mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
if ( pfcompcast.IsNotNull() )
{
// child is of type planar Figure composite
// make new node of the child, cuz later the child has to be removed of its old position in datamanager
// feed new dataNode with information of the savedDataNode, which is gonna be removed soon
mitk::DataNode::Pointer newChildPFCNode;
newChildPFCNode = mitk::DataNode::New();
newChildPFCNode->SetData(tmpPFchild);
newChildPFCNode->SetName( savedPFchildNode->GetName() );
pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
//update inside vector the dataNodePointer
pfc->replaceDataNodeAt(i, newChildPFCNode);
AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
// remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
// without having its parent anymore
GetDataStorage()->Remove(savedPFchildNode);
}
else
{
// child is not of type PlanarFigureComposite, so its one of the planarFigures
// create new dataNode containing the data of the old dataNode, but position in dataManager will be
// modified cuz we re setting a (new) parent.
mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
newPFchildNode->SetName(savedPFchildNode->GetName() );
newPFchildNode->SetData(tmpPFchild);
newPFchildNode->SetVisibility(true);
newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
// replace the dataNode in PFComp DataNodeVector
pfc->replaceDataNodeAt(i, newPFchildNode);
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
//add new child to datamanager with its new position as child of newPFCNode parent
GetDataStorage()->Add(newPFchildNode, newPFCNode);
}
}
break;
}
case 1:
{
if (!parentNode.IsNull())
GetDataStorage()->Add(newPFCNode, parentNode);
else
GetDataStorage()->Add(newPFCNode);
for(int i=0; i<pfc->getNumberOfChildren(); ++i)
{
mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
if ( !pfcompcast.IsNull() )
{
// child is of type planar Figure composite
// make new node of the child, cuz later the child has to be removed of its old position in datamanager
// feed new dataNode with information of the savedDataNode, which is gonna be removed soon
mitk::DataNode::Pointer newChildPFCNode;
newChildPFCNode = mitk::DataNode::New();
newChildPFCNode->SetData(tmpPFchild);
newChildPFCNode->SetName( savedPFchildNode->GetName() );
pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
//update inside vector the dataNodePointer
pfc->replaceDataNodeAt(i, newChildPFCNode);
AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
}
else
{
// child is not of type PlanarFigureComposite, so its one of the planarFigures
// create new dataNode containing the data of the old dataNode, but position in dataManager will be
// modified cuz we re setting a (new) parent.
mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
newPFchildNode->SetName(savedPFchildNode->GetName() );
newPFchildNode->SetData(tmpPFchild);
newPFchildNode->SetVisibility(true);
newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
// replace the dataNode in PFComp DataNodeVector
pfc->replaceDataNodeAt(i, newPFchildNode);
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
//add new child to datamanager with its new position as child of newPFCNode parent
GetDataStorage()->Add(newPFchildNode, newPFCNode);
}
}
break;
}
case 2:
{
if (!parentNode.IsNull())
GetDataStorage()->Add(newPFCNode, parentNode);
else
GetDataStorage()->Add(newPFCNode);
//iterate through its childs
for(int i=0; i<pfc->getNumberOfChildren(); ++i)
{
mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
if ( !pfcompcast.IsNull() )
{ // child is of type planar Figure composite
// makeRemoveBundle new node of the child, cuz later the child has to be removed of its old position in datamanager
// feed new dataNode with information of the savedDataNode, which is gonna be removed soon
mitk::DataNode::Pointer newChildPFCNode;
newChildPFCNode = mitk::DataNode::New();
newChildPFCNode->SetData(tmpPFchild);
newChildPFCNode->SetName( savedPFchildNode->GetName() );
pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
//update inside vector the dataNodePointer
pfc->replaceDataNodeAt(i, newChildPFCNode);
AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
}
else
{
// child is not of type PlanarFigureComposite, so its one of the planarFigures
// create new dataNode containing the data of the old dataNode, but position in dataManager will be
// modified cuz we re setting a (new) parent.
mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
newPFchildNode->SetName(savedPFchildNode->GetName() );
newPFchildNode->SetData(tmpPFchild);
newPFchildNode->SetVisibility(true);
newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
// replace the dataNode in PFComp DataNodeVector
pfc->replaceDataNodeAt(i, newPFchildNode);
// remove old child position in dataStorage
GetDataStorage()->Remove(savedPFchildNode);
//add new child to datamanager with its new position as child of newPFCNode parent
GetDataStorage()->Add(newPFchildNode, newPFCNode);
}
}
break;
}
default:
MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
break;
}
for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
m_SelectedPF[i]->SetSelected(false);
newPFCNode->SetSelected(true);
m_SelectedPF.clear();
m_SelectedPF.push_back(newPFCNode);
UpdateGui();
}
void QmitkFiberProcessingView::JoinBundles()
{
if ( m_SelectedFB.size()<2 ){
QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
return;
}
mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
m_SelectedFB.at(0)->SetVisibility(false);
QString name("");
name += QString(m_SelectedFB.at(0)->GetName().c_str());
for (unsigned int i=1; i<m_SelectedFB.size(); i++)
{
newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
name += "+"+QString(m_SelectedFB.at(i)->GetName().c_str());
m_SelectedFB.at(i)->SetVisibility(false);
}
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode);
}
void QmitkFiberProcessingView::SubstractBundles()
{
if ( m_SelectedFB.size()<2 ){
QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
return;
}
mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
m_SelectedFB.at(0)->SetVisibility(false);
QString name("");
name += QString(m_SelectedFB.at(0)->GetName().c_str());
for (unsigned int i=1; i<m_SelectedFB.size(); i++)
{
newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
if (newBundle.IsNull())
break;
name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
m_SelectedFB.at(i)->SetVisibility(false);
}
if (newBundle.IsNull())
{
QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
return;
}
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode);
}
void QmitkFiberProcessingView::ResampleSelectedBundles()
{
double factor = this->m_Controls->m_SmoothFibersBox->value();
for (unsigned int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
fib->ResampleSpline(factor);
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::CompressSelectedBundles()
{
double factor = this->m_Controls->m_ErrorThresholdBox->value();
for (unsigned int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
fib->Compress(factor);
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberProcessingView::DoImageColorCoding()
{
if (m_Controls->m_ColorMapBox->GetSelectedNode().IsNull())
{
QMessageBox::information(NULL, "Bundle coloring aborted:", "No image providing the scalar values for coloring the selected bundle available.");
return;
}
for(unsigned int i=0; i<m_SelectedFB.size(); i++ )
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
fib->SetFAMap(dynamic_cast<mitk::Image*>(m_Controls->m_ColorMapBox->GetSelectedNode()->GetData()));
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_FA_BASED);
fib->DoColorCodingFaBased();
}
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkFiberProcessingView::MirrorFibers()
{
unsigned int axis = this->m_Controls->m_MirrorFibersBox->currentIndex();
for (int i=0; i<m_SelectedFB.size(); i++)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
fib->MirrorFibers(axis);
}
if (m_SelectedSurfaces.size()>0)
{
for (int i=0; i<m_SelectedSurfaces.size(); i++)
{
mitk::Surface::Pointer surf = m_SelectedSurfaces.at(i);
vtkSmartPointer<vtkPolyData> poly = surf->GetVtkPolyData();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
for (int i=0; i<poly->GetNumberOfPoints(); i++)
{
double* point = poly->GetPoint(i);
point[axis] *= -1;
vtkNewPoints->InsertNextPoint(point);
}
poly->SetPoints(vtkNewPoints);
surf->CalculateBoundingBox();
}
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
index 3aaec4a69d..e12f09e205 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
@@ -1,443 +1,442 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberQuantificationView.h"
#include <QmitkStdMultiWidget.h>
// Qt
#include <QMessageBox>
// MITK
#include <mitkNodePredicateProperty.h>
#include <mitkImageCast.h>
#include <mitkPointSet.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarRectangle.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkGlobalInteraction.h>
#include <mitkImageAccessByItk.h>
#include <mitkDataNodeObject.h>
-#include <mitkDiffusionImage.h>
#include <mitkTensorImage.h>
// ITK
#include <itkResampleImageFilter.h>
#include <itkGaussianInterpolateImageFunction.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkTractsToFiberEndingsImageFilter.h>
#include <itkTractDensityImageFilter.h>
#include <itkImageRegion.h>
#include <itkTractsToRgbaImageFilter.h>
#include <itkTractsToVectorImageFilter.h>
#include <math.h>
#include <boost/lexical_cast.hpp>
const std::string QmitkFiberQuantificationView::VIEW_ID = "org.mitk.views.fiberquantification";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace mitk;
QmitkFiberQuantificationView::QmitkFiberQuantificationView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_UpsamplingFactor(5)
{
}
// Destructor
QmitkFiberQuantificationView::~QmitkFiberQuantificationView()
{
}
void QmitkFiberQuantificationView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberQuantificationViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->m_ProcessFiberBundleButton, SIGNAL(clicked()), this, SLOT(ProcessSelectedBundles()) );
connect( m_Controls->m_ExtractFiberPeaks, SIGNAL(clicked()), this, SLOT(CalculateFiberDirections()) );
}
}
void QmitkFiberQuantificationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkFiberQuantificationView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkFiberQuantificationView::CalculateFiberDirections()
{
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image< itk::Vector< float, 3>, 3 > ItkDirectionImage3DType;
typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer > ItkDirectionImageContainerType;
// load fiber bundle
mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.back()->GetData());
itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
if (m_SelectedImage.IsNotNull())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
mitk::CastToItkImage<ItkUcharImgType>(m_SelectedImage, itkMaskImage);
fOdfFilter->SetMaskImage(itkMaskImage);
}
// extract directions from fiber bundle
fOdfFilter->SetFiberBundle(inputTractogram);
fOdfFilter->SetAngularThreshold(cos(m_Controls->m_AngularThreshold->value()*M_PI/180));
fOdfFilter->SetNormalizeVectors(m_Controls->m_NormalizeDirectionsBox->isChecked());
fOdfFilter->SetUseWorkingCopy(true);
fOdfFilter->SetCreateDirectionImages(m_Controls->m_DirectionImagesBox->isChecked());
fOdfFilter->SetSizeThreshold(m_Controls->m_PeakThreshold->value());
fOdfFilter->SetMaxNumDirections(m_Controls->m_MaxNumDirections->value());
fOdfFilter->Update();
QString name = m_SelectedFB.back()->GetName().c_str();
if (m_Controls->m_VectorFieldBox->isChecked())
{
float minSpacing = 1;
if (m_SelectedImage.IsNotNull())
{
mitk::Vector3D outImageSpacing = m_SelectedImage->GetGeometry()->GetSpacing();
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
}
mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(directions);
node->SetName((name+"_vectorfield").toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
node->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 1.0f));
GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
}
if (m_Controls->m_NumDirectionsBox->isChecked())
{
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitkImage->InitializeByItk( fOdfFilter->GetNumDirectionsImage().GetPointer() );
mitkImage->SetVolume( fOdfFilter->GetNumDirectionsImage()->GetBufferPointer() );
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(mitkImage);
node->SetName((name+"_numdirections").toStdString().c_str());
GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
}
if (m_Controls->m_DirectionImagesBox->isChecked())
{
ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
for (unsigned int i=0; i<directionImageContainer->Size(); i++)
{
itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
if (itkImg.IsNull())
return;
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitkImage->InitializeByItk( itkImg.GetPointer() );
mitkImage->SetVolume( itkImg->GetBufferPointer() );
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(mitkImage);
node->SetName( (name+"_direction_"+boost::lexical_cast<std::string>(i).c_str()).toStdString().c_str());
node->SetVisibility(false);
GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
}
}
}
void QmitkFiberQuantificationView::UpdateGui()
{
m_Controls->m_ProcessFiberBundleButton->setEnabled(!m_SelectedFB.empty());
m_Controls->m_ExtractFiberPeaks->setEnabled(!m_SelectedFB.empty());
}
void QmitkFiberQuantificationView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
//reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
m_SelectedFB.clear();
m_SelectedSurfaces.clear();
m_SelectedImage = NULL;
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
m_SelectedFB.push_back(node);
}
else if (dynamic_cast<mitk::Image*>(node->GetData()))
m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
else if (dynamic_cast<mitk::Surface*>(node->GetData()))
{
m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
}
}
UpdateGui();
GenerateStats();
}
void QmitkFiberQuantificationView::Activated()
{
}
void QmitkFiberQuantificationView::GenerateStats()
{
if ( m_SelectedFB.empty() )
return;
QString stats("");
for( int i=0; i<m_SelectedFB.size(); i++ )
{
mitk::DataNode::Pointer node = m_SelectedFB[i];
if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
if (i>0)
stats += "\n-----------------------------\n";
stats += QString(node->GetName().c_str()) + "\n";
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
stats += "Number of fibers: "+ QString::number(fib->GetNumFibers()) + "\n";
stats += "Number of points: "+ QString::number(fib->GetNumberOfPoints()) + "\n";
stats += "Min. length: "+ QString::number(fib->GetMinFiberLength(),'f',1) + " mm\n";
stats += "Max. length: "+ QString::number(fib->GetMaxFiberLength(),'f',1) + " mm\n";
stats += "Mean length: "+ QString::number(fib->GetMeanFiberLength(),'f',1) + " mm\n";
stats += "Median length: "+ QString::number(fib->GetMedianFiberLength(),'f',1) + " mm\n";
stats += "Standard deviation: "+ QString::number(fib->GetLengthStDev(),'f',1) + " mm\n";
}
}
this->m_Controls->m_StatsTextEdit->setText(stats);
}
void QmitkFiberQuantificationView::ProcessSelectedBundles()
{
if ( m_SelectedFB.empty() ){
QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
MITK_WARN("QmitkFiberQuantificationView") << "no fibe bundle selected";
return;
}
int generationMethod = m_Controls->m_GenerationBox->currentIndex();
for( int i=0; i<m_SelectedFB.size(); i++ )
{
mitk::DataNode::Pointer node = m_SelectedFB[i];
if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
QString name(node->GetName().c_str());
DataNode::Pointer newNode = NULL;
switch(generationMethod){
case 0:
newNode = GenerateTractDensityImage(fib, false, true);
name += "_TDI";
break;
case 1:
newNode = GenerateTractDensityImage(fib, false, false);
name += "_TDI";
break;
case 2:
newNode = GenerateTractDensityImage(fib, true, false);
name += "_envelope";
break;
case 3:
newNode = GenerateColorHeatmap(fib);
break;
case 4:
newNode = GenerateFiberEndingsImage(fib);
name += "_fiber_endings";
break;
case 5:
newNode = GenerateFiberEndingsPointSet(fib);
name += "_fiber_endings";
break;
}
if (newNode.IsNotNull())
{
newNode->SetName(name.toStdString());
GetDataStorage()->Add(newNode);
}
}
}
}
// generate pointset displaying the fiber endings
mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib)
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
vtkSmartPointer<vtkPolyData> fiberPolyData = fib->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int count = 0;
int numFibers = fib->GetNumFibers();
for( int i=0; i<numFibers; i++ )
{
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
if (numPoints>0)
{
double* point = fiberPolyData->GetPoint(points[0]);
itk::Point<float,3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
pointSet->InsertPoint(count, itkPoint);
count++;
}
if (numPoints>2)
{
double* point = fiberPolyData->GetPoint(points[numPoints-1]);
itk::Point<float,3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
pointSet->InsertPoint(count, itkPoint);
count++;
}
}
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( pointSet );
return node;
}
// generate image displaying the fiber endings
mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib)
{
typedef unsigned char OutPixType;
typedef itk::Image<OutPixType,3> OutImageType;
typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
generator->SetFiberBundle(fib);
generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
if (m_SelectedImage.IsNotNull())
{
OutImageType::Pointer itkImage = OutImageType::New();
CastToItkImage(m_SelectedImage, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
OutImageType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
return node;
}
// generate rgba heatmap from fiber bundle
mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib)
{
typedef itk::RGBAPixel<unsigned char> OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
typedef itk::TractsToRgbaImageFilter< OutImageType > ImageGeneratorType;
ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
generator->SetFiberBundle(fib);
generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
if (m_SelectedImage.IsNotNull())
{
itk::Image<unsigned char, 3>::Pointer itkImage = itk::Image<unsigned char, 3>::New();
CastToItkImage(m_SelectedImage, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
typedef itk::Image<OutPixType,3> OutType;
OutType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
return node;
}
// generate tract density image from fiber bundle
mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute)
{
typedef float OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
generator->SetFiberBundle(fib);
generator->SetBinaryOutput(binary);
generator->SetOutputAbsoluteValues(absolute);
generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
if (m_SelectedImage.IsNotNull())
{
OutImageType::Pointer itkImage = OutImageType::New();
CastToItkImage(m_SelectedImage, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
typedef itk::Image<OutPixType,3> OutType;
OutType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
return node;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
index 5c48643290..fd750f32f1 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2659 +1,2694 @@
/*===================================================================
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.
===================================================================*/
//misc
#define _USE_MATH_DEFINES
#include <math.h>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberfoxView.h"
// MITK
#include <mitkImage.h>
-#include <mitkDiffusionImage.h>
#include <mitkImageToItk.h>
#include <mitkImageCast.h>
#include <mitkProperties.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkDataStorage.h>
#include <itkFibersFromPlanarFiguresFilter.h>
#include <itkTractsToDWIImageFilter.h>
#include <mitkTensorImage.h>
#include <mitkILinkedRenderWindowPart.h>
#include <mitkGlobalInteraction.h>
#include <mitkImageToItk.h>
#include <mitkImageCast.h>
#include <mitkImageGenerator.h>
#include <mitkNodePredicateDataType.h>
#include <itkScalableAffineTransform.h>
#include <mitkLevelWindowProperty.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateProperty.h>
+#include <mitkNodePredicateIsDWI.h>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>
#include <QFileDialog>
#include <QMessageBox>
#include "usModuleRegistry.h"
#include <mitkChiSquareNoiseModel.h>
#include <itksys/SystemTools.hxx>
#include <mitkIOUtil.h>
#include <QScrollBar>
#include <itkInvertIntensityImageFilter.h>
#include <QDialogButtonBox>
#include <itkAdcImageFilter.h>
#include <itkShiftScaleImageFilter.h>
+#include <mitkITKImageImport.h>
#include "mitkNodePredicateDataType.h"
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateOr.h>
#define _USE_MATH_DEFINES
#include <math.h>
QmitkFiberfoxWorker::QmitkFiberfoxWorker(QmitkFiberfoxView* view)
: m_View(view)
{
}
void QmitkFiberfoxWorker::run()
{
try{
switch (m_FilterType)
{
case 0:
m_View->m_TractsToDwiFilter->Update();
break;
case 1:
m_View->m_ArtifactsToDwiFilter->Update();
break;
}
}
catch( ... )
{
}
m_View->m_Thread.quit();
}
const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
QmitkFiberfoxView::QmitkFiberfoxView()
: QmitkAbstractView()
, m_Controls( 0 )
, m_SelectedImage( NULL )
, m_Worker(this)
, m_ThreadIsRunning(false)
{
m_Worker.moveToThread(&m_Thread);
connect(&m_Thread, SIGNAL(started()), this, SLOT(BeforeThread()));
connect(&m_Thread, SIGNAL(started()), &m_Worker, SLOT(run()));
connect(&m_Thread, SIGNAL(finished()), this, SLOT(AfterThread()));
connect(&m_Thread, SIGNAL(terminated()), this, SLOT(AfterThread()));
m_SimulationTimer = new QTimer(this);
}
void QmitkFiberfoxView::KillThread()
{
MITK_INFO << "Aborting DWI simulation.";
switch (m_Worker.m_FilterType)
{
case 0:
m_TractsToDwiFilter->SetAbortGenerateData(true);
break;
case 1:
m_ArtifactsToDwiFilter->SetAbortGenerateData(true);
break;
}
m_Controls->m_AbortSimulationButton->setEnabled(false);
m_Controls->m_AbortSimulationButton->setText("Aborting simulation ...");
}
void QmitkFiberfoxView::BeforeThread()
{
m_SimulationTime = QTime::currentTime();
m_SimulationTimer->start(100);
m_Controls->m_AbortSimulationButton->setVisible(true);
m_Controls->m_GenerateImageButton->setVisible(false);
m_Controls->m_SimulationStatusText->setVisible(true);
m_ThreadIsRunning = true;
}
void QmitkFiberfoxView::AfterThread()
{
UpdateSimulationStatus();
m_SimulationTimer->stop();
m_Controls->m_AbortSimulationButton->setVisible(false);
m_Controls->m_AbortSimulationButton->setEnabled(true);
m_Controls->m_AbortSimulationButton->setText("Abort simulation");
m_Controls->m_GenerateImageButton->setVisible(true);
m_ThreadIsRunning = false;
QString statusText;
FiberfoxParameters<double> parameters;
- mitk::DiffusionImage<short>::Pointer mitkImage = mitk::DiffusionImage<short>::New();
+ mitk::Image::Pointer mitkImage = mitk::Image::New();
switch (m_Worker.m_FilterType)
{
case 0:
{
statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
if (m_TractsToDwiFilter->GetAbortGenerateData())
{
MITK_INFO << "Simulation aborted.";
return;
}
parameters = m_TractsToDwiFilter->GetParameters();
- mitkImage->SetVectorImage( m_TractsToDwiFilter->GetOutput() );
- mitkImage->SetReferenceBValue(parameters.m_SignalGen.m_Bvalue);
- mitkImage->SetDirections(parameters.m_SignalGen.GetGradientDirections());
- mitkImage->InitializeFromVectorImage();
+ mitkImage = mitk::GrabItkImageMemory( m_TractsToDwiFilter->GetOutput() );
+ mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ));
+ mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ));
+ mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
+ propertyHelper.InitializeImage();
parameters.m_Misc.m_ResultNode->SetData( mitkImage );
parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()
+"_D"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(0)).toStdString()
+"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(1)).toStdString()
+"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(2)).toStdString()
+"_S"+QString::number(parameters.m_SignalGen.m_ImageSpacing[0]).toStdString()
+"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[1]).toStdString()
+"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[2]).toStdString()
+"_b"+QString::number(parameters.m_SignalGen.m_Bvalue).toStdString()
+"_"+parameters.m_Misc.m_SignalModelString
+parameters.m_Misc.m_ArtifactModelString);
GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
parameters.m_Misc.m_ResultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(m_TractsToDwiFilter->GetLevelWindow()) );
if (m_Controls->m_VolumeFractionsBox->isChecked())
{
std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = m_TractsToDwiFilter->GetVolumeFractions();
for (unsigned int k=0; k<volumeFractions.size(); k++)
{
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk(volumeFractions.at(k).GetPointer());
image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( image );
node->SetName(parameters.m_Misc.m_ParentNode->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
GetDataStorage()->Add(node, parameters.m_Misc.m_ParentNode);
}
}
m_TractsToDwiFilter = NULL;
break;
}
case 1:
{
statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
if (m_ArtifactsToDwiFilter->GetAbortGenerateData())
{
MITK_INFO << "Simulation aborted.";
return;
}
parameters = m_ArtifactsToDwiFilter->GetParameters().CopyParameters<double>();
- mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(parameters.m_Misc.m_ParentNode->GetData());
- mitkImage = mitk::DiffusionImage<short>::New();
- mitkImage->SetVectorImage( m_ArtifactsToDwiFilter->GetOutput() );
- mitkImage->SetReferenceBValue(diffImg->GetReferenceBValue());
- mitkImage->SetDirections(diffImg->GetDirections());
- mitkImage->InitializeFromVectorImage();
+ mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(parameters.m_Misc.m_ParentNode->GetData());
+ mitkImage = mitk::GrabItkImageMemory( m_ArtifactsToDwiFilter->GetOutput() );
+
+ mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+ mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
+ propertyHelper.InitializeImage();
+
parameters.m_Misc.m_ResultNode->SetData( mitkImage );
parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()+parameters.m_Misc.m_ArtifactModelString);
GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
m_ArtifactsToDwiFilter = NULL;
break;
}
}
mitk::BaseData::Pointer basedata = parameters.m_Misc.m_ResultNode->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if (!parameters.m_Misc.m_OutputPath.empty())
{
try{
QString outputFileName(parameters.m_Misc.m_OutputPath.c_str());
outputFileName += parameters.m_Misc.m_ResultNode->GetName().c_str();
outputFileName.replace(QString("."), QString("_"));
outputFileName += ".dwi";
QString status("Saving output image to ");
status += outputFileName;
m_Controls->m_SimulationStatusText->append(status);
mitk::IOUtil::SaveBaseData(mitkImage, outputFileName.toStdString());
m_Controls->m_SimulationStatusText->append("File saved successfully.");
}
catch (itk::ExceptionObject &e)
{
QString status("Exception during DWI writing: ");
status += e.GetDescription();
m_Controls->m_SimulationStatusText->append(status);
}
catch (...)
{
m_Controls->m_SimulationStatusText->append("Unknown exception during DWI writing!");
}
}
parameters.m_SignalGen.m_FrequencyMap = NULL;
}
void QmitkFiberfoxView::UpdateSimulationStatus()
{
QString statusText;
switch (m_Worker.m_FilterType)
{
case 0:
statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
break;
case 1:
statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
break;
}
if (QString::compare(m_SimulationStatusText,statusText)!=0)
{
m_Controls->m_SimulationStatusText->clear();
statusText = "<pre>"+statusText+"</pre>";
m_Controls->m_SimulationStatusText->setText(statusText);
QScrollBar *vScrollBar = m_Controls->m_SimulationStatusText->verticalScrollBar();
vScrollBar->triggerAction(QScrollBar::SliderToMaximum);
}
}
// Destructor
QmitkFiberfoxView::~QmitkFiberfoxView()
{
delete m_SimulationTimer;
}
void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberfoxViewControls;
m_Controls->setupUi( parent );
// commented out
m_Controls->m_DiffusionDirectionBox->setVisible(false);
m_Controls->label_3->setVisible(false);
m_Controls->m_SeparationAngleBox->setVisible(false);
m_Controls->label_4->setVisible(false);
//
m_Controls->m_StickWidget1->setVisible(true);
m_Controls->m_StickWidget2->setVisible(false);
m_Controls->m_ZeppelinWidget1->setVisible(false);
m_Controls->m_ZeppelinWidget2->setVisible(false);
m_Controls->m_TensorWidget1->setVisible(false);
m_Controls->m_TensorWidget2->setVisible(false);
m_Controls->m_BallWidget1->setVisible(true);
m_Controls->m_BallWidget2->setVisible(false);
m_Controls->m_AstrosticksWidget1->setVisible(false);
m_Controls->m_AstrosticksWidget2->setVisible(false);
m_Controls->m_DotWidget1->setVisible(false);
m_Controls->m_DotWidget2->setVisible(false);
m_Controls->m_PrototypeWidget1->setVisible(false);
m_Controls->m_PrototypeWidget2->setVisible(false);
m_Controls->m_PrototypeWidget3->setVisible(false);
m_Controls->m_PrototypeWidget4->setVisible(false);
m_Controls->m_PrototypeWidget3->SetMinFa(0.0);
m_Controls->m_PrototypeWidget3->SetMaxFa(0.15);
m_Controls->m_PrototypeWidget4->SetMinFa(0.0);
m_Controls->m_PrototypeWidget4->SetMaxFa(0.15);
m_Controls->m_PrototypeWidget3->SetMinAdc(0.0);
m_Controls->m_PrototypeWidget3->SetMaxAdc(0.001);
m_Controls->m_PrototypeWidget4->SetMinAdc(0.003);
m_Controls->m_PrototypeWidget4->SetMaxAdc(0.004);
m_Controls->m_Comp4FractionFrame->setVisible(false);
m_Controls->m_DiffusionPropsMessage->setVisible(false);
m_Controls->m_GeometryMessage->setVisible(false);
m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
m_Controls->m_VarianceBox->setVisible(false);
m_Controls->m_NoiseFrame->setVisible(false);
m_Controls->m_GhostFrame->setVisible(false);
m_Controls->m_DistortionsFrame->setVisible(false);
m_Controls->m_EddyFrame->setVisible(false);
m_Controls->m_SpikeFrame->setVisible(false);
m_Controls->m_AliasingFrame->setVisible(false);
m_Controls->m_MotionArtifactFrame->setVisible(false);
m_ParameterFile = QDir::currentPath()+"/param.ffp";
m_Controls->m_AbortSimulationButton->setVisible(false);
m_Controls->m_SimulationStatusText->setVisible(false);
m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
m_Controls->m_Comp4VolumeFraction->SetDataStorage(this->GetDataStorage());
m_Controls->m_MaskComboBox->SetDataStorage(this->GetDataStorage());
m_Controls->m_TemplateComboBox->SetDataStorage(this->GetDataStorage());
m_Controls->m_FiberBundleComboBox->SetDataStorage(this->GetDataStorage());
mitk::TNodePredicateDataType<mitk::FiberBundleX>::Pointer isFiberBundle = mitk::TNodePredicateDataType<mitk::FiberBundleX>::New();
mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
- mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
+ mitk::NodePredicateIsDWI::Pointer isDwi = mitk::NodePredicateIsDWI::New( );
mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
mitk::NodePredicateAnd::Pointer isNonDiffMitkImage = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateAnd::Pointer isBinaryMitkImage = mitk::NodePredicateAnd::New( isNonDiffMitkImage, isBinaryPredicate );
m_Controls->m_FrequencyMapBox->SetPredicate(isNonDiffMitkImage);
m_Controls->m_Comp4VolumeFraction->SetPredicate(isNonDiffMitkImage);
m_Controls->m_MaskComboBox->SetPredicate(isBinaryMitkImage);
m_Controls->m_MaskComboBox->SetZeroEntryText("--");
m_Controls->m_TemplateComboBox->SetPredicate(isMitkImage);
m_Controls->m_TemplateComboBox->SetZeroEntryText("--");
m_Controls->m_FiberBundleComboBox->SetPredicate(isFiberBundle);
m_Controls->m_FiberBundleComboBox->SetZeroEntryText("--");
// mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
connect( m_SimulationTimer, SIGNAL(timeout()), this, SLOT(UpdateSimulationStatus()) );
connect((QObject*) m_Controls->m_AbortSimulationButton, SIGNAL(clicked()), (QObject*) this, SLOT(KillThread()));
connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
connect((QObject*) m_Controls->m_AddSpikes, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddSpikes(int)));
connect((QObject*) m_Controls->m_AddAliasing, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddAliasing(int)));
connect((QObject*) m_Controls->m_AddMotion, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddMotion(int)));
connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
connect((QObject*) m_Controls->m_OutputPathButton, SIGNAL(clicked()), (QObject*) this, SLOT(SetOutputPath()));
connect((QObject*) m_Controls->m_MaskComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnMaskSelected(int)));
connect((QObject*) m_Controls->m_TemplateComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnTemplateSelected(int)));
connect((QObject*) m_Controls->m_FiberBundleComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnFibSelected(int)));
}
}
void QmitkFiberfoxView::OnMaskSelected(int value)
{
UpdateGui();
}
void QmitkFiberfoxView::OnTemplateSelected(int value)
{
UpdateGui();
}
void QmitkFiberfoxView::OnFibSelected(int value)
{
UpdateGui();
}
template< class ScalarType >
FiberfoxParameters< ScalarType > QmitkFiberfoxView::UpdateImageParameters()
{
FiberfoxParameters< ScalarType > parameters;
parameters.m_Misc.m_OutputPath = "";
parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
parameters.m_Misc.m_CheckAdvancedSignalOptionsBox = m_Controls->m_AdvancedOptionsBox_2->isChecked();
parameters.m_Misc.m_CheckOutputVolumeFractionsBox = m_Controls->m_VolumeFractionsBox->isChecked();
string outputPath = m_Controls->m_SavePathEdit->text().toStdString();
if (outputPath.compare("-")!=0)
{
parameters.m_Misc.m_OutputPath = outputPath;
parameters.m_Misc.m_OutputPath += "/";
}
if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull())
{
mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(m_Controls->m_MaskComboBox->GetSelectedNode()->GetData());
mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, parameters.m_SignalGen.m_MaskImage);
itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
duplicator->SetInputImage(parameters.m_SignalGen.m_MaskImage);
duplicator->Update();
parameters.m_SignalGen.m_MaskImage = duplicator->GetOutput();
}
- if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())) // use parameters of selected DWI
+ if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))) // use parameters of selected DWI
{
- mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
- parameters.m_SignalGen.m_ImageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
- parameters.m_SignalGen.m_ImageSpacing = dwi->GetVectorImage()->GetSpacing();
- parameters.m_SignalGen.m_ImageOrigin = dwi->GetVectorImage()->GetOrigin();
- parameters.m_SignalGen.m_ImageDirection = dwi->GetVectorImage()->GetDirection();
- parameters.m_SignalGen.m_Bvalue = dwi->GetReferenceBValue();
- parameters.m_SignalGen.SetGradienDirections(dwi->GetDirections());
+ mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
+ parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
+ parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
+ parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
+ parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
+ parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+ parameters.m_SignalGen.SetGradienDirections(static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
}
else if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull()) // use geometry of selected image
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
}
else // use GUI parameters
{
parameters.m_SignalGen.m_ImageRegion.SetSize(0, m_Controls->m_SizeX->value());
parameters.m_SignalGen.m_ImageRegion.SetSize(1, m_Controls->m_SizeY->value());
parameters.m_SignalGen.m_ImageRegion.SetSize(2, m_Controls->m_SizeZ->value());
parameters.m_SignalGen.m_ImageSpacing[0] = m_Controls->m_SpacingX->value();
parameters.m_SignalGen.m_ImageSpacing[1] = m_Controls->m_SpacingY->value();
parameters.m_SignalGen.m_ImageSpacing[2] = m_Controls->m_SpacingZ->value();
parameters.m_SignalGen.m_ImageOrigin[0] = parameters.m_SignalGen.m_ImageSpacing[0]/2;
parameters.m_SignalGen.m_ImageOrigin[1] = parameters.m_SignalGen.m_ImageSpacing[1]/2;
parameters.m_SignalGen.m_ImageOrigin[2] = parameters.m_SignalGen.m_ImageSpacing[2]/2;
parameters.m_SignalGen.m_ImageDirection.SetIdentity();
parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
parameters.m_SignalGen.GenerateGradientHalfShell();
}
// signal relaxation
parameters.m_SignalGen.m_DoSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
parameters.m_SignalGen.m_SimulateKspaceAcquisition = parameters.m_SignalGen.m_DoSimulateRelaxation;
if (parameters.m_SignalGen.m_DoSimulateRelaxation && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
parameters.m_Misc.m_ArtifactModelString += "_RELAX";
// N/2 ghosts
parameters.m_Misc.m_CheckAddGhostsBox = m_Controls->m_AddGhosts->isChecked();
if (m_Controls->m_AddGhosts->isChecked())
{
parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
parameters.m_Misc.m_ArtifactModelString += "_GHOST";
parameters.m_SignalGen.m_KspaceLineOffset = m_Controls->m_kOffsetBox->value();
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ghost", DoubleProperty::New(parameters.m_SignalGen.m_KspaceLineOffset));
}
else
parameters.m_SignalGen.m_KspaceLineOffset = 0;
// Aliasing
parameters.m_Misc.m_CheckAddAliasingBox = m_Controls->m_AddAliasing->isChecked();
if (m_Controls->m_AddAliasing->isChecked())
{
parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
parameters.m_Misc.m_ArtifactModelString += "_ALIASING";
parameters.m_SignalGen.m_CroppingFactor = (100-m_Controls->m_WrapBox->value())/100;
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Aliasing", DoubleProperty::New(m_Controls->m_WrapBox->value()));
}
// Spikes
parameters.m_Misc.m_CheckAddSpikesBox = m_Controls->m_AddSpikes->isChecked();
if (m_Controls->m_AddSpikes->isChecked())
{
parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
parameters.m_SignalGen.m_Spikes = m_Controls->m_SpikeNumBox->value();
parameters.m_SignalGen.m_SpikeAmplitude = m_Controls->m_SpikeScaleBox->value();
parameters.m_Misc.m_ArtifactModelString += "_SPIKES";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Number", IntProperty::New(parameters.m_SignalGen.m_Spikes));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Amplitude", DoubleProperty::New(parameters.m_SignalGen.m_SpikeAmplitude));
}
// gibbs ringing
parameters.m_SignalGen.m_DoAddGibbsRinging = m_Controls->m_AddGibbsRinging->isChecked();
if (m_Controls->m_AddGibbsRinging->isChecked())
{
parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ringing", BoolProperty::New(true));
parameters.m_Misc.m_ArtifactModelString += "_RINGING";
}
// add distortions
parameters.m_Misc.m_CheckAddDistortionsBox = m_Controls->m_AddDistortions->isChecked();
if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
{
mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
CastToItkImage< ItkDoubleImgType >(img, itkImg);
if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull()) // use geometry of frequency map
{
parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
}
if (parameters.m_SignalGen.m_ImageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
parameters.m_SignalGen.m_ImageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
parameters.m_SignalGen.m_ImageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
{
parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
itk::ImageDuplicator<ItkDoubleImgType>::Pointer duplicator = itk::ImageDuplicator<ItkDoubleImgType>::New();
duplicator->SetInputImage(itkImg);
duplicator->Update();
parameters.m_SignalGen.m_FrequencyMap = duplicator->GetOutput();
parameters.m_Misc.m_ArtifactModelString += "_DISTORTED";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Distortions", BoolProperty::New(true));
}
}
parameters.m_SignalGen.m_EddyStrength = 0;
parameters.m_Misc.m_CheckAddEddyCurrentsBox = m_Controls->m_AddEddy->isChecked();
if (m_Controls->m_AddEddy->isChecked())
{
parameters.m_SignalGen.m_EddyStrength = m_Controls->m_EddyGradientStrength->value();
parameters.m_Misc.m_ArtifactModelString += "_EDDY";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Eddy-strength", DoubleProperty::New(parameters.m_SignalGen.m_EddyStrength));
}
// Motion
parameters.m_SignalGen.m_DoAddMotion = m_Controls->m_AddMotion->isChecked();
parameters.m_SignalGen.m_DoRandomizeMotion = m_Controls->m_RandomMotion->isChecked();
parameters.m_SignalGen.m_Translation[0] = m_Controls->m_MaxTranslationBoxX->value();
parameters.m_SignalGen.m_Translation[1] = m_Controls->m_MaxTranslationBoxY->value();
parameters.m_SignalGen.m_Translation[2] = m_Controls->m_MaxTranslationBoxZ->value();
parameters.m_SignalGen.m_Rotation[0] = m_Controls->m_MaxRotationBoxX->value();
parameters.m_SignalGen.m_Rotation[1] = m_Controls->m_MaxRotationBoxY->value();
parameters.m_SignalGen.m_Rotation[2] = m_Controls->m_MaxRotationBoxZ->value();
if ( m_Controls->m_AddMotion->isChecked() && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
{
parameters.m_Misc.m_ArtifactModelString += "_MOTION";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Random", BoolProperty::New(parameters.m_SignalGen.m_DoRandomizeMotion));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-x", DoubleProperty::New(parameters.m_SignalGen.m_Translation[0]));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-y", DoubleProperty::New(parameters.m_SignalGen.m_Translation[1]));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-z", DoubleProperty::New(parameters.m_SignalGen.m_Translation[2]));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-x", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[0]));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-y", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[1]));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-z", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[2]));
}
// other imaging parameters
parameters.m_SignalGen.m_tLine = m_Controls->m_LineReadoutTimeBox->value();
parameters.m_SignalGen.m_tInhom = m_Controls->m_T2starBox->value();
parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
parameters.m_SignalGen.m_DoDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
parameters.m_SignalGen.m_AxonRadius = m_Controls->m_FiberRadius->value();
parameters.m_SignalGen.m_SignalScale = m_Controls->m_SignalScaleBox->value();
// adjust echo time if needed
if ( parameters.m_SignalGen.m_tEcho < parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine )
{
this->m_Controls->m_TEbox->setValue( parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine );
parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(parameters.m_SignalGen.m_tEcho)+" ms");
}
// Noise
parameters.m_Misc.m_CheckAddNoiseBox = m_Controls->m_AddNoise->isChecked();
if (m_Controls->m_AddNoise->isChecked())
{
double noiseVariance = m_Controls->m_NoiseLevel->value();
{
switch (m_Controls->m_NoiseDistributionBox->currentIndex())
{
case 0:
{
parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
break;
}
case 1:
{
parameters.m_NoiseModel = new mitk::ChiSquareNoiseModel<ScalarType>();
parameters.m_Misc.m_ArtifactModelString += "_CHISQUARED-";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Chi-squared"));
break;
}
default:
{
parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
}
}
}
parameters.m_NoiseModel->SetNoiseVariance(noiseVariance);
parameters.m_Misc.m_ArtifactModelString += QString::number(noiseVariance).toStdString();
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
}
// adjusting line readout time to the adapted image size needed for the DFT
unsigned int y = parameters.m_SignalGen.m_ImageRegion.GetSize(1);
y += y%2;
if ( y>parameters.m_SignalGen.m_ImageRegion.GetSize(1) )
parameters.m_SignalGen.m_tLine *= (double)parameters.m_SignalGen.m_ImageRegion.GetSize(1)/y;
// signal models
{
// compartment 1
switch (m_Controls->m_Compartment1Box->currentIndex())
{
case 0:
{
mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity(m_Controls->m_StickWidget1->GetD());
model->SetT2(m_Controls->m_StickWidget1->GetT2());
model->m_CompartmentId = 1;
parameters.m_FiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Stick";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 1:
{
mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
model->SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
model->SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
model->SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
model->m_CompartmentId = 1;
parameters.m_FiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Zeppelin";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 2:
{
mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
model->SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
model->SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
model->SetT2(m_Controls->m_TensorWidget1->GetT2());
model->m_CompartmentId = 1;
parameters.m_FiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Tensor";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 3:
{
mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
parameters.m_SignalGen.m_DoSimulateRelaxation = false;
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetMaxNumKernels(m_Controls->m_PrototypeWidget1->GetNumberOfSamples());
model->SetFaRange(m_Controls->m_PrototypeWidget1->GetMinFa(), m_Controls->m_PrototypeWidget1->GetMaxFa());
model->SetAdcRange(m_Controls->m_PrototypeWidget1->GetMinAdc(), m_Controls->m_PrototypeWidget1->GetMaxAdc());
model->m_CompartmentId = 1;
parameters.m_FiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Prototype";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Prototype") );
break;
}
}
// compartment 2
switch (m_Controls->m_Compartment2Box->currentIndex())
{
case 0:
break;
case 1:
{
mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity(m_Controls->m_StickWidget2->GetD());
model->SetT2(m_Controls->m_StickWidget2->GetT2());
model->m_CompartmentId = 2;
parameters.m_FiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Stick";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 2:
{
mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
model->SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
model->SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
model->SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
model->m_CompartmentId = 2;
parameters.m_FiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Zeppelin";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 3:
{
mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
model->SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
model->SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
model->SetT2(m_Controls->m_TensorWidget2->GetT2());
model->m_CompartmentId = 2;
parameters.m_FiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Tensor";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
break;
}
}
// compartment 3
switch (m_Controls->m_Compartment3Box->currentIndex())
{
case 0:
{
mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity(m_Controls->m_BallWidget1->GetD());
model->SetT2(m_Controls->m_BallWidget1->GetT2());
model->m_CompartmentId = 3;
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Ball";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 1:
{
mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
model->SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
model->m_CompartmentId = 3;
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Astrosticks";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
break;
}
case 2:
{
mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetT2(m_Controls->m_DotWidget1->GetT2());
model->m_CompartmentId = 3;
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Dot";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 3:
{
mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
parameters.m_SignalGen.m_DoSimulateRelaxation = false;
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetMaxNumKernels(m_Controls->m_PrototypeWidget3->GetNumberOfSamples());
model->SetFaRange(m_Controls->m_PrototypeWidget3->GetMinFa(), m_Controls->m_PrototypeWidget3->GetMaxFa());
model->SetAdcRange(m_Controls->m_PrototypeWidget3->GetMinAdc(), m_Controls->m_PrototypeWidget3->GetMaxAdc());
model->m_CompartmentId = 3;
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Prototype";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Prototype") );
break;
}
}
// compartment 4
ItkDoubleImgType::Pointer comp4VolumeImage = NULL;
ItkDoubleImgType::Pointer comp3VolumeImage = NULL;
if (m_Controls->m_Compartment4Box->currentIndex()>0)
{
mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp4VolumeFraction->GetSelectedNode();
if (volumeNode.IsNull())
{
QMessageBox::information( NULL, "Information", "No volume fraction image selected! Second extra-axonal compartment has been disabled for this simultation.");
MITK_WARN << "No volume fraction image selected! Second extra-axonal compartment has been disabled.";
}
else
{
MITK_INFO << "Rescaling volume fraction image...";
comp4VolumeImage = ItkDoubleImgType::New();
mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
CastToItkImage< ItkDoubleImgType >(img, comp4VolumeImage);
double max = itk::NumericTraits<double>::min();
double min = itk::NumericTraits<double>::max();
itk::ImageRegionIterator< ItkDoubleImgType > it(comp4VolumeImage, comp4VolumeImage->GetLargestPossibleRegion());
while(!it.IsAtEnd())
{
if (parameters.m_SignalGen.m_MaskImage.IsNotNull() && parameters.m_SignalGen.m_MaskImage->GetPixel(it.GetIndex())<=0)
{
it.Set(0.0);
++it;
continue;
}
if (it.Get()>900)
it.Set(900);
if (it.Get()>max)
max = it.Get();
if (it.Get()<min)
min = it.Get();
++it;
}
itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer scaler = itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
scaler->SetInput(comp4VolumeImage);
scaler->SetShift(-min);
scaler->SetScale(1.0/(max-min));
scaler->Update();
comp4VolumeImage = scaler->GetOutput();
// itk::ImageFileWriter< ItkDoubleImgType >::Pointer wr = itk::ImageFileWriter< ItkDoubleImgType >::New();
// wr->SetInput(comp4VolumeImage);
// wr->SetFileName("/local/comp4.nrrd");
// wr->Update();
// if (max>1 || min<0) // are volume fractions between 0 and 1?
// {
// itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::New();
// rescaler->SetInput(0, comp4VolumeImage);
// rescaler->SetOutputMaximum(1);
// rescaler->SetOutputMinimum(0);
// rescaler->Update();
// comp4VolumeImage = rescaler->GetOutput();
// }
itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer inverter = itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
inverter->SetMaximum(1.0);
inverter->SetInput(comp4VolumeImage);
inverter->Update();
comp3VolumeImage = inverter->GetOutput();
}
}
if (comp4VolumeImage.IsNotNull())
{
switch (m_Controls->m_Compartment4Box->currentIndex())
{
case 0:
break;
case 1:
{
mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity(m_Controls->m_BallWidget2->GetD());
model->SetT2(m_Controls->m_BallWidget2->GetT2());
model->SetVolumeFractionImage(comp4VolumeImage);
model->m_CompartmentId = 4;
parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Ball";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 2:
{
mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
model->SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
model->SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
model->SetVolumeFractionImage(comp4VolumeImage);
model->m_CompartmentId = 4;
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Astrosticks";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
break;
}
case 3:
{
mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetT2(m_Controls->m_DotWidget2->GetT2());
model->SetVolumeFractionImage(comp4VolumeImage);
model->m_CompartmentId = 4;
parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Dot";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
break;
}
case 4:
{
mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
parameters.m_SignalGen.m_DoSimulateRelaxation = false;
model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
model->SetMaxNumKernels(m_Controls->m_PrototypeWidget4->GetNumberOfSamples());
model->SetFaRange(m_Controls->m_PrototypeWidget4->GetMinFa(), m_Controls->m_PrototypeWidget4->GetMaxFa());
model->SetAdcRange(m_Controls->m_PrototypeWidget4->GetMinAdc(), m_Controls->m_PrototypeWidget4->GetMaxAdc());
model->SetVolumeFractionImage(comp4VolumeImage);
model->m_CompartmentId = 4;
parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
parameters.m_NonFiberModelList.push_back(model);
parameters.m_Misc.m_SignalModelString += "Prototype";
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Prototype") );
break;
}
}
}
}
parameters.m_SignalGen.m_FiberSeparationThreshold = m_Controls->m_SeparationAngleBox->value();
switch (m_Controls->m_DiffusionDirectionBox->currentIndex())
{
case 0:
parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
break;
case 1:
parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::MAIN_FIBER_DIRECTIONS;
break;
case 2:
parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::RANDOM_DIRECTIONS;
parameters.m_SignalGen.m_DoAddMotion = false;
parameters.m_SignalGen.m_DoAddGibbsRinging = false;
parameters.m_SignalGen.m_KspaceLineOffset = 0.0;
parameters.m_SignalGen.m_FrequencyMap = NULL;
parameters.m_SignalGen.m_CroppingFactor = 1.0;
parameters.m_SignalGen.m_EddyStrength = 0;
break;
default:
parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
}
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(parameters.m_SignalGen.m_SignalScale));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(parameters.m_SignalGen.m_AxonRadius));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tinhom", DoubleProperty::New(parameters.m_SignalGen.m_tInhom));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tline", DoubleProperty::New(parameters.m_SignalGen.m_tLine));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.TE", DoubleProperty::New(parameters.m_SignalGen.m_tEcho));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(parameters.m_SignalGen.m_Bvalue));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.NoPartialVolume", BoolProperty::New(parameters.m_SignalGen.m_DoDisablePartialVolume));
parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Relaxation", BoolProperty::New(parameters.m_SignalGen.m_DoSimulateRelaxation));
parameters.m_Misc.m_ResultNode->AddProperty("binary", BoolProperty::New(false));
parameters.m_Misc.m_CheckRealTimeFibersBox = m_Controls->m_RealTimeFibers->isChecked();
parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
parameters.m_Misc.m_CheckIncludeFiducialsBox = m_Controls->m_IncludeFiducials->isChecked();
parameters.m_Misc.m_CheckConstantRadiusBox = m_Controls->m_ConstantRadiusBox->isChecked();
switch(m_Controls->m_DistributionBox->currentIndex())
{
case 0:
parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
break;
case 1:
parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
break;
default:
parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
}
parameters.m_FiberGen.m_Variance = m_Controls->m_VarianceBox->value();
parameters.m_FiberGen.m_Density = m_Controls->m_FiberDensityBox->value();
parameters.m_FiberGen.m_Sampling = m_Controls->m_FiberSamplingBox->value();
parameters.m_FiberGen.m_Tension = m_Controls->m_TensionBox->value();
parameters.m_FiberGen.m_Continuity = m_Controls->m_ContinuityBox->value();
parameters.m_FiberGen.m_Bias = m_Controls->m_BiasBox->value();
parameters.m_FiberGen.m_Rotation[0] = m_Controls->m_XrotBox->value();
parameters.m_FiberGen.m_Rotation[1] = m_Controls->m_YrotBox->value();
parameters.m_FiberGen.m_Rotation[2] = m_Controls->m_ZrotBox->value();
parameters.m_FiberGen.m_Translation[0] = m_Controls->m_XtransBox->value();
parameters.m_FiberGen.m_Translation[1] = m_Controls->m_YtransBox->value();
parameters.m_FiberGen.m_Translation[2] = m_Controls->m_ZtransBox->value();
parameters.m_FiberGen.m_Scale[0] = m_Controls->m_XscaleBox->value();
parameters.m_FiberGen.m_Scale[1] = m_Controls->m_YscaleBox->value();
parameters.m_FiberGen.m_Scale[2] = m_Controls->m_ZscaleBox->value();
return parameters;
}
void QmitkFiberfoxView::SaveParameters()
{
FiberfoxParameters<> ffParamaters = UpdateImageParameters<double>();
QString filename = QFileDialog::getSaveFileName(
0,
tr("Save Parameters"),
m_ParameterFile,
tr("Fiberfox Parameters (*.ffp)") );
bool ok = true;
bool first = true;
bool dosampling = false;
- mitk::DiffusionImage<short>::Pointer diffImg = NULL;
+ mitk::Image::Pointer diffImg = NULL;
itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
const int shOrder = 2;
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
ItkDoubleImgType::Pointer adcImage = NULL;
for (unsigned int i=0; i<ffParamaters.m_FiberModelList.size()+ffParamaters.m_NonFiberModelList.size(); i++)
{
mitk::RawShModel<>* model = NULL;
if (i<ffParamaters.m_FiberModelList.size())
model = dynamic_cast< mitk::RawShModel<>* >(ffParamaters.m_FiberModelList.at(i));
else
model = dynamic_cast< mitk::RawShModel<>* >(ffParamaters.m_NonFiberModelList.at(i-ffParamaters.m_FiberModelList.size()));
if (model!=0 && model->GetNumberOfKernels()<=0)
{
if (first==true)
{
if (QMessageBox::question(NULL, "Prototype signal sampling", "Do you want to sample prototype signals from the selected diffusion-weighted imag and save them?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
dosampling = true;
first = false;
- if (dosampling && (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull() || !dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
+ if (dosampling && (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))))
{
QMessageBox::information(NULL, "Parameter file not saved", "No diffusion-weighted image selected to sample signal from.");
return;
}
else if (dosampling)
{
- diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
-
- typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
- TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
- filter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
- filter->SetBValue(diffImg->GetReferenceBValue());
- filter->Update();
- tensorImage = filter->GetOutput();
-
- const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
- QballFilterType::Pointer qballfilter = QballFilterType::New();
- qballfilter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
- qballfilter->SetBValue(diffImg->GetReferenceBValue());
- qballfilter->SetLambda(0.006);
- qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
- qballfilter->Update();
- itkFeatureImage = qballfilter->GetCoefficientImage();
-
- itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
- adcFilter->SetInput(diffImg->GetVectorImage());
- adcFilter->SetGradientDirections(diffImg->GetDirections());
- adcFilter->SetB_value(diffImg->GetReferenceBValue());
- adcFilter->Update();
- adcImage = adcFilter->GetOutput();
+ diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
+
+ typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
+ TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+ filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+
+ filter->Update();
+ tensorImage = filter->GetOutput();
+
+ const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
+ QballFilterType::Pointer qballfilter = QballFilterType::New();
+ qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ qballfilter->SetLambda(0.006);
+ qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
+ qballfilter->Update();
+ itkFeatureImage = qballfilter->GetCoefficientImage();
+
+ itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
+ adcFilter->SetInput( itkVectorImagePointer );
+ adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ adcFilter->Update();
+ adcImage = adcFilter->GetOutput();
}
}
if (dosampling && diffImg.IsNotNull())
{
ok = model->SampleKernels(diffImg, ffParamaters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
if (!ok)
{
QMessageBox::information( NULL, "Parameter file not saved", "No valid prototype signals could be sampled.");
return;
}
}
}
}
ffParamaters.SaveParameters(filename.toStdString());
m_ParameterFile = filename;
}
void QmitkFiberfoxView::LoadParameters()
{
QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QString(itksys::SystemTools::GetFilenamePath(m_ParameterFile.toStdString()).c_str()), tr("Fiberfox Parameters (*.ffp)") );
if(filename.isEmpty() || filename.isNull())
return;
m_ParameterFile = filename;
FiberfoxParameters<> parameters;
parameters.LoadParameters(filename.toStdString());
m_Controls->m_RealTimeFibers->setChecked(parameters.m_Misc.m_CheckRealTimeFibersBox);
m_Controls->m_AdvancedOptionsBox->setChecked(parameters.m_Misc.m_CheckAdvancedFiberOptionsBox);
m_Controls->m_IncludeFiducials->setChecked(parameters.m_Misc.m_CheckIncludeFiducialsBox);
m_Controls->m_ConstantRadiusBox->setChecked(parameters.m_Misc.m_CheckConstantRadiusBox);
m_Controls->m_DistributionBox->setCurrentIndex(parameters.m_FiberGen.m_Distribution);
m_Controls->m_VarianceBox->setValue(parameters.m_FiberGen.m_Variance);
m_Controls->m_FiberDensityBox->setValue(parameters.m_FiberGen.m_Density);
m_Controls->m_FiberSamplingBox->setValue(parameters.m_FiberGen.m_Sampling);
m_Controls->m_TensionBox->setValue(parameters.m_FiberGen.m_Tension);
m_Controls->m_ContinuityBox->setValue(parameters.m_FiberGen.m_Continuity);
m_Controls->m_BiasBox->setValue(parameters.m_FiberGen.m_Bias);
m_Controls->m_XrotBox->setValue(parameters.m_FiberGen.m_Rotation[0]);
m_Controls->m_YrotBox->setValue(parameters.m_FiberGen.m_Rotation[1]);
m_Controls->m_ZrotBox->setValue(parameters.m_FiberGen.m_Rotation[2]);
m_Controls->m_XtransBox->setValue(parameters.m_FiberGen.m_Translation[0]);
m_Controls->m_YtransBox->setValue(parameters.m_FiberGen.m_Translation[1]);
m_Controls->m_ZtransBox->setValue(parameters.m_FiberGen.m_Translation[2]);
m_Controls->m_XscaleBox->setValue(parameters.m_FiberGen.m_Scale[0]);
m_Controls->m_YscaleBox->setValue(parameters.m_FiberGen.m_Scale[1]);
m_Controls->m_ZscaleBox->setValue(parameters.m_FiberGen.m_Scale[2]);
// image generation parameters
m_Controls->m_SizeX->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(0));
m_Controls->m_SizeY->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(1));
m_Controls->m_SizeZ->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(2));
m_Controls->m_SpacingX->setValue(parameters.m_SignalGen.m_ImageSpacing[0]);
m_Controls->m_SpacingY->setValue(parameters.m_SignalGen.m_ImageSpacing[1]);
m_Controls->m_SpacingZ->setValue(parameters.m_SignalGen.m_ImageSpacing[2]);
m_Controls->m_NumGradientsBox->setValue(parameters.m_SignalGen.GetNumWeightedVolumes());
m_Controls->m_BvalueBox->setValue(parameters.m_SignalGen.m_Bvalue);
m_Controls->m_SignalScaleBox->setValue(parameters.m_SignalGen.m_SignalScale);
m_Controls->m_TEbox->setValue(parameters.m_SignalGen.m_tEcho);
m_Controls->m_LineReadoutTimeBox->setValue(parameters.m_SignalGen.m_tLine);
m_Controls->m_T2starBox->setValue(parameters.m_SignalGen.m_tInhom);
m_Controls->m_FiberRadius->setValue(parameters.m_SignalGen.m_AxonRadius);
m_Controls->m_RelaxationBox->setChecked(parameters.m_SignalGen.m_DoSimulateRelaxation);
m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(parameters.m_SignalGen.m_DoDisablePartialVolume);
if (parameters.m_NoiseModel!=NULL)
{
m_Controls->m_AddNoise->setChecked(parameters.m_Misc.m_CheckAddNoiseBox);
if (dynamic_cast<mitk::RicianNoiseModel<double>*>(parameters.m_NoiseModel))
m_Controls->m_NoiseDistributionBox->setCurrentIndex(0);
else if (dynamic_cast<mitk::ChiSquareNoiseModel<double>*>(parameters.m_NoiseModel))
m_Controls->m_NoiseDistributionBox->setCurrentIndex(1);
m_Controls->m_NoiseLevel->setValue(parameters.m_NoiseModel->GetNoiseVariance());
}
else
m_Controls->m_AddNoise->setChecked(false);
m_Controls->m_VolumeFractionsBox->setChecked(parameters.m_Misc.m_CheckOutputVolumeFractionsBox);
m_Controls->m_AdvancedOptionsBox_2->setChecked(parameters.m_Misc.m_CheckAdvancedSignalOptionsBox);
m_Controls->m_AddGhosts->setChecked(parameters.m_Misc.m_CheckAddGhostsBox);
m_Controls->m_AddAliasing->setChecked(parameters.m_Misc.m_CheckAddAliasingBox);
m_Controls->m_AddDistortions->setChecked(parameters.m_Misc.m_CheckAddDistortionsBox);
m_Controls->m_AddSpikes->setChecked(parameters.m_Misc.m_CheckAddSpikesBox);
m_Controls->m_AddEddy->setChecked(parameters.m_Misc.m_CheckAddEddyCurrentsBox);
m_Controls->m_kOffsetBox->setValue(parameters.m_SignalGen.m_KspaceLineOffset);
m_Controls->m_WrapBox->setValue(100*(1-parameters.m_SignalGen.m_CroppingFactor));
m_Controls->m_SpikeNumBox->setValue(parameters.m_SignalGen.m_Spikes);
m_Controls->m_SpikeScaleBox->setValue(parameters.m_SignalGen.m_SpikeAmplitude);
m_Controls->m_EddyGradientStrength->setValue(parameters.m_SignalGen.m_EddyStrength);
m_Controls->m_AddGibbsRinging->setChecked(parameters.m_SignalGen.m_DoAddGibbsRinging);
m_Controls->m_AddMotion->setChecked(parameters.m_SignalGen.m_DoAddMotion);
m_Controls->m_RandomMotion->setChecked(parameters.m_SignalGen.m_DoRandomizeMotion);
m_Controls->m_MaxTranslationBoxX->setValue(parameters.m_SignalGen.m_Translation[0]);
m_Controls->m_MaxTranslationBoxY->setValue(parameters.m_SignalGen.m_Translation[1]);
m_Controls->m_MaxTranslationBoxZ->setValue(parameters.m_SignalGen.m_Translation[2]);
m_Controls->m_MaxRotationBoxX->setValue(parameters.m_SignalGen.m_Rotation[0]);
m_Controls->m_MaxRotationBoxY->setValue(parameters.m_SignalGen.m_Rotation[1]);
m_Controls->m_MaxRotationBoxZ->setValue(parameters.m_SignalGen.m_Rotation[2]);
m_Controls->m_DiffusionDirectionBox->setCurrentIndex(parameters.m_SignalGen.m_DiffusionDirectionMode);
m_Controls->m_SeparationAngleBox->setValue(parameters.m_SignalGen.m_FiberSeparationThreshold);
m_Controls->m_Compartment1Box->setCurrentIndex(0);
m_Controls->m_Compartment2Box->setCurrentIndex(0);
m_Controls->m_Compartment3Box->setCurrentIndex(0);
m_Controls->m_Compartment4Box->setCurrentIndex(0);
for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
{
mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
if (i<parameters.m_FiberModelList.size())
signalModel = parameters.m_FiberModelList.at(i);
else
signalModel = parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size());
switch (signalModel->m_CompartmentId)
{
case 1:
{
if (dynamic_cast<mitk::StickModel<>*>(signalModel))
{
mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
m_Controls->m_StickWidget1->SetT2(model->GetT2());
m_Controls->m_StickWidget1->SetD(model->GetDiffusivity());
m_Controls->m_Compartment1Box->setCurrentIndex(0);
break;
}
else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
{
mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
m_Controls->m_TensorWidget1->SetT2(model->GetT2());
m_Controls->m_TensorWidget1->SetD1(model->GetDiffusivity1());
m_Controls->m_TensorWidget1->SetD2(model->GetDiffusivity2());
m_Controls->m_TensorWidget1->SetD3(model->GetDiffusivity3());
m_Controls->m_Compartment1Box->setCurrentIndex(2);
break;
}
else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
{
mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
m_Controls->m_PrototypeWidget1->SetNumberOfSamples(model->GetMaxNumKernels());
m_Controls->m_PrototypeWidget1->SetMinFa(model->GetFaRange().first);
m_Controls->m_PrototypeWidget1->SetMaxFa(model->GetFaRange().second);
m_Controls->m_PrototypeWidget1->SetMinAdc(model->GetAdcRange().first);
m_Controls->m_PrototypeWidget1->SetMaxAdc(model->GetAdcRange().second);
m_Controls->m_Compartment1Box->setCurrentIndex(3);
break;
}
break;
}
case 2:
{
if (dynamic_cast<mitk::StickModel<>*>(signalModel))
{
mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
m_Controls->m_StickWidget2->SetT2(model->GetT2());
m_Controls->m_StickWidget2->SetD(model->GetDiffusivity());
m_Controls->m_Compartment2Box->setCurrentIndex(1);
break;
}
else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
{
mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
m_Controls->m_TensorWidget2->SetT2(model->GetT2());
m_Controls->m_TensorWidget2->SetD1(model->GetDiffusivity1());
m_Controls->m_TensorWidget2->SetD2(model->GetDiffusivity2());
m_Controls->m_TensorWidget2->SetD3(model->GetDiffusivity3());
m_Controls->m_Compartment2Box->setCurrentIndex(3);
break;
}
break;
}
case 3:
{
if (dynamic_cast<mitk::BallModel<>*>(signalModel))
{
mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
m_Controls->m_BallWidget1->SetT2(model->GetT2());
m_Controls->m_BallWidget1->SetD(model->GetDiffusivity());
m_Controls->m_Compartment3Box->setCurrentIndex(0);
break;
}
else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
{
mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
m_Controls->m_AstrosticksWidget1->SetT2(model->GetT2());
m_Controls->m_AstrosticksWidget1->SetD(model->GetDiffusivity());
m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(model->GetRandomizeSticks());
m_Controls->m_Compartment3Box->setCurrentIndex(1);
break;
}
else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
{
mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
m_Controls->m_DotWidget1->SetT2(model->GetT2());
m_Controls->m_Compartment3Box->setCurrentIndex(2);
break;
}
else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
{
mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
m_Controls->m_PrototypeWidget3->SetNumberOfSamples(model->GetMaxNumKernels());
m_Controls->m_PrototypeWidget3->SetMinFa(model->GetFaRange().first);
m_Controls->m_PrototypeWidget3->SetMaxFa(model->GetFaRange().second);
m_Controls->m_PrototypeWidget3->SetMinAdc(model->GetAdcRange().first);
m_Controls->m_PrototypeWidget3->SetMaxAdc(model->GetAdcRange().second);
m_Controls->m_Compartment3Box->setCurrentIndex(3);
break;
}
break;
}
case 4:
{
if (dynamic_cast<mitk::BallModel<>*>(signalModel))
{
mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
m_Controls->m_BallWidget2->SetT2(model->GetT2());
m_Controls->m_BallWidget2->SetD(model->GetDiffusivity());
m_Controls->m_Compartment4Box->setCurrentIndex(1);
break;
}
else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
{
mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
m_Controls->m_AstrosticksWidget2->SetT2(model->GetT2());
m_Controls->m_AstrosticksWidget2->SetD(model->GetDiffusivity());
m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(model->GetRandomizeSticks());
m_Controls->m_Compartment4Box->setCurrentIndex(2);
break;
}
else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
{
mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
m_Controls->m_DotWidget2->SetT2(model->GetT2());
m_Controls->m_Compartment4Box->setCurrentIndex(3);
break;
}
else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
{
mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
m_Controls->m_PrototypeWidget4->SetNumberOfSamples(model->GetMaxNumKernels());
m_Controls->m_PrototypeWidget4->SetMinFa(model->GetFaRange().first);
m_Controls->m_PrototypeWidget4->SetMaxFa(model->GetFaRange().second);
m_Controls->m_PrototypeWidget4->SetMinAdc(model->GetAdcRange().first);
m_Controls->m_PrototypeWidget4->SetMaxAdc(model->GetAdcRange().second);
m_Controls->m_Compartment4Box->setCurrentIndex(4);
break;
}
break;
}
}
}
}
void QmitkFiberfoxView::ShowAdvancedOptions(int state)
{
if (state)
{
m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
m_Controls->m_AdvancedOptionsBox->setChecked(true);
m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
}
else
{
m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
m_Controls->m_AdvancedOptionsBox->setChecked(false);
m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
}
}
void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
{
m_Controls->m_StickWidget1->setVisible(false);
m_Controls->m_ZeppelinWidget1->setVisible(false);
m_Controls->m_TensorWidget1->setVisible(false);
m_Controls->m_PrototypeWidget1->setVisible(false);
switch (index)
{
case 0:
m_Controls->m_StickWidget1->setVisible(true);
break;
case 1:
m_Controls->m_ZeppelinWidget1->setVisible(true);
break;
case 2:
m_Controls->m_TensorWidget1->setVisible(true);
break;
case 3:
m_Controls->m_PrototypeWidget1->setVisible(true);
break;
}
}
void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
{
m_Controls->m_StickWidget2->setVisible(false);
m_Controls->m_ZeppelinWidget2->setVisible(false);
m_Controls->m_TensorWidget2->setVisible(false);
switch (index)
{
case 0:
break;
case 1:
m_Controls->m_StickWidget2->setVisible(true);
break;
case 2:
m_Controls->m_ZeppelinWidget2->setVisible(true);
break;
case 3:
m_Controls->m_TensorWidget2->setVisible(true);
break;
}
}
void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
{
m_Controls->m_BallWidget1->setVisible(false);
m_Controls->m_AstrosticksWidget1->setVisible(false);
m_Controls->m_DotWidget1->setVisible(false);
m_Controls->m_PrototypeWidget3->setVisible(false);
switch (index)
{
case 0:
m_Controls->m_BallWidget1->setVisible(true);
break;
case 1:
m_Controls->m_AstrosticksWidget1->setVisible(true);
break;
case 2:
m_Controls->m_DotWidget1->setVisible(true);
break;
case 3:
m_Controls->m_PrototypeWidget3->setVisible(true);
break;
}
}
void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
{
m_Controls->m_BallWidget2->setVisible(false);
m_Controls->m_AstrosticksWidget2->setVisible(false);
m_Controls->m_DotWidget2->setVisible(false);
m_Controls->m_PrototypeWidget4->setVisible(false);
m_Controls->m_Comp4FractionFrame->setVisible(false);
switch (index)
{
case 0:
break;
case 1:
m_Controls->m_BallWidget2->setVisible(true);
m_Controls->m_Comp4FractionFrame->setVisible(true);
break;
case 2:
m_Controls->m_AstrosticksWidget2->setVisible(true);
m_Controls->m_Comp4FractionFrame->setVisible(true);
break;
case 3:
m_Controls->m_DotWidget2->setVisible(true);
m_Controls->m_Comp4FractionFrame->setVisible(true);
break;
case 4:
m_Controls->m_PrototypeWidget4->setVisible(true);
m_Controls->m_Comp4FractionFrame->setVisible(true);
break;
}
}
void QmitkFiberfoxView::OnConstantRadius(int value)
{
if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnAddMotion(int value)
{
if (value>0)
m_Controls->m_MotionArtifactFrame->setVisible(true);
else
m_Controls->m_MotionArtifactFrame->setVisible(false);
}
void QmitkFiberfoxView::OnAddAliasing(int value)
{
if (value>0)
m_Controls->m_AliasingFrame->setVisible(true);
else
m_Controls->m_AliasingFrame->setVisible(false);
}
void QmitkFiberfoxView::OnAddSpikes(int value)
{
if (value>0)
m_Controls->m_SpikeFrame->setVisible(true);
else
m_Controls->m_SpikeFrame->setVisible(false);
}
void QmitkFiberfoxView::OnAddEddy(int value)
{
if (value>0)
m_Controls->m_EddyFrame->setVisible(true);
else
m_Controls->m_EddyFrame->setVisible(false);
}
void QmitkFiberfoxView::OnAddDistortions(int value)
{
if (value>0)
m_Controls->m_DistortionsFrame->setVisible(true);
else
m_Controls->m_DistortionsFrame->setVisible(false);
}
void QmitkFiberfoxView::OnAddGhosts(int value)
{
if (value>0)
m_Controls->m_GhostFrame->setVisible(true);
else
m_Controls->m_GhostFrame->setVisible(false);
}
void QmitkFiberfoxView::OnAddNoise(int value)
{
if (value>0)
m_Controls->m_NoiseFrame->setVisible(true);
else
m_Controls->m_NoiseFrame->setVisible(false);
}
void QmitkFiberfoxView::OnDistributionChanged(int value)
{
if (value==1)
m_Controls->m_VarianceBox->setVisible(true);
else
m_Controls->m_VarianceBox->setVisible(false);
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnVarianceChanged(double)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFiberDensityChanged(int)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFiberSamplingChanged(double)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnTensionChanged(double)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnContinuityChanged(double)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnBiasChanged(double)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::AlignOnGrid()
{
for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
{
mitk::DataNode::Pointer pFibNode = *it;
if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
{
mitk::DataNode::Pointer pImgNode = *it2;
if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
mitk::BaseGeometry::Pointer geom = img->GetGeometry();
itk::Index<3> idx;
geom->WorldToIndex(wc0, idx);
mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
mitk::Point3D world;
geom->IndexToWorld(cIdx,world);
mitk::Vector3D trans = world - wc0;
pe->GetGeometry()->Translate(trans);
break;
}
}
break;
}
}
}
for(unsigned int i=0; i<m_SelectedBundles2.size(); i++ )
{
mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
{
mitk::DataNode::Pointer imgNode = *it;
if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
mitk::BaseGeometry::Pointer geom = img->GetGeometry();
itk::Index<3> idx;
geom->WorldToIndex(wc0, idx);
mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
mitk::Point3D world;
geom->IndexToWorld(cIdx,world);
mitk::Vector3D trans = world - wc0;
pe->GetGeometry()->Translate(trans);
}
}
break;
}
}
}
for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
{
mitk::DataNode::Pointer fibNode = *it;
if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::BaseGeometry::Pointer geom = img->GetGeometry();
itk::Index<3> idx;
geom->WorldToIndex(wc0, idx);
mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
mitk::Point3D world;
geom->IndexToWorld(cIdx,world);
mitk::Vector3D trans = world - wc0;
pe->GetGeometry()->Translate(trans);
}
}
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFlipButton()
{
if (m_SelectedFiducial.IsNull())
return;
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
if( it != m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
data.m_Flipped += 1;
data.m_Flipped %= 2;
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
{
NPoints *= 2;
GradientListType pointshell;
int numB0 = NPoints/20;
if (numB0==0)
numB0=1;
GradientType g;
g.Fill(0.0);
for (int i=0; i<numB0; i++)
pointshell.push_back(g);
if (NPoints==0)
return pointshell;
vnl_vector<double> theta; theta.set_size(NPoints);
vnl_vector<double> phi; phi.set_size(NPoints);
double C = sqrt(4*M_PI);
phi(0) = 0.0;
phi(NPoints-1) = 0.0;
for(int i=0; i<NPoints; i++)
{
theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
if( i>0 && i<NPoints-1)
{
phi(i) = (phi(i-1) + C /
sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
// % (2*DIST_POINTSHELL_PI);
}
}
for(int i=0; i<NPoints; i++)
{
g[2] = sin(theta(i));
if (g[2]<0)
continue;
g[0] = cos(theta(i)) * cos(phi(i));
g[1] = cos(theta(i)) * sin(phi(i));
pointshell.push_back(g);
}
return pointshell;
}
template<int ndirs>
std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
{
std::vector<itk::Vector<double,3> > retval;
vnl_matrix_fixed<double, 3, ndirs>* U =
itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
// Add 0 vector for B0
int numB0 = ndirs/10;
if (numB0==0)
numB0=1;
itk::Vector<double,3> v;
v.Fill(0.0);
for (int i=0; i<numB0; i++)
{
retval.push_back(v);
}
for(int i=0; i<ndirs;i++)
{
itk::Vector<double,3> v;
v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
retval.push_back(v);
}
return retval;
}
void QmitkFiberfoxView::OnAddBundle()
{
if (m_SelectedImage.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( bundle );
QString name = QString("Bundle_%1").arg(children->size());
node->SetName(name.toStdString());
m_SelectedBundles.push_back(node);
UpdateGui();
GetDataStorage()->Add(node, m_SelectedImage);
}
void QmitkFiberfoxView::OnDrawROI()
{
if (m_SelectedBundles.empty())
OnAddBundle();
if (m_SelectedBundles.empty())
return;
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( figure );
node->SetBoolProperty("planarfigure.3drendering", true);
QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
for( int i=0; i<nodes.size(); i++)
nodes.at(i)->SetSelected(false);
m_SelectedFiducial = node;
QString name = QString("Fiducial_%1").arg(children->size());
node->SetName(name.toStdString());
node->SetSelected(true);
this->DisableCrosshairNavigation();
mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New();
us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode( node );
}
UpdateGui();
GetDataStorage()->Add(node, m_SelectedBundles.at(0));
}
bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
{
int li = -1;
i->GetPropertyValue("layer", li);
int lj = -1;
j->GetPropertyValue("layer", lj);
return li<lj;
}
void QmitkFiberfoxView::GenerateFibers()
{
if (m_SelectedBundles.empty())
{
if (m_SelectedFiducial.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
m_SelectedBundles.push_back(*it);
if (m_SelectedBundles.empty())
return;
}
FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
for (unsigned int i=0; i<m_SelectedBundles.size(); i++)
{
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
std::vector< mitk::DataNode::Pointer > childVector;
for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
childVector.push_back(*it);
sort(childVector.begin(), childVector.end(), CompareLayer);
vector< mitk::PlanarEllipse::Pointer > fib;
vector< unsigned int > flip;
float radius = 1;
int count = 0;
for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
{
mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
if (m_Controls->m_ConstantRadiusBox->isChecked())
{
ellipse->SetTreatAsCircle(true);
mitk::Point2D c = ellipse->GetControlPoint(0);
mitk::Point2D p = ellipse->GetControlPoint(1);
mitk::Vector2D v = p-c;
if (count==0)
{
radius = v.GetVnlVector().magnitude();
ellipse->SetControlPoint(1, p);
ellipse->Modified();
}
else
{
v.Normalize();
v *= radius;
ellipse->SetControlPoint(1, c+v);
ellipse->Modified();
}
}
fib.push_back(ellipse);
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
if( it != m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
flip.push_back(data.m_Flipped);
}
else
flip.push_back(0);
}
count++;
}
if (fib.size()>1)
{
parameters.m_FiberGen.m_Fiducials.push_back(fib);
parameters.m_FiberGen.m_FlipList.push_back(flip);
}
else if (fib.size()>0)
m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
filter->SetParameters(parameters.m_FiberGen);
filter->Update();
vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
for (unsigned int i=0; i<fiberBundles.size(); i++)
{
m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
if (fiberBundles.at(i)->GetNumFibers()>50000)
m_SelectedBundles.at(i)->SetVisibility(false);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::GenerateImage()
{
if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNull() && m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull())
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
m_Controls->m_SizeX->value(),
m_Controls->m_SizeY->value(),
m_Controls->m_SizeZ->value(),
m_Controls->m_SpacingX->value(),
m_Controls->m_SpacingY->value(),
m_Controls->m_SpacingZ->value());
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( image );
node->SetName("Dummy");
unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
unsigned int level = window/2;
mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
GetDataStorage()->Add(node);
m_SelectedImage = node;
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
UpdateGui();
}
else if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull())
SimulateImageFromFibers(m_Controls->m_FiberBundleComboBox->GetSelectedNode());
else if ( m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() )
SimulateForExistingDwi(m_Controls->m_TemplateComboBox->GetSelectedNode());
}
void QmitkFiberfoxView::SimulateForExistingDwi(mitk::DataNode* imageNode)
{
- if (!dynamic_cast<mitk::DiffusionImage<short>*>(imageNode->GetData()))
- return;
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(imageNode->GetData())) );
+ if ( !isDiffusionImage )
+ {
+ return;
+ }
FiberfoxParameters<short> parameters = UpdateImageParameters<short>();
if (parameters.m_NoiseModel==NULL &&
parameters.m_SignalGen.m_Spikes==0 &&
parameters.m_SignalGen.m_FrequencyMap.IsNull() &&
parameters.m_SignalGen.m_KspaceLineOffset<=0.000001 &&
!parameters.m_SignalGen.m_DoAddGibbsRinging &&
!(parameters.m_SignalGen.m_EddyStrength>0) &&
parameters.m_SignalGen.m_CroppingFactor>0.999)
{
QMessageBox::information( NULL, "Simulation cancelled", "No valid artifact enabled! Motion artifacts and relaxation effects can NOT be added to an existing diffusion weighted image.");
return;
}
- mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(imageNode->GetData());
+ mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(imageNode->GetData());
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+
m_ArtifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
- m_ArtifactsToDwiFilter->SetInput(diffImg->GetVectorImage());
+ m_ArtifactsToDwiFilter->SetInput(itkVectorImagePointer);
parameters.m_Misc.m_ParentNode = imageNode;
m_ArtifactsToDwiFilter->SetParameters(parameters);
m_Worker.m_FilterType = 1;
m_Thread.start(QThread::LowestPriority);
}
void QmitkFiberfoxView::SimulateImageFromFibers(mitk::DataNode* fiberNode)
{
mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(fiberNode->GetData());
if (fiberBundle->GetNumFibers()<=0)
return;
FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
m_TractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
parameters.m_Misc.m_ParentNode = fiberNode;
- if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))
+ if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
{
bool first = true;
bool ok = true;
- mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
+ mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
const int shOrder = 2;
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
ItkDoubleImgType::Pointer adcImage = NULL;
for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
{
mitk::RawShModel<>* model = NULL;
if (i<parameters.m_FiberModelList.size())
model = dynamic_cast< mitk::RawShModel<>* >(parameters.m_FiberModelList.at(i));
else
model = dynamic_cast< mitk::RawShModel<>* >(parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size()));
if (model!=0 && model->GetNumberOfKernels()<=0)
{
if (first==true)
{
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+
typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
- filter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
- filter->SetBValue(diffImg->GetReferenceBValue());
+ filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
filter->Update();
tensorImage = filter->GetOutput();
const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
QballFilterType::Pointer qballfilter = QballFilterType::New();
- qballfilter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
- qballfilter->SetBValue(diffImg->GetReferenceBValue());
+ qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
qballfilter->SetLambda(0.006);
qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
qballfilter->Update();
itkFeatureImage = qballfilter->GetCoefficientImage();
itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
- adcFilter->SetInput(diffImg->GetVectorImage());
- adcFilter->SetGradientDirections(diffImg->GetDirections());
- adcFilter->SetB_value(diffImg->GetReferenceBValue());
+ adcFilter->SetInput( itkVectorImagePointer );
+ adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
adcFilter->Update();
adcImage = adcFilter->GetOutput();
}
ok = model->SampleKernels(diffImg, parameters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
if (!ok)
break;
}
}
if (!ok)
{
QMessageBox::information( NULL, "Simulation cancelled", "No valid prototype signals could be sampled.");
return;
}
}
else if ( m_Controls->m_Compartment1Box->currentIndex()==3 || m_Controls->m_Compartment3Box->currentIndex()==3 || m_Controls->m_Compartment4Box->currentIndex()==4 )
{
QMessageBox::information( NULL, "Simulation cancelled", "Prototype signal but no diffusion-weighted image selected to sample signal from.");
return;
}
m_TractsToDwiFilter->SetParameters(parameters);
m_TractsToDwiFilter->SetFiberBundle(fiberBundle);
m_Worker.m_FilterType = 0;
m_Thread.start(QThread::LowestPriority);
}
void QmitkFiberfoxView::ApplyTransform()
{
vector< mitk::DataNode::Pointer > selectedBundles;
for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
{
mitk::DataNode::Pointer fibNode = *it;
if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
selectedBundles.push_back(fibNode);
}
}
if (selectedBundles.empty())
selectedBundles = m_SelectedBundles2;
if (!selectedBundles.empty())
{
for (std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin(); it!=selectedBundles.end(); ++it)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
// handle child fiducials
if (m_Controls->m_IncludeFiducials->isChecked())
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::BaseGeometry* geom = pe->GetGeometry();
// translate
mitk::Vector3D world;
world[0] = m_Controls->m_XtransBox->value();
world[1] = m_Controls->m_YtransBox->value();
world[2] = m_Controls->m_ZtransBox->value();
geom->Translate(world);
// calculate rotation matrix
double x = m_Controls->m_XrotBox->value()*M_PI/180;
double y = m_Controls->m_YrotBox->value()*M_PI/180;
double z = m_Controls->m_ZrotBox->value()*M_PI/180;
itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
rotX[1][1] = cos(x);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(x);
rotX[2][1] = -rotX[1][2];
itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
rotY[0][0] = cos(y);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(y);
rotY[2][0] = -rotY[0][2];
itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
rotZ[0][0] = cos(z);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(z);
rotZ[1][0] = -rotZ[0][1];
itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
// transform control point coordinate into geometry translation
geom->SetOrigin(pe->GetWorldControlPoint(0));
mitk::Point2D cp; cp.Fill(0.0);
pe->SetControlPoint(0, cp);
// rotate fiducial
geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
// implicit translation
mitk::Vector3D trans;
trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
mitk::Vector3D newWc = rot*trans;
newWc = newWc-trans;
geom->Translate(newWc);
pe->Modified();
}
}
}
}
}
else
{
for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
{
mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
mitk::BaseGeometry* geom = pe->GetGeometry();
// translate
mitk::Vector3D world;
world[0] = m_Controls->m_XtransBox->value();
world[1] = m_Controls->m_YtransBox->value();
world[2] = m_Controls->m_ZtransBox->value();
geom->Translate(world);
// calculate rotation matrix
double x = m_Controls->m_XrotBox->value()*M_PI/180;
double y = m_Controls->m_YrotBox->value()*M_PI/180;
double z = m_Controls->m_ZrotBox->value()*M_PI/180;
itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
rotX[1][1] = cos(x);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(x);
rotX[2][1] = -rotX[1][2];
itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
rotY[0][0] = cos(y);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(y);
rotY[2][0] = -rotY[0][2];
itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
rotZ[0][0] = cos(z);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(z);
rotZ[1][0] = -rotZ[0][1];
itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
// transform control point coordinate into geometry translation
geom->SetOrigin(pe->GetWorldControlPoint(0));
mitk::Point2D cp; cp.Fill(0.0);
pe->SetControlPoint(0, cp);
// rotate fiducial
geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
pe->Modified();
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::CopyBundles()
{
if ( m_SelectedBundles.size()<1 ){
QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
MITK_WARN("QmitkFiberFoxView") << "Select at least one fiber bundle!";
return;
}
for (std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin(); it!=m_SelectedBundles.end(); ++it)
{
// find parent image
mitk::DataNode::Pointer parentNode;
mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
{
mitk::DataNode::Pointer pImgNode = *it2;
if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
{
parentNode = pImgNode;
break;
}
}
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
QString name((*it)->GetName().c_str());
name += "_copy";
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
if (parentNode.IsNotNull())
GetDataStorage()->Add(fbNode, parentNode);
else
GetDataStorage()->Add(fbNode);
// copy child fiducials
if (m_Controls->m_IncludeFiducials->isChecked())
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData())->Clone();
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData(pe);
newNode->SetName(fiducialNode->GetName());
newNode->SetBoolProperty("planarfigure.3drendering", true);
GetDataStorage()->Add(newNode, fbNode);
}
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::JoinBundles()
{
if ( m_SelectedBundles.size()<2 ){
QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
MITK_WARN("QmitkFiberFoxView") << "Select at least two fiber bundles!";
return;
}
std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
QString name("");
name += QString((*it)->GetName().c_str());
++it;
for (; it!=m_SelectedBundles.end(); ++it)
{
newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
name += "+"+QString((*it)->GetName().c_str());
}
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::UpdateGui()
{
m_Controls->m_GeometryFrame->setEnabled(true);
m_Controls->m_GeometryMessage->setVisible(false);
m_Controls->m_DiffusionPropsMessage->setVisible(false);
m_Controls->m_FiberGenMessage->setVisible(true);
m_Controls->m_TransformBundlesButton->setEnabled(false);
m_Controls->m_CopyBundlesButton->setEnabled(false);
m_Controls->m_GenerateFibersButton->setEnabled(false);
m_Controls->m_FlipButton->setEnabled(false);
m_Controls->m_CircleButton->setEnabled(false);
m_Controls->m_BvalueBox->setEnabled(true);
m_Controls->m_NumGradientsBox->setEnabled(true);
m_Controls->m_JoinBundlesButton->setEnabled(false);
m_Controls->m_AlignOnGrid->setEnabled(false);
// Fiber generation gui
if (m_SelectedFiducial.IsNotNull())
{
m_Controls->m_TransformBundlesButton->setEnabled(true);
m_Controls->m_FlipButton->setEnabled(true);
m_Controls->m_AlignOnGrid->setEnabled(true);
}
if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
{
m_Controls->m_CircleButton->setEnabled(true);
m_Controls->m_FiberGenMessage->setVisible(false);
}
if (m_SelectedImage.IsNotNull() && !m_SelectedBundles.empty())
m_Controls->m_AlignOnGrid->setEnabled(true);
if (!m_SelectedBundles.empty())
{
m_Controls->m_TransformBundlesButton->setEnabled(true);
m_Controls->m_CopyBundlesButton->setEnabled(true);
m_Controls->m_GenerateFibersButton->setEnabled(true);
if (m_SelectedBundles.size()>1)
m_Controls->m_JoinBundlesButton->setEnabled(true);
}
// Signal generation gui
if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull() || m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())
{
m_Controls->m_GeometryMessage->setVisible(true);
m_Controls->m_GeometryFrame->setEnabled(false);
}
- if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))
+ if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
{
m_Controls->m_DiffusionPropsMessage->setVisible(true);
m_Controls->m_BvalueBox->setEnabled(false);
m_Controls->m_NumGradientsBox->setEnabled(false);
m_Controls->m_GeometryMessage->setVisible(true);
m_Controls->m_GeometryFrame->setEnabled(false);
}
}
void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
{
m_SelectedBundles2.clear();
m_SelectedImages.clear();
m_SelectedFiducials.clear();
m_SelectedFiducial = NULL;
m_SelectedBundles.clear();
m_SelectedImage = NULL;
// iterate all selected objects, adjust warning visibility
for( int i=0; i<nodes.size(); i++)
{
mitk::DataNode::Pointer node = nodes.at(i);
+// bool isDiffusionImage(false);
+// if ( node.IsNotNull() )
+// {
+// isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
+// }
+
+// if ( node.IsNotNull() && isDiffusionImage )
+// {
+// m_SelectedDWI = node;
+// m_SelectedImage = node;
+// m_SelectedImages.push_back(node);
+// }
+
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
m_SelectedImages.push_back(node);
m_SelectedImage = node;
}
else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
m_SelectedBundles2.push_back(node);
if (m_Controls->m_RealTimeFibers->isChecked())
{
m_SelectedBundles.push_back(node);
mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
GenerateFibers();
}
else
m_SelectedBundles.push_back(node);
}
else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
{
m_SelectedFiducials.push_back(node);
m_SelectedFiducial = node;
m_SelectedBundles.clear();
mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
{
mitk::DataNode::Pointer pNode = *it;
if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
m_SelectedBundles.push_back(pNode);
}
}
}
UpdateGui();
}
void QmitkFiberfoxView::EnableCrosshairNavigation()
{
MITK_DEBUG << "EnableCrosshairNavigation";
// enable the crosshair navigation
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MITK_DEBUG << "enabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(true);
// linkedRenderWindow->EnableSlicingPlanes(true);
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::DisableCrosshairNavigation()
{
MITK_DEBUG << "DisableCrosshairNavigation";
// disable the crosshair navigation during the drawing
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MITK_DEBUG << "disabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(false);
// linkedRenderWindow->EnableSlicingPlanes(false);
}
}
void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
{
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
if (dynamic_cast<FiberBundleX*>(node->GetData()))
{
m_SelectedBundles.clear();
m_SelectedBundles2.clear();
}
else if (dynamic_cast<Image*>(node->GetData()))
m_SelectedImages.clear();
if( it != m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
// remove observers
data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
m_DataNodeToPlanarFigureData.erase( it );
}
}
void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
{
// add observer for selection in renderwindow
mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
bool isPositionMarker (false);
node->GetBoolProperty("isContourMarker", isPositionMarker);
if( figure && !isPositionMarker )
{
MITK_DEBUG << "figure added. will add interactor if needed.";
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New();
us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode( nonConstNode );
}
MITK_DEBUG << "will now add observers for planarfigure";
QmitkPlanarFigureData data;
data.m_Figure = figure;
// // add observer for event when figure has been placed
typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
// SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
// initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
// data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
// add observer for event when figure is picked (selected)
typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
MemberCommandType::Pointer selectCommand = MemberCommandType::New();
selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
// add observer for event when interaction with figure starts
SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
// add observer for event when interaction with figure starts
SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
m_DataNodeToPlanarFigureData[nonConstNode] = data;
}
}
void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
{
mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
{
mitk::DataNode* node = *it;
if( node->GetData() == object )
{
node->SetSelected(true);
m_SelectedFiducial = node;
}
else
node->SetSelected(false);
}
UpdateGui();
this->RequestRenderWindowUpdate();
}
void QmitkFiberfoxView::SetFocus()
{
m_Controls->m_CircleButton->setFocus();
}
void QmitkFiberfoxView::SetOutputPath()
{
// SELECT FOLDER DIALOG
string outputPath = QFileDialog::getExistingDirectory(NULL, "Save images to...", QString(outputPath.c_str())).toStdString();
if (outputPath.empty())
m_Controls->m_SavePathEdit->setText("-");
else
{
outputPath += "/";
m_Controls->m_SavePathEdit->setText(QString(outputPath.c_str()));
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
index a4e48967ec..edff70dd72 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
@@ -1,210 +1,214 @@
/*===================================================================
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 <berryISelectionListener.h>
#include <berryIStructuredSelection.h>
#include <QmitkAbstractView.h>
#include "ui_QmitkFiberfoxViewControls.h"
#include <itkVectorImage.h>
#include <itkVectorContainer.h>
#include <itkOrientationDistributionFunction.h>
#include <mitkFiberBundleX.h>
#include <mitkPlanarEllipse.h>
#include <mitkDiffusionNoiseModel.h>
#include <mitkDiffusionSignalModel.h>
#include <mitkRicianNoiseModel.h>
#include <itkTractsToDWIImageFilter.h>
#include <itkAddArtifactsToDwiImageFilter.h>
#include <mitkTensorModel.h>
#include <mitkBallModel.h>
#include <mitkStickModel.h>
#include <mitkAstroStickModel.h>
#include <mitkDotModel.h>
#include <QThread>
#include <QObject>
#include <QTimer>
#include <QTime>
#include <mitkFiberfoxParameters.h>
#include <itkStatisticsImageFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
/*!
\brief View for fiber based diffusion software phantoms (Fiberfox). See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
\sa QmitkFunctionality
\ingroup Functionalities
*/
// Forward Qt class declarations
using namespace std;
class QmitkFiberfoxView;
class QmitkFiberfoxWorker : public QObject
{
Q_OBJECT
public:
QmitkFiberfoxWorker(QmitkFiberfoxView* view);
int m_FilterType;
public slots:
void run();
private:
QmitkFiberfoxView* m_View;
};
class QmitkFiberfoxView : public QmitkAbstractView
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const string VIEW_ID;
QmitkFiberfoxView();
virtual ~QmitkFiberfoxView();
virtual void CreateQtPartControl(QWidget *parent);
void SetFocus();
- typedef itk::Image<double, 3> ItkDoubleImgType;
- typedef itk::Image<unsigned char, 3> ItkUcharImgType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
typedef itk::Vector<double,3> GradientType;
typedef vector<GradientType> GradientListType;
+ typedef itk::VectorImage< short, 3 > ItkDwiType;
+ typedef itk::Image<double, 3> ItkDoubleImgType;
+ typedef itk::Image<unsigned char, 3> ItkUcharImgType;
template<int ndirs> vector<itk::Vector<double,3> > MakeGradientList();
protected slots:
void SetOutputPath(); ///< path where image is automatically saved to after the simulation is finished
void LoadParameters(); ///< load fiberfox parameters
void SaveParameters(); ///< save fiberfox parameters
void BeforeThread();
void AfterThread();
void KillThread(); ///< abort simulation
void UpdateSimulationStatus(); ///< print simulation progress and satus messages
void OnDrawROI(); ///< adds new ROI, handles interactors etc.
void OnAddBundle(); ///< adds new fiber bundle to datastorage
void OnFlipButton(); ///< negate one coordinate of the fiber waypoints in the selcted planar figure. needed in case of unresolvable twists
void GenerateFibers(); ///< generate fibers from the selected ROIs
void GenerateImage(); ///< start image simulation
void JoinBundles(); ///< merges selcted fiber bundles into one
void CopyBundles(); ///< add copy of the selected bundle to the datamanager
void ApplyTransform(); ///< rotate and shift selected bundles
void AlignOnGrid(); ///< shift selected fiducials to nearest voxel center
void Comp1ModelFrameVisibility(int index); ///< only show parameters of selected signal model for compartment 1
void Comp2ModelFrameVisibility(int index); ///< only show parameters of selected signal model for compartment 2
void Comp3ModelFrameVisibility(int index); ///< only show parameters of selected signal model for compartment 3
void Comp4ModelFrameVisibility(int index); ///< only show parameters of selected signal model for compartment 4
void ShowAdvancedOptions(int state);
/** update fibers if any parameter changes */
void OnFiberDensityChanged(int value);
void OnFiberSamplingChanged(double value);
void OnTensionChanged(double value);
void OnContinuityChanged(double value);
void OnBiasChanged(double value);
void OnVarianceChanged(double value);
void OnDistributionChanged(int value);
void OnConstantRadius(int value);
/** update GUI elements */
void OnAddNoise(int value);
void OnAddGhosts(int value);
void OnAddDistortions(int value);
void OnAddEddy(int value);
void OnAddSpikes(int value);
void OnAddAliasing(int value);
void OnAddMotion(int value);
void OnMaskSelected(int value);
void OnFibSelected(int value);
void OnTemplateSelected(int value);
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&);
GradientListType GenerateHalfShell(int NPoints); ///< generate vectors distributed over the halfsphere
Ui::QmitkFiberfoxViewControls* m_Controls;
void SimulateForExistingDwi(mitk::DataNode* imageNode); ///< add artifacts to existing diffusion weighted image
void SimulateImageFromFibers(mitk::DataNode* fiberNode); ///< simulate new diffusion weighted image
template< class ScalarType > FiberfoxParameters< ScalarType > UpdateImageParameters(); ///< update fiberfox paramater object (template parameter defines noise model type)
void UpdateGui(); ///< enable/disbale buttons etc. according to current datamanager selection
void PlanarFigureSelected( itk::Object* object, const itk::EventObject& );
void EnableCrosshairNavigation(); ///< enable crosshair navigation if planar figure interaction ends
void DisableCrosshairNavigation(); ///< disable crosshair navigation if planar figure interaction starts
void NodeAdded( const mitk::DataNode* node ); ///< add observers
void NodeRemoved(const mitk::DataNode* node); ///< remove observers
/** structure to keep track of planar figures and observers */
struct QmitkPlanarFigureData
{
QmitkPlanarFigureData()
: m_Figure(0)
, m_EndPlacementObserverTag(0)
, m_SelectObserverTag(0)
, m_StartInteractionObserverTag(0)
, m_EndInteractionObserverTag(0)
, m_Flipped(0)
{
}
mitk::PlanarFigure* m_Figure;
unsigned int m_EndPlacementObserverTag;
unsigned int m_SelectObserverTag;
unsigned int m_StartInteractionObserverTag;
unsigned int m_EndInteractionObserverTag;
unsigned int m_Flipped;
};
std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData; ///< map each planar figure uniquely to a QmitkPlanarFigureData
mitk::DataNode::Pointer m_SelectedFiducial; ///< selected planar ellipse
mitk::DataNode::Pointer m_SelectedImage;
vector< mitk::DataNode::Pointer > m_SelectedBundles;
vector< mitk::DataNode::Pointer > m_SelectedBundles2;
vector< mitk::DataNode::Pointer > m_SelectedFiducials;
vector< mitk::DataNode::Pointer > m_SelectedImages;
QString m_ParameterFile; ///< parameter file name
// GUI thread
QmitkFiberfoxWorker m_Worker; ///< runs filter
QThread m_Thread; ///< worker thread
bool m_ThreadIsRunning;
QTimer* m_SimulationTimer;
QTime m_SimulationTime;
QString m_SimulationStatusText;
/** Image filters that do all the simulations. */
itk::TractsToDWIImageFilter< short >::Pointer m_TractsToDwiFilter;
itk::AddArtifactsToDwiImageFilter< short >::Pointer m_ArtifactsToDwiFilter;
friend class QmitkFiberfoxWorker;
};
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
index d7a48764db..ca203d8df9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
@@ -1,826 +1,832 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkIVIMView.h"
#include "QmitkStdMultiWidget.h"
// qt
#include "qmessagebox.h"
#include "qclipboard.h"
// mitk
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
#include "mitkImageCast.h"
// itk
#include "itkScalarImageToHistogramGenerator.h"
#include "itkRegionOfInterestImageFilter.h"
#include "itkImageRegionConstIteratorWithIndex.h"
// itk/mitk
#include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
#include "itkRegularizedIVIMReconstructionFilter.h"
#include "mitkImageCast.h"
const std::string QmitkIVIMView::VIEW_ID = "org.mitk.views.ivim";
QmitkIVIMView::QmitkIVIMView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_SliceObserverTag1(0), m_SliceObserverTag2(0), m_SliceObserverTag3(0)
, m_DiffusionImageNode(NULL)
, m_MaskImageNode(NULL)
, m_Active(false)
{
}
QmitkIVIMView::~QmitkIVIMView()
{
// QmitkStdMultiWidget* MultiWidget = this->GetActiveStdMultiWidget(false);
// if(MultiWidget)
// {
// //unregister observers when view is destroyed
// if( MultiWidget->mitkWidget1 != NULL && m_SliceObserverTag1 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget1->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag1 );
// }
// if( MultiWidget->mitkWidget2 != NULL && m_SliceObserverTag2 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget2->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag2 );
// }
// if( MultiWidget->mitkWidget3!= NULL && m_SliceObserverTag3 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget3->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag3 );
// }
// }
}
void QmitkIVIMView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkIVIMViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->m_ButtonStart, SIGNAL(clicked()), this, SLOT(FittIVIMStart()) );
connect( m_Controls->m_ButtonAutoThres, SIGNAL(clicked()), this, SLOT(AutoThreshold()) );
connect( m_Controls->m_MethodCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(MethodCombo(int)) );
connect( m_Controls->m_DStarSlider, SIGNAL(valueChanged(int)), this, SLOT(DStarSlider(int)) );
connect( m_Controls->m_BThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(BThreshSlider(int)) );
connect( m_Controls->m_S0ThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(S0ThreshSlider(int)) );
connect( m_Controls->m_NumItSlider, SIGNAL(valueChanged(int)), this, SLOT(NumItsSlider(int)) );
connect( m_Controls->m_LambdaSlider, SIGNAL(valueChanged(int)), this, SLOT(LambdaSlider(int)) );
connect( m_Controls->m_CheckDStar, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_CheckD, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_Checkf, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_ChooseMethod, SIGNAL(clicked()), this, SLOT(ChooseMethod()) );
connect( m_Controls->m_CurveClipboard, SIGNAL(clicked()), this, SLOT(ClipboardCurveButtonClicked()) );
connect( m_Controls->m_ValuesClipboard, SIGNAL(clicked()), this, SLOT(ClipboardStatisticsButtonClicked()) );
}
QString dstar = QString::number(m_Controls->m_DStarSlider->value()/1000.0);
m_Controls->m_DStarLabel->setText(dstar);
QString bthresh = QString::number(m_Controls->m_BThreshSlider->value()*5.0);
m_Controls->m_BThreshLabel->setText(bthresh);
QString s0thresh = QString::number(m_Controls->m_S0ThreshSlider->value()*0.5);
m_Controls->m_S0ThreshLabel->setText(s0thresh);
QString numits = QString::number(m_Controls->m_NumItSlider->value());
m_Controls->m_NumItsLabel->setText(numits);
QString lambda = QString::number(m_Controls->m_LambdaSlider->value()*.00001);
m_Controls->m_LambdaLabel->setText(lambda);
m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
m_Controls->m_Warning->setVisible(false);
MethodCombo(m_Controls->m_MethodCombo->currentIndex());
}
void QmitkIVIMView::Checkbox()
{
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::MethodCombo(int val)
{
switch(val)
{
case 0:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 1:
m_Controls->m_DstarFrame->setVisible(true);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 2:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(true);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 3:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(true);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 4:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(false);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
}
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::DStarSlider (int val)
{
QString sval = QString::number(val/1000.0);
m_Controls->m_DStarLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::BThreshSlider (int val)
{
QString sval = QString::number(val*5.0);
m_Controls->m_BThreshLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::S0ThreshSlider (int val)
{
QString sval = QString::number(val*0.5);
m_Controls->m_S0ThreshLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::NumItsSlider (int val)
{
QString sval = QString::number(val);
m_Controls->m_NumItsLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::LambdaSlider (int val)
{
QString sval = QString::number(val*.00001);
m_Controls->m_LambdaLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
}
void QmitkIVIMView::StdMultiWidgetNotAvailable()
{
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag1 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag2 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag3 );
}
m_MultiWidget = NULL;
}
void QmitkIVIMView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
bool foundOneDiffusionImage = false;
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
m_MaskImageNode = NULL;
m_DiffusionImageNode = NULL;
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
- if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+
+ if( isDiffusionImage )
{
m_DiffusionImageNode = node;
foundOneDiffusionImage = true;
m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
}
else
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_MaskImageNode = node;
m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
}
}
}
}
if (m_DiffusionImageNode.IsNotNull())
{
m_Controls->m_VisualizeResultsWidget->setVisible(true);
m_Controls->m_InputData->setTitle("Input Data");
}
else
{
m_Controls->m_VisualizeResultsWidget->setVisible(false);
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
}
m_Controls->m_ButtonStart->setEnabled( foundOneDiffusionImage );
m_Controls->m_ButtonAutoThres->setEnabled( foundOneDiffusionImage );
m_Controls->m_ControlsFrame->setEnabled( foundOneDiffusionImage );
m_Controls->m_BottomControlsFrame->setEnabled( foundOneDiffusionImage );
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::AutoThreshold()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if (nodes.empty()) return;
if (!nodes.front())
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, "Template", "Please load and select a diffusion image before starting image processing.");
return;
}
- typedef mitk::DiffusionImage<short> DiffImgType;
- DiffImgType* dimg = dynamic_cast<DiffImgType*>(nodes.front()->GetData());
+ mitk::Image* dimg = dynamic_cast<mitk::Image*>(nodes.front()->GetData());
if (!dimg)
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
return;
}
// find bzero index
int index = -1;
- DiffImgType::GradientDirectionContainerType::Pointer directions = dimg->GetDirections();
- for(DiffImgType::GradientDirectionContainerType::ConstIterator it = directions->Begin();
+ DirContainerType::Pointer directions = static_cast<mitk::GradientDirectionsProperty*>( dimg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+ for(DirContainerType::ConstIterator it = directions->Begin();
it != directions->End(); ++it)
{
index++;
- DiffImgType::GradientDirectionType g = it.Value();
+ GradientDirectionType g = it.Value();
if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
break;
}
- typedef itk::VectorImage<short,3> VecImgType;
- VecImgType::Pointer vecimg = dimg->GetVectorImage();
+ VecImgType::Pointer vecimg = VecImgType::New();
+ mitk::CastToItkImage(dimg, vecimg);
int vecLength = vecimg->GetVectorLength();
index = index > vecLength-1 ? vecLength-1 : index;
MITK_INFO << "Performing Histogram Analysis on Channel" << index;
typedef itk::Image<short,3> ImgType;
ImgType::Pointer img = ImgType::New();
mitk::CastToItkImage(dimg, img);
itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
itw.GoToBegin();
itk::ImageRegionConstIterator<VecImgType> itr (vecimg, vecimg->GetLargestPossibleRegion() );
itr.GoToBegin();
while(!itr.IsAtEnd())
{
itw.Set(itr.Get().GetElement(index));
++itr;
++itw;
}
typedef itk::Statistics::ScalarImageToHistogramGenerator< ImgType >
HistogramGeneratorType;
typedef HistogramGeneratorType::HistogramType HistogramType;
HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
histogramGenerator->SetInput( img );
histogramGenerator->SetMarginalScale( 10 ); // Defines y-margin width of histogram
histogramGenerator->SetNumberOfBins( 100 ); // CT range [-1024, +2048] --> bin size 4 values
histogramGenerator->SetHistogramMin( dimg->GetScalarValueMin() );
histogramGenerator->SetHistogramMax( dimg->GetScalarValueMax() * .5 );
histogramGenerator->Compute();
HistogramType::ConstIterator iter = histogramGenerator->GetOutput()->Begin();
float maxFreq = 0;
float maxValue = 0;
while ( iter != histogramGenerator->GetOutput()->End() )
{
if(iter.GetFrequency() > maxFreq)
{
maxFreq = iter.GetFrequency();
maxValue = iter.GetMeasurementVector()[0];
}
++iter;
}
maxValue *= 2;
int sliderPos = maxValue * 2;
m_Controls->m_S0ThreshSlider->setValue(sliderPos);
S0ThreshSlider(sliderPos);
}
void QmitkIVIMView::FittIVIMStart()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
- mitk::DiffusionImage<short>* img = 0;
+ mitk::Image* img = 0;
for ( unsigned int i=0; i<nodes.size(); i++ )
{
- img = dynamic_cast<mitk::DiffusionImage<short>*>(nodes.at(i)->GetData());
- if (img)
+ img = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData());
+
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(nodes.at(i)->GetData())) );
+
+ if (img && isDiffusionImage)
break;
}
+
if (!img)
{
QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
return;
}
- typedef itk::VectorImage<short,3> VecImgType;
- VecImgType::Pointer vecimg = img->GetVectorImage();
+
+ VecImgType::Pointer vecimg = VecImgType::New();
+ mitk::CastToItkImage(img, vecimg);
OutImgType::IndexType dummy;
- FittIVIM(vecimg, img->GetDirections(), img->GetReferenceBValue(), true, dummy);
+ FittIVIM(vecimg, static_cast<mitk::GradientDirectionsProperty*>( img->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), static_cast<mitk::FloatProperty*>(img->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(), true, dummy);
OutputToDatastorage(nodes);
}
void QmitkIVIMView::OnSliceChanged(const itk::EventObject& /*e*/)
{
if(!m_Visible)
return;
m_Controls->m_Warning->setVisible(false);
if(!m_Controls || m_DiffusionImageNode.IsNull())
return;
m_Controls->m_VisualizeResultsWidget->setVisible(false);
- mitk::DiffusionImage<short>::Pointer diffusionImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_DiffusionImageNode->GetData());
+ mitk::Image::Pointer diffusionImg = dynamic_cast<mitk::Image*>(m_DiffusionImageNode->GetData());
mitk::Image::Pointer maskImg = NULL;
if (m_MaskImageNode.IsNotNull())
maskImg = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
if (!m_MultiWidget) return;
- typedef itk::VectorImage<short,3> VecImgType;
- VecImgType::Pointer vecimg = (VecImgType*)diffusionImg->GetVectorImage().GetPointer();
+ VecImgType::Pointer vecimg = VecImgType::New();
+ mitk::CastToItkImage(diffusionImg, vecimg);
VecImgType::Pointer roiImage = VecImgType::New();
bool success = false;
if(maskImg.IsNull())
{
int roisize = 0;
if(m_Controls->m_MethodCombo->currentIndex() == 4)
roisize = 5;
mitk::Point3D pos = m_MultiWidget->GetCrossPosition();
VecImgType::IndexType crosspos;
diffusionImg->GetGeometry()->WorldToIndex(pos, crosspos);
if (!vecimg->GetLargestPossibleRegion().IsInside(crosspos))
{
m_Controls->m_Warning->setText(QString("Crosshair position not inside of selected diffusion weighted image. Reinit needed!"));
m_Controls->m_Warning->setVisible(true);
return;
}
else
m_Controls->m_Warning->setVisible(false);
VecImgType::IndexType index;
index[0] = crosspos[0] - roisize; index[0] = index[0] < 0 ? 0 : index[0];
index[1] = crosspos[1] - roisize; index[1] = index[1] < 0 ? 0 : index[1];
index[2] = crosspos[2] - roisize; index[2] = index[2] < 0 ? 0 : index[2];
VecImgType::SizeType size;
size[0] = roisize*2+1;
size[1] = roisize*2+1;
size[2] = roisize*2+1;
VecImgType::SizeType maxSize = vecimg->GetLargestPossibleRegion().GetSize();
size[0] = index[0]+size[0] > maxSize[0] ? maxSize[0]-index[0] : size[0];
size[1] = index[1]+size[1] > maxSize[1] ? maxSize[1]-index[1] : size[1];
size[2] = index[2]+size[2] > maxSize[2] ? maxSize[2]-index[2] : size[2];
VecImgType::RegionType region;
region.SetSize( size );
region.SetIndex( index );
vecimg->SetRequestedRegion( region );
VecImgType::IndexType newstart;
newstart.Fill(0);
VecImgType::RegionType newregion;
newregion.SetSize( size );
newregion.SetIndex( newstart );
roiImage->CopyInformation( vecimg );
roiImage->SetRegions( newregion );
roiImage->SetOrigin( pos );
roiImage->Allocate();
roiImage->SetPixel(newstart, vecimg->GetPixel(index));
- success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetReferenceBValue(), false, crosspos);
+ success = FittIVIM(roiImage, static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(), false, crosspos);
}
else
{
typedef itk::Image<float,3> MaskImgType;
MaskImgType::Pointer maskItk;
CastToItkImage( maskImg, maskItk );
mitk::Point3D pos;
pos[0] = 0;
pos[1] = 0;
pos[2] = 0;
VecImgType::IndexType index;
index[0] = 0;
index[1] = 0;
index[2] = 0;
VecImgType::SizeType size;
size[0] = 1;
size[1] = 1;
size[2] = 1;
VecImgType::RegionType region;
region.SetSize( size );
region.SetIndex( index );
vecimg->SetRequestedRegion( region );
// iterators over output and input
itk::ImageRegionConstIteratorWithIndex<VecImgType>
vecit(vecimg, vecimg->GetLargestPossibleRegion());
itk::VariableLengthVector<double> avg(vecimg->GetVectorLength());
avg.Fill(0);
float numPixels = 0;
while ( ! vecit.IsAtEnd() )
{
VecImgType::PointType point;
vecimg->TransformIndexToPhysicalPoint(vecit.GetIndex(), point);
MaskImgType::IndexType index;
maskItk->TransformPhysicalPointToIndex(point, index);
if(maskItk->GetPixel(index) != 0)
{
avg += vecit.Get();
numPixels += 1.0;
}
// update iterators
++vecit;
}
avg /= numPixels;
m_Controls->m_Warning->setText(QString("Averaging ")+QString::number((int)numPixels)+QString(" voxels!"));
m_Controls->m_Warning->setVisible(true);
roiImage->CopyInformation( vecimg );
roiImage->SetRegions( region );
roiImage->SetOrigin( pos );
roiImage->Allocate();
roiImage->SetPixel(index, avg);
- success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetReferenceBValue(), false, index);
+ success = FittIVIM(roiImage, static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(), false, index);
}
vecimg->SetRegions( vecimg->GetLargestPossibleRegion() );
if (success)
{
m_Controls->m_VisualizeResultsWidget->setVisible(true);
m_Controls->m_VisualizeResultsWidget->SetParameters(m_Snap);
}
}
bool QmitkIVIMView::FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos)
{
IVIMFilterType::Pointer filter = IVIMFilterType::New();
filter->SetInput(vecimg);
filter->SetGradientDirections(dirs);
filter->SetBValue(bval);
switch(m_Controls->m_MethodCombo->currentIndex())
{
case 0:
filter->SetMethod(IVIMFilterType::IVIM_FIT_ALL);
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
break;
case 1:
filter->SetMethod(IVIMFilterType::IVIM_DSTAR_FIX);
filter->SetDStar(m_Controls->m_DStarLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
break;
case 2:
filter->SetMethod(IVIMFilterType::IVIM_D_THEN_DSTAR);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
case 3:
filter->SetMethod(IVIMFilterType::IVIM_LINEAR_D_THEN_F);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
case 4:
filter->SetMethod(IVIMFilterType::IVIM_REGULARIZED);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetNumberIterations(m_Controls->m_NumItsLabel->text().toInt());
filter->SetLambda(m_Controls->m_LambdaLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
}
if(!multivoxel)
{
filter->SetFitDStar(true);
}
filter->SetNumberOfThreads(1);
filter->SetVerbose(false);
filter->SetCrossPosition(crosspos);
try{
filter->Update();
m_Snap = filter->GetSnapshot();
m_DStarMap = filter->GetOutput(2);
m_DMap = filter->GetOutput(1);
m_fMap = filter->GetOutput();
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
m_Controls->m_Warning->setText(QString("IVIM fit not possible: ")+ex.GetDescription());
m_Controls->m_Warning->setVisible(true);
return false;
}
return true;
}
void QmitkIVIMView::OutputToDatastorage(std::vector<mitk::DataNode*> nodes)
{
// Outputs to Datastorage
QString basename(nodes.front()->GetName().c_str());
if(m_Controls->m_CheckDStar->isChecked())
{
mitk::Image::Pointer dstarimage = mitk::Image::New();
dstarimage->InitializeByItk(m_DStarMap.GetPointer());
dstarimage->SetVolume(m_DStarMap->GetBufferPointer());
QString newname2 = basename; newname2 = newname2.append("_DStarMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node2=mitk::DataNode::New();
node2->SetData( dstarimage );
node2->SetName(newname2.toLatin1());
GetDefaultDataStorage()->Add(node2);
}
if(m_Controls->m_CheckD->isChecked())
{
mitk::Image::Pointer dimage = mitk::Image::New();
dimage->InitializeByItk(m_DMap.GetPointer());
dimage->SetVolume(m_DMap->GetBufferPointer());
QString newname1 = basename; newname1 = newname1.append("_DMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node1=mitk::DataNode::New();
node1->SetData( dimage );
node1->SetName(newname1.toLatin1());
GetDefaultDataStorage()->Add(node1);
}
if(m_Controls->m_Checkf->isChecked())
{
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk(m_fMap.GetPointer());
image->SetVolume(m_fMap->GetBufferPointer());
QString newname0 = basename; newname0 = newname0.append("_fMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
node->SetName(newname0.toLatin1());
GetDefaultDataStorage()->Add(node);
}
m_MultiWidget->RequestUpdate();
// reset the data node labels, the selection in DataManager is lost after adding
// a new node -> we cannot directly proceed twice, the DWI ( and MASK) image have to be selected again
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
m_MaskImageNode = NULL;
m_DiffusionImageNode = NULL;
}
void QmitkIVIMView::ChooseMethod()
{
m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
}
void QmitkIVIMView::ClipboardCurveButtonClicked()
{
if(true)
{
QString clipboard("Measurement Points\n");
for ( unsigned int i=0; i<m_Snap.bvalues.size(); i++)
{
clipboard = clipboard.append( "%L1 \t" )
.arg( m_Snap.bvalues[i], 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
for ( unsigned int i=0; i<m_Snap.allmeas.size(); i++)
{
clipboard = clipboard.append( "%L1 \t" )
.arg( m_Snap.allmeas[i], 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
clipboard = clipboard.append( "1st Linear Fit of D and f \n" );
double maxb = m_Snap.bvalues.max_value();
clipboard = clipboard.append( "%L1 \t %L2 \n %L3 \t %L4 \n" )
.arg( (float) 0, 0, 'f', 2 )
.arg( maxb, 0, 'f', 2 )
.arg(1-m_Snap.currentFunceiled, 0, 'f', 2 )
.arg((1-m_Snap.currentFunceiled)*exp(-maxb * m_Snap.currentD), 0, 'f', 2 );
int nsampling = 50;
double f = 1-m_Snap.currentFunceiled;
clipboard = clipboard.append("Final Model\n");
for(int i=0; i<nsampling; i++)
{
double x = (((1.0)*i)/(1.0*nsampling))*maxb;
clipboard = clipboard.append( "%L1 \t" )
.arg( x, 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
for(int i=0; i<nsampling; i++)
{
double x = (((1.0)*i)/(1.0*nsampling))*maxb;
double y = f*exp(- x * m_Snap.currentD) + (1-f)*exp(- x * (m_Snap.currentD+m_Snap.currentDStar));
clipboard = clipboard.append( "%L1 \t" )
.arg( y, 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkIVIMView::ClipboardStatisticsButtonClicked()
{
if ( true )
{
QString clipboard( "f \t D \t D* \n" );
clipboard = clipboard.append( "%L1 \t %L2 \t %L3" )
.arg( m_Snap.currentF, 0, 'f', 10 )
.arg( m_Snap.currentD, 0, 'f', 10 )
.arg( m_Snap.currentDStar, 0, 'f', 10 ) ;
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkIVIMView::Activated()
{
m_Active = true;
}
void QmitkIVIMView::Deactivated()
{
m_Active = false;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
index bfbf10044d..0ed0a8d7a0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
@@ -1,115 +1,117 @@
/*===================================================================
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 _QMITKIVIMVIEW_H_INCLUDED
#define _QMITKIVIMVIEW_H_INCLUDED
#include <berryISelectionListener.h>
#include <QmitkFunctionality.h>
#include "ui_QmitkIVIMViewControls.h"
#include "itkVectorImage.h"
#include "itkImage.h"
-#include "mitkDiffusionImage.h"
+#include <mitkDiffusionPropertyHelper.h>
#include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
/*!
\brief QmitkIVIMView
\warning This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkIVIMView : public QmitkFunctionality
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkIVIMView();
virtual ~QmitkIVIMView();
- typedef mitk::DiffusionImage<short>::GradientDirectionContainerType DirContainerType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType DirContainerType;
typedef itk::DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<short, float> IVIMFilterType;
+ typedef itk::VectorImage<short,3> VecImgType;
typedef itk::Image<float,3> OutImgType;
virtual void CreateQtPartControl(QWidget *parent);
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
void OnSliceChanged(const itk::EventObject& e);
void OutputToDatastorage(std::vector<mitk::DataNode*> nodes);
bool FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos);
void Activated();
void Deactivated();
protected slots:
/// \brief Called when the user clicks the GUI button
void FittIVIMStart();
void AutoThreshold();
void MethodCombo(int val);
void Checkbox();
void DStarSlider(int val);
void BThreshSlider(int val);
void S0ThreshSlider(int val);
void NumItsSlider(int val);
void LambdaSlider(int val);
void ChooseMethod();
void ClipboardStatisticsButtonClicked();
void ClipboardCurveButtonClicked();
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkIVIMViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
int m_SliceObserverTag1;
int m_SliceObserverTag2;
int m_SliceObserverTag3;
OutImgType::Pointer m_DStarMap;
OutImgType::Pointer m_DMap;
OutImgType::Pointer m_fMap;
IVIMFilterType::IVIMSnapshot m_Snap;
mitk::DataNode::Pointer m_DiffusionImageNode;
mitk::DataNode::Pointer m_MaskImageNode;
bool m_Active;
};
#endif // _QMITKIVIMVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
index b4386d9a92..437a3bb34b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
@@ -1,119 +1,118 @@
/*===================================================================
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 _QMITKQmitkODFDetailsView_H_INCLUDED
#define _QMITKQmitkODFDetailsView_H_INCLUDED
#include <berryISelectionListener.h>
#include <QmitkAbstractView.h>
#include "mitkILifecycleAwarePart.h"
#include "ui_QmitkODFDetailsViewControls.h"
#include <itkVectorImage.h>
#include <itkImage.h>
-#include <mitkDiffusionImage.h>
#include <itkOrientationDistributionFunction.h>
#include <mitkQBallImage.h>
#include <vtkTransform.h>
#include <vtkDoubleArray.h>
#include <vtkOdfSource.h>
#include <vtkSmartPointer.h>
#include <QmitkRenderWindow.h>
#include <vtkPolyDataMapper.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <itkDiffusionTensor3D.h>
/*!
\brief View displaying details of the orientation distribution function in the voxel at the current crosshair position.
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkODFDetailsView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkODFDetailsView();
virtual ~QmitkODFDetailsView();
typedef float TOdfPixelType;
typedef itk::Vector<TOdfPixelType,QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
typedef itk::DiffusionTensor3D< TOdfPixelType > TensorPixelType;
typedef itk::Image< TensorPixelType, 3 > TensorImageType;
virtual void CreateQtPartControl(QWidget *parent);
void OnSliceChanged(const itk::EventObject& e);
protected slots:
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
const QList<mitk::DataNode::Pointer>& nodes );
virtual void SetFocus();
void Visible();
void Hidden();
void Activated();
void Deactivated();
void UpdateOdf(); ///< called if slice position or datamanager selection has changed
Ui::QmitkODFDetailsViewControls* m_Controls;
/** observer flags */
int m_SliceObserverTag1;
int m_SliceObserverTag2;
int m_SliceObserverTag3;
int m_PropertyObserverTag;
/** ODF related variables like mesh structure, values etc. */
vtkPolyData* m_TemplateOdf; ///< spherical base mesh
vtkSmartPointer<vtkTransform> m_OdfTransform;
vtkSmartPointer<vtkDoubleArray> m_OdfVals;
vtkSmartPointer<vtkOdfSource> m_OdfSource;
int m_OdfNormalization; ///< normalization method defined in the visualization view
/** rendering of the ODF */
vtkActor* m_VtkActor;
vtkPolyDataMapper* m_VtkMapper;
vtkRenderer* m_Renderer;
vtkRenderWindow* m_VtkRenderWindow;
vtkRenderWindowInteractor* m_RenderWindowInteractor;
vtkCamera* m_Camera;
mitk::DataNode::Pointer m_ImageNode;
};
#endif // _QmitkODFDetailsView_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
index 55a298ba1d..c928cfe266 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
@@ -1,779 +1,778 @@
/*===================================================================
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.
===================================================================*/
//misc
#define _USE_MATH_DEFINES
#include <math.h>
#include <QFileDialog>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkOdfMaximaExtractionView.h"
// MITK
#include <mitkImageCast.h>
#include <mitkFiberBundleX.h>
#include <mitkImage.h>
-#include <mitkDiffusionImage.h>
#include <mitkImageToItk.h>
#include <mitkTensorImage.h>
// ITK
#include <itkVectorImage.h>
#include <itkOdfMaximaExtractionFilter.h>
#include <itkFiniteDiffOdfMaximaExtractionFilter.h>
#include <itkMrtrixPeakImageConverter.h>
#include <itkFslPeakImageConverter.h>
#include <itkShCoefficientImageImporter.h>
#include <itkDiffusionTensorPrincipalDirectionImageFilter.h>
// Qt
#include <QMessageBox>
const std::string QmitkOdfMaximaExtractionView::VIEW_ID = "org.mitk.views.odfmaximaextractionview";
using namespace mitk;
QmitkOdfMaximaExtractionView::QmitkOdfMaximaExtractionView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
}
// Destructor
QmitkOdfMaximaExtractionView::~QmitkOdfMaximaExtractionView()
{
}
void QmitkOdfMaximaExtractionView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkOdfMaximaExtractionViewControls;
m_Controls->setupUi( parent );
connect((QObject*) m_Controls->m_StartTensor, SIGNAL(clicked()), (QObject*) this, SLOT(StartTensor()));
connect((QObject*) m_Controls->m_StartFiniteDiff, SIGNAL(clicked()), (QObject*) this, SLOT(StartFiniteDiff()));
connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
connect((QObject*) m_Controls->m_ImportPeaks, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertPeaks()));
connect((QObject*) m_Controls->m_ImportShCoeffs, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertShCoeffs()));
}
}
void QmitkOdfMaximaExtractionView::UpdateGui()
{
m_Controls->m_GenerateImageButton->setEnabled(false);
m_Controls->m_StartFiniteDiff->setEnabled(false);
m_Controls->m_StartTensor->setEnabled(false);
m_Controls->m_CoeffImageFrame->setEnabled(false);
if (!m_ImageNodes.empty() || !m_TensorImageNodes.empty())
{
m_Controls->m_InputData->setTitle("Input Data");
if (!m_TensorImageNodes.empty())
{
m_Controls->m_DwiFibLabel->setText(m_TensorImageNodes.front()->GetName().c_str());
m_Controls->m_StartTensor->setEnabled(true);
}
else
{
m_Controls->m_DwiFibLabel->setText(m_ImageNodes.front()->GetName().c_str());
m_Controls->m_StartFiniteDiff->setEnabled(true);
m_Controls->m_GenerateImageButton->setEnabled(true);
m_Controls->m_CoeffImageFrame->setEnabled(true);
m_Controls->m_ShOrderBox->setEnabled(true);
m_Controls->m_MaxNumPeaksBox->setEnabled(true);
m_Controls->m_PeakThresholdBox->setEnabled(true);
m_Controls->m_AbsoluteThresholdBox->setEnabled(true);
}
}
else
m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
if (m_ImageNodes.empty())
{
m_Controls->m_ImportPeaks->setEnabled(false);
m_Controls->m_ImportShCoeffs->setEnabled(false);
}
else
{
m_Controls->m_ImportPeaks->setEnabled(true);
m_Controls->m_ImportShCoeffs->setEnabled(true);
}
if (!m_BinaryImageNodes.empty())
{
m_Controls->m_MaskLabel->setText(m_BinaryImageNodes.front()->GetName().c_str());
}
else
{
m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
}
}
template<int shOrder>
void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffs(mitk::Image* mitkImg)
{
typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
typename FilterType::Pointer filter = FilterType::New();
switch (m_Controls->m_ToolkitBox->currentIndex())
{
case 0:
filter->SetToolkit(FilterType::FSL);
break;
case 1:
filter->SetToolkit(FilterType::MRTRIX);
break;
default:
filter->SetToolkit(FilterType::FSL);
}
filter->SetInputImage(caster->GetOutput());
filter->GenerateData();
typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
{
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkCi.GetPointer() );
img->SetVolume( itkCi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("_ShCoefficientImage");
node->SetVisibility(false);
GetDataStorage()->Add(node);
}
{
mitk::QBallImage::Pointer img = mitk::QBallImage::New();
img->InitializeByItk( itkQbi.GetPointer() );
img->SetVolume( itkQbi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("_QballImage");
GetDataStorage()->Add(node);
}
}
void QmitkOdfMaximaExtractionView::ConvertShCoeffs()
{
if (m_ImageNodes.empty())
return;
mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
if (mitkImg->GetDimension()!=4)
{
MITK_INFO << "wrong image type (need 4 dimensions)";
return;
}
int nrCoeffs = mitkImg->GetLargestPossibleRegion().GetSize()[3];
// solve bx² + cx + d = 0 = shOrder² + 2*shOrder + 2-2*neededCoeffs;
int c=3, d=2-2*nrCoeffs;
double D = c*c-4*d;
int shOrder;
if (D>0)
{
shOrder = (-c+sqrt(D))/2.0;
if (shOrder<0)
shOrder = (-c-sqrt(D))/2.0;
}
else if (D==0)
shOrder = -c/2.0;
MITK_INFO << "using SH-order " << shOrder;
switch (shOrder)
{
case 2:
TemplatedConvertShCoeffs<2>(mitkImg);
break;
case 4:
TemplatedConvertShCoeffs<4>(mitkImg);
break;
case 6:
TemplatedConvertShCoeffs<6>(mitkImg);
break;
case 8:
TemplatedConvertShCoeffs<8>(mitkImg);
break;
case 10:
TemplatedConvertShCoeffs<10>(mitkImg);
break;
case 12:
TemplatedConvertShCoeffs<12>(mitkImg);
break;
default:
MITK_INFO << "SH-order " << shOrder << " not supported";
}
}
void QmitkOdfMaximaExtractionView::ConvertPeaks()
{
if (m_ImageNodes.empty())
return;
switch (m_Controls->m_ToolkitBox->currentIndex())
{
case 0:
{
typedef itk::Image< float, 4 > ItkImageType;
typedef itk::FslPeakImageConverter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
FilterType::InputType::Pointer inputVec = FilterType::InputType::New();
mitk::BaseGeometry::Pointer geom;
for (int i=0; i<m_ImageNodes.size(); i++)
{
mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(i)->GetData());
geom = mitkImg->GetGeometry();
typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
inputVec->InsertElement(inputVec->Size(), itkImg);
}
filter->SetInputImages(inputVec);
filter->GenerateData();
mitk::Vector3D outImageSpacing = geom->GetSpacing();
float maxSpacing = 1;
if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
maxSpacing = outImageSpacing[0];
else if (outImageSpacing[1] > outImageSpacing[2])
maxSpacing = outImageSpacing[1];
else
maxSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geom);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
node->SetName("_VectorField");
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(i)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
node->SetVisibility(false);
GetDataStorage()->Add(node);
}
break;
}
case 1:
{
typedef itk::Image< float, 4 > ItkImageType;
typedef itk::MrtrixPeakImageConverter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
// cast to itk
mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
mitk::BaseGeometry::Pointer geom = mitkImg->GetGeometry();
typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
filter->SetInputImage(itkImg);
filter->GenerateData();
mitk::Vector3D outImageSpacing = geom->GetSpacing();
float maxSpacing = 1;
if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
maxSpacing = outImageSpacing[0];
else if (outImageSpacing[1] > outImageSpacing[2])
maxSpacing = outImageSpacing[1];
else
maxSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
//directions->SetGeometry(geom);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node2 = DataNode::New();
node2->SetData(image2);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
node->SetVisibility(false);
GetDataStorage()->Add(node);
}
break;
}
}
}
void QmitkOdfMaximaExtractionView::GenerateImage()
{
if (!m_ImageNodes.empty())
GenerateDataFromDwi();
}
void QmitkOdfMaximaExtractionView::StartTensor()
{
if (m_TensorImageNodes.empty())
return;
typedef itk::DiffusionTensorPrincipalDirectionImageFilter< float, float > MaximaExtractionFilterType;
MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
mitk::BaseGeometry::Pointer geometry;
try{
TensorImage::Pointer img = dynamic_cast<TensorImage*>(m_TensorImageNodes.at(0)->GetData());
ItkTensorImage::Pointer itkImage = ItkTensorImage::New();
CastToItkImage(img, itkImage);
filter->SetInput(itkImage);
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Tensor Principal Direction Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
return;
//throw e;
}
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
if (m_Controls->m_NormalizationBox->currentIndex()==0)
filter->SetNormalizeVectors(false);
filter->Update();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
MaximaExtractionFilterType::OutputImageType::Pointer itkImg = filter->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_PrincipalDirection";
node->SetName(name.toStdString().c_str());
node->SetVisibility(false);
GetDataStorage()->Add(node);
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node2 = DataNode::New();
node2->SetData(image2);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
template<int shOrder>
void QmitkOdfMaximaExtractionView::StartMaximaExtraction()
{
typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
switch (m_Controls->m_ToolkitBox->currentIndex())
{
case 0:
filter->SetToolkit(MaximaExtractionFilterType::FSL);
break;
case 1:
filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
break;
default:
filter->SetToolkit(MaximaExtractionFilterType::FSL);
}
mitk::BaseGeometry::Pointer geometry;
try{
Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
typedef ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
typename CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
filter->SetInput(caster->GetOutput());
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Finite Differences Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
return;
//throw;
}
filter->SetAngularThreshold(cos((float)m_Controls->m_AngularThreshold->value()*M_PI/180));
filter->SetClusteringThreshold(cos((float)m_Controls->m_ClusteringAngleBox->value()*M_PI/180));
filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
filter->SetAbsolutePeakThreshold(m_Controls->m_AbsoluteThresholdBox->value());
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
switch (m_Controls->m_NormalizationBox->currentIndex())
{
case 0:
filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
break;
case 1:
filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
break;
case 2:
filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
break;
}
filter->Update();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
node->SetVisibility(false);
GetDataStorage()->Add(node);
}
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node2 = DataNode::New();
node2->SetData(image2);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkOdfMaximaExtractionView::StartFiniteDiff()
{
if (m_ImageNodes.empty())
return;
switch (m_Controls->m_ShOrderBox->currentIndex())
{
case 0:
StartMaximaExtraction<2>();
break;
case 1:
StartMaximaExtraction<4>();
break;
case 2:
StartMaximaExtraction<6>();
break;
case 3:
StartMaximaExtraction<8>();
break;
case 4:
StartMaximaExtraction<10>();
break;
case 5:
StartMaximaExtraction<12>();
break;
}
}
void QmitkOdfMaximaExtractionView::GenerateDataFromDwi()
{
typedef itk::OdfMaximaExtractionFilter< float > MaximaExtractionFilterType;
MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
mitk::BaseGeometry::Pointer geometry;
if (!m_ImageNodes.empty())
{
try{
Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
typedef ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
filter->SetShCoeffImage(caster->GetOutput());
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
return;
}
}
else
return;
filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
switch (m_Controls->m_NormalizationBox->currentIndex())
{
case 0:
filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
break;
case 1:
filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
break;
case 2:
filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
break;
}
filter->GenerateData();
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
typedef MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(image2);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
// directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkOdfMaximaExtractionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkOdfMaximaExtractionView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkOdfMaximaExtractionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
m_BinaryImageNodes.clear();
m_ImageNodes.clear();
m_TensorImageNodes.clear();
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if ( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
{
m_TensorImageNodes.push_back(node);
}
else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
m_BinaryImageNodes.push_back(node);
else
m_ImageNodes.push_back(node);
}
}
UpdateGui();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
index c873ab9b97..f4b2c87f7d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
@@ -1,2168 +1,2167 @@
/*===================================================================
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 "QmitkPartialVolumeAnalysisView.h"
#include <limits>
#include <qlabel.h>
#include <qspinbox.h>
#include <qpushbutton.h>
#include <qcheckbox.h>
#include <qgroupbox.h>
#include <qradiobutton.h>
#include <qlineedit.h>
#include <qclipboard.h>
#include <qfiledialog.h>
#include <berryIEditorPart.h>
#include <berryIWorkbenchPage.h>
#include <berryPlatform.h>
#include "QmitkStdMultiWidget.h"
#include "QmitkStdMultiWidgetEditor.h"
#include "QmitkSliderNavigatorWidget.h"
#include <QMessageBox>
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateOr.h"
#include "mitkImageTimeSelector.h"
#include "mitkProperties.h"
#include "mitkProgressBar.h"
#include "mitkImageCast.h"
#include "mitkImageToItk.h"
#include "mitkITKImageImport.h"
#include "mitkDataNodeObject.h"
#include "mitkNodePredicateData.h"
#include "mitkPlanarFigureInteractor.h"
#include "mitkGlobalInteraction.h"
#include "mitkTensorImage.h"
#include "mitkPlanarCircle.h"
#include "mitkPlanarRectangle.h"
#include "mitkPlanarPolygon.h"
#include "mitkPartialVolumeAnalysisClusteringCalculator.h"
-#include "mitkDiffusionImage.h"
#include "usModuleRegistry.h"
#include <itkVectorImage.h>
#include "itkTensorDerivedMeasurementsFilter.h"
#include "itkDiffusionTensor3D.h"
#include "itkCartesianToPolarVectorImageFilter.h"
#include "itkPolarToCartesianVectorImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkMaskImageFilter.h"
#include "itkCastImageFilter.h"
#include "itkImageMomentsCalculator.h"
#include <itkResampleImageFilter.h>
#include <itkGaussianInterpolateImageFunction.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <vnl/vnl_vector.h>
#define _USE_MATH_DEFINES
#include <math.h>
#define PVA_PI M_PI
const std::string QmitkPartialVolumeAnalysisView::VIEW_ID =
"org.mitk.views.partialvolumeanalysisview";
class QmitkRequestStatisticsUpdateEvent : public QEvent
{
public:
enum Type
{
StatisticsUpdateRequest = QEvent::MaxUser - 1025
};
QmitkRequestStatisticsUpdateEvent()
: QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
};
typedef itk::Image<short, 3> ImageType;
typedef itk::Image<float, 3> FloatImageType;
typedef itk::Image<itk::Vector<float,3>, 3> VectorImageType;
inline bool my_isnan(float x)
{
volatile float d = x;
if(d!=d)
return true;
if(d==d)
return false;
return d != d;
}
QmitkPartialVolumeAnalysisView::QmitkPartialVolumeAnalysisView(QObject * /*parent*/, const char * /*name*/)
: //QmitkFunctionality(),
m_Controls( NULL ),
m_TimeStepperAdapter( NULL ),
m_MeasurementInfoRenderer(0),
m_MeasurementInfoAnnotation(0),
m_SelectedImageNodes( ),
m_SelectedImage( NULL ),
m_SelectedMaskNode( NULL ),
m_SelectedImageMask( NULL ),
m_SelectedPlanarFigureNodes(0),
m_SelectedPlanarFigure( NULL ),
m_IsTensorImage(false),
m_FAImage(0),
m_RDImage(0),
m_ADImage(0),
m_MDImage(0),
m_CAImage(0),
// m_DirectionImage(0),
m_DirectionComp1Image(0),
m_DirectionComp2Image(0),
m_AngularErrorImage(0),
m_SelectedRenderWindow(NULL),
m_LastRenderWindow(NULL),
m_ImageObserverTag( -1 ),
m_ImageMaskObserverTag( -1 ),
m_PlanarFigureObserverTag( -1 ),
m_CurrentStatisticsValid( false ),
m_StatisticsUpdatePending( false ),
m_GaussianSigmaChangedSliding(false),
m_NumberBinsSliding(false),
m_UpsamplingChangedSliding(false),
m_ClusteringResult(NULL),
m_EllipseCounter(0),
m_RectangleCounter(0),
m_PolygonCounter(0),
m_CurrentFigureNodeInitialized(false),
m_QuantifyClass(2),
m_IconTexOFF(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntOFFIcon.png")),
m_IconTexON(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntONIcon.png")),
m_TexIsOn(true),
m_Visible(false)
{
}
QmitkPartialVolumeAnalysisView::~QmitkPartialVolumeAnalysisView()
{
if ( m_SelectedImage.IsNotNull() )
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
if ( m_SelectedImageMask.IsNotNull() )
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
if ( m_SelectedPlanarFigure.IsNotNull() )
{
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
}
this->GetDataStorage()->AddNodeEvent -= mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage );
m_SelectedPlanarFigureNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedPlanarFigureNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
m_SelectedPlanarFigureNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
m_SelectedImageNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedImageNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
m_SelectedImageNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
}
void QmitkPartialVolumeAnalysisView::CreateQtPartControl(QWidget *parent)
{
if (m_Controls == NULL)
{
m_Controls = new Ui::QmitkPartialVolumeAnalysisViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
SetHistogramVisibility();
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
m_Controls->m_SimilarAnglesFrame->setVisible(false);
m_Controls->m_SimilarAnglesLabel->setVisible(false);
vtkTextProperty *textProp = vtkTextProperty::New();
textProp->SetColor(1.0, 1.0, 1.0);
m_MeasurementInfoAnnotation = vtkCornerAnnotation::New();
m_MeasurementInfoAnnotation->SetMaximumFontSize(12);
m_MeasurementInfoAnnotation->SetTextProperty(textProp);
m_MeasurementInfoRenderer = vtkRenderer::New();
m_MeasurementInfoRenderer->AddActor(m_MeasurementInfoAnnotation);
m_SelectedPlanarFigureNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
m_SelectedPlanarFigureNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedPlanarFigureNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
m_SelectedPlanarFigureNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
m_SelectedImageNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
m_SelectedImageNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
m_SelectedImageNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
m_SelectedImageNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
this->GetDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
, const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage ) );
Select(NULL,true,true);
SetAdvancedVisibility();
}
void QmitkPartialVolumeAnalysisView::SetHistogramVisibility()
{
m_Controls->m_HistogramWidget->setVisible(m_Controls->m_DisplayHistogramCheckbox->isChecked());
}
void QmitkPartialVolumeAnalysisView::SetAdvancedVisibility()
{
m_Controls->frame_7->setVisible(m_Controls->m_AdvancedCheckbox->isChecked());
}
void QmitkPartialVolumeAnalysisView::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_DisplayHistogramCheckbox, SIGNAL( clicked() )
, this, SLOT( SetHistogramVisibility() ) );
connect( m_Controls->m_AdvancedCheckbox, SIGNAL( clicked() )
, this, SLOT( SetAdvancedVisibility() ) );
connect( m_Controls->m_NumberBinsSlider, SIGNAL( sliderReleased () ),
this, SLOT( NumberBinsReleasedSlider( ) ) );
connect( m_Controls->m_UpsamplingSlider, SIGNAL( sliderReleased( ) ),
this, SLOT( UpsamplingReleasedSlider( ) ) );
connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( sliderReleased( ) ),
this, SLOT( GaussianSigmaReleasedSlider( ) ) );
connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( sliderReleased( ) ),
this, SLOT( SimilarAnglesReleasedSlider( ) ) );
connect( m_Controls->m_NumberBinsSlider, SIGNAL( valueChanged (int) ),
this, SLOT( NumberBinsChangedSlider( int ) ) );
connect( m_Controls->m_UpsamplingSlider, SIGNAL( valueChanged( int ) ),
this, SLOT( UpsamplingChangedSlider( int ) ) );
connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( valueChanged( int ) ),
this, SLOT( GaussianSigmaChangedSlider( int ) ) );
connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( valueChanged( int ) ),
this, SLOT( SimilarAnglesChangedSlider(int) ) );
connect( m_Controls->m_OpacitySlider, SIGNAL( valueChanged( int ) ),
this, SLOT( OpacityChangedSlider(int) ) );
connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ToClipBoard()));
connect( m_Controls->m_CircleButton, SIGNAL( clicked() )
, this, SLOT( ActionDrawEllipseTriggered() ) );
connect( m_Controls->m_RectangleButton, SIGNAL( clicked() )
, this, SLOT( ActionDrawRectangleTriggered() ) );
connect( m_Controls->m_PolygonButton, SIGNAL( clicked() )
, this, SLOT( ActionDrawPolygonTriggered() ) );
connect( m_Controls->m_GreenRadio, SIGNAL( clicked(bool) )
, this, SLOT( GreenRadio(bool) ) );
connect( m_Controls->m_PartialVolumeRadio, SIGNAL( clicked(bool) )
, this, SLOT( PartialVolumeRadio(bool) ) );
connect( m_Controls->m_BlueRadio, SIGNAL( clicked(bool) )
, this, SLOT( BlueRadio(bool) ) );
connect( m_Controls->m_AllRadio, SIGNAL( clicked(bool) )
, this, SLOT( AllRadio(bool) ) );
connect( m_Controls->m_EstimateCircle, SIGNAL( clicked() )
, this, SLOT( EstimateCircle() ) );
connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
connect( m_Controls->m_ExportClusteringResultsButton, SIGNAL(clicked()), this, SLOT(ExportClusteringResults()));
}
}
void QmitkPartialVolumeAnalysisView::ExportClusteringResults()
{
if (m_ClusteringResult.IsNull() || m_SelectedImage.IsNull())
return;
mitk::BaseGeometry* geometry = m_SelectedImage->GetGeometry();
itk::Image< short, 3>::Pointer referenceImage = itk::Image< short, 3>::New();
itk::Vector<double,3> newSpacing = geometry->GetSpacing();
mitk::Point3D newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
itk::Matrix<double, 3, 3> newDirection;
itk::ImageRegion<3> imageRegion;
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
newDirection[j][i] = geometry->GetMatrixColumn(i)[j]/newSpacing[j];
imageRegion.SetSize(0, geometry->GetExtent(0));
imageRegion.SetSize(1, geometry->GetExtent(1));
imageRegion.SetSize(2, geometry->GetExtent(2));
// apply new image parameters
referenceImage->SetSpacing( newSpacing );
referenceImage->SetOrigin( newOrigin );
referenceImage->SetDirection( newDirection );
referenceImage->SetRegions( imageRegion );
referenceImage->Allocate();
typedef itk::Image< float, 3 > OutType;
mitk::Image::Pointer mitkInImage = dynamic_cast<mitk::Image*>(m_ClusteringResult->GetData());
typedef itk::Image< itk::RGBAPixel<unsigned char>, 3 > ItkRgbaImageType;
typedef mitk::ImageToItk< ItkRgbaImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkInImage);
caster->Update();
ItkRgbaImageType::Pointer itkInImage = caster->GetOutput();
typedef itk::ExtractChannelFromRgbaImageFilter< itk::Image< short, 3>, OutType > ExtractionFilterType;
ExtractionFilterType::Pointer filter = ExtractionFilterType::New();
filter->SetInput(itkInImage);
filter->SetChannel(ExtractionFilterType::ALPHA);
filter->SetReferenceImage(referenceImage);
filter->Update();
OutType::Pointer outImg = filter->GetOutput();
mitk::Image::Pointer img = mitk::Image::New(); img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// init data node
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
node->SetName("Clustering Result");
GetDataStorage()->Add(node);
}
void QmitkPartialVolumeAnalysisView::EstimateCircle()
{
typedef itk::Image<unsigned char, 3> SegImageType;
SegImageType::Pointer mask_itk = SegImageType::New();
typedef mitk::ImageToItk<SegImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(m_SelectedImageMask);
caster->Update();
typedef itk::ImageMomentsCalculator< SegImageType > MomentsType;
MomentsType::Pointer momentsCalc = MomentsType::New();
momentsCalc->SetImage(caster->GetOutput());
momentsCalc->Compute();
MomentsType::VectorType cog = momentsCalc->GetCenterOfGravity();
MomentsType::MatrixType axes = momentsCalc->GetPrincipalAxes();
MomentsType::VectorType moments = momentsCalc->GetPrincipalMoments();
// moments-coord conversion
// third coordinate min oder max?
// max-min = extent
MomentsType::AffineTransformPointer trafo = momentsCalc->GetPhysicalAxesToPrincipalAxesTransform();
itk::ImageRegionIterator<SegImageType>
itimage(caster->GetOutput(), caster->GetOutput()->GetLargestPossibleRegion());
itimage = itimage.Begin();
double max = -9999999999.0;
double min = 9999999999.0;
while( !itimage.IsAtEnd() )
{
if(itimage.Get())
{
ImageType::IndexType index = itimage.GetIndex();
itk::Point<float,3> point;
caster->GetOutput()->TransformIndexToPhysicalPoint(index,point);
itk::Point<float,3> newPoint;
newPoint = trafo->TransformPoint(point);
if(newPoint[2]<min)
min = newPoint[2];
if(newPoint[2]>max)
max = newPoint[2];
}
++itimage;
}
double extent = max - min;
MITK_DEBUG << "EXTENT = " << extent;
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
double factor = 1000.0;
mitk::FillVector3D(origin, cog[0]-factor*axes[1][0]-factor*axes[2][0],
cog[1]-factor*axes[1][1]-factor*axes[2][1],
cog[2]-factor*axes[1][2]-factor*axes[2][2]);
// mitk::FillVector3D(normal, axis[0][0],axis[0][1],axis[0][2]);
mitk::FillVector3D(bottom, 2*factor*axes[1][0], 2*factor*axes[1][1], 2*factor*axes[1][2]);
mitk::FillVector3D(right, 2*factor*axes[2][0], 2*factor*axes[2][1], 2*factor*axes[2][2]);
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
planegeometry->SetOrigin(origin);
double len1 = sqrt(axes[1][0]*axes[1][0] + axes[1][1]*axes[1][1] + axes[1][2]*axes[1][2]);
double len2 = sqrt(axes[2][0]*axes[2][0] + axes[2][1]*axes[2][1] + axes[2][2]*axes[2][2]);
mitk::Point2D point1;
point1[0] = factor*len1;
point1[1] = factor*len2;
mitk::Point2D point2;
point2[0] = factor*len1+extent*.5;
point2[1] = factor*len2;
mitk::PlanarCircle::Pointer circle = mitk::PlanarCircle::New();
circle->SetPlaneGeometry(planegeometry);
circle->PlaceFigure( point1 );
circle->SetControlPoint(0,point1);
circle->SetControlPoint(1,point2);
//circle->SetCurrentControlPoint( point2 );
mitk::PlanarFigure::PolyLineType polyline = circle->GetPolyLine( 0 );
MITK_DEBUG << "SIZE of planar figure polyline: " << polyline.size();
AddFigureToDataStorage(circle, "Circle");
}
bool QmitkPartialVolumeAnalysisView::AssertDrawingIsPossible(bool checked)
{
if (m_SelectedImageNodes->GetNode().IsNull())
{
checked = false;
this->HandleException("Please select an image!", dynamic_cast<QWidget *>(this->parent()), true);
return false;
}
//this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
return checked;
}
void QmitkPartialVolumeAnalysisView::ActionDrawEllipseTriggered()
{
bool checked = m_Controls->m_CircleButton->isChecked();
if(!this->AssertDrawingIsPossible(checked))
return;
mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
// using PV_ prefix for planar figures from this view
// to distinguish them from that ones created throught the measurement view
this->AddFigureToDataStorage(figure, QString("PV_Circle%1").arg(++m_EllipseCounter));
MITK_DEBUG << "PlanarCircle created ...";
}
void QmitkPartialVolumeAnalysisView::ActionDrawRectangleTriggered()
{
bool checked = m_Controls->m_RectangleButton->isChecked();
if(!this->AssertDrawingIsPossible(checked))
return;
mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
// using PV_ prefix for planar figures from this view
// to distinguish them from that ones created throught the measurement view
this->AddFigureToDataStorage(figure, QString("PV_Rectangle%1").arg(++m_RectangleCounter));
MITK_DEBUG << "PlanarRectangle created ...";
}
void QmitkPartialVolumeAnalysisView::ActionDrawPolygonTriggered()
{
bool checked = m_Controls->m_PolygonButton->isChecked();
if(!this->AssertDrawingIsPossible(checked))
return;
mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
figure->ClosedOn();
// using PV_ prefix for planar figures from this view
// to distinguish them from that ones created throught the measurement view
this->AddFigureToDataStorage(figure, QString("PV_Polygon%1").arg(++m_PolygonCounter));
MITK_DEBUG << "PlanarPolygon created ...";
}
void QmitkPartialVolumeAnalysisView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
const char *propertyKey, mitk::BaseProperty *property )
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
// Add custom property, if available
if ( (propertyKey != NULL) && (property != NULL) )
{
newNode->AddProperty( propertyKey, property );
}
// figure drawn on the topmost layer / image
this->GetDataStorage()->Add(newNode, m_SelectedImageNodes->GetNode() );
QList<mitk::DataNode::Pointer> selectedNodes = this->GetDataManagerSelection();
for(unsigned int i = 0; i < selectedNodes.size(); i++)
{
selectedNodes[i]->SetSelected(false);
}
std::vector<mitk::DataNode *> selectedPFNodes = m_SelectedPlanarFigureNodes->GetNodes();
for(unsigned int i = 0; i < selectedPFNodes.size(); i++)
{
selectedPFNodes[i]->SetSelected(false);
}
newNode->SetSelected(true);
Select(newNode);
}
void QmitkPartialVolumeAnalysisView::PlanarFigureInitialized()
{
if(m_SelectedPlanarFigureNodes->GetNode().IsNull())
return;
m_CurrentFigureNodeInitialized = true;
this->Select(m_SelectedPlanarFigureNodes->GetNode());
m_Controls->m_CircleButton->setChecked(false);
m_Controls->m_RectangleButton->setChecked(false);
m_Controls->m_PolygonButton->setChecked(false);
//this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
this->RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::PlanarFigureFocus(mitk::DataNode* node)
{
mitk::PlanarFigure* _PlanarFigure = 0;
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
if (_PlanarFigure)
{
FindRenderWindow(node);
const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
// make node visible
if (m_SelectedRenderWindow)
{
mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
m_SelectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
centerP, _PlaneGeometry->GetNormal());
m_SelectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
centerP);
}
}
}
void QmitkPartialVolumeAnalysisView::FindRenderWindow(mitk::DataNode* node)
{
if (node && dynamic_cast<mitk::PlanarFigure*> (node->GetData()))
{
m_SelectedRenderWindow = 0;
bool PlanarFigureInitializedWindow = false;
foreach(QmitkRenderWindow * window, this->GetRenderWindowPart()->GetQmitkRenderWindows().values())
{
if (!m_SelectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, window->GetRenderer()))
{
m_SelectedRenderWindow = window;
}
}
}
}
void QmitkPartialVolumeAnalysisView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes)
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
if (!m_Visible)
return;
if ( nodes.empty() )
{
if (m_ClusteringResult.IsNotNull())
{
this->GetDataStorage()->Remove(m_ClusteringResult);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
Select(NULL, true, true);
}
for (int i=0; i<nodes.size(); i++)
Select(nodes.at(i));
}
void QmitkPartialVolumeAnalysisView::Select( mitk::DataNode::Pointer node, bool clearMaskOnFirstArgNULL, bool clearImageOnFirstArgNULL )
{
// Clear any unreferenced images
this->RemoveOrphanImages();
bool somethingChanged = false;
if(node.IsNull())
{
somethingChanged = true;
if(clearMaskOnFirstArgNULL)
{
if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
{
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
m_ImageMaskObserverTag = -1;
}
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
m_PlanarFigureObserverTag = -1;
}
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
m_InitializedObserverTag = -1;
}
m_SelectedPlanarFigure = NULL;
m_SelectedPlanarFigureNodes->RemoveAllNodes();
m_CurrentFigureNodeInitialized = false;
m_SelectedRenderWindow = 0;
m_SelectedMaskNode = NULL;
m_SelectedImageMask = NULL;
}
if(clearImageOnFirstArgNULL)
{
if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
{
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
m_ImageObserverTag = -1;
}
m_SelectedImageNodes->RemoveAllNodes();
m_SelectedImage = NULL;
m_IsTensorImage = false;
m_FAImage = NULL;
m_RDImage = NULL;
m_ADImage = NULL;
m_MDImage = NULL;
m_CAImage = NULL;
m_DirectionComp1Image = NULL;
m_DirectionComp2Image = NULL;
m_AngularErrorImage = NULL;
m_Controls->m_SimilarAnglesFrame->setVisible(false);
m_Controls->m_SimilarAnglesLabel->setVisible(false);
}
}
else
{
typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
ITKCommandType::Pointer changeListener;
changeListener = ITKCommandType::New();
changeListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate );
// Get selected element
mitk::TensorImage *selectedTensorImage = dynamic_cast< mitk::TensorImage * >( node->GetData() );
mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( node->GetData() );
mitk::PlanarFigure *selectedPlanar = dynamic_cast< mitk::PlanarFigure * >( node->GetData() );
bool isMask = false;
bool isImage = false;
bool isPlanar = false;
bool isTensorImage = false;
if (selectedTensorImage != NULL)
{
isTensorImage = true;
}
else if(selectedImage != NULL)
{
node->GetPropertyValue("binary", isMask);
isImage = !isMask;
}
else if ( (selectedPlanar != NULL) )
{
isPlanar = true;
}
// image
if(isImage && selectedImage->GetDimension()==3)
{
if(selectedImage != m_SelectedImage.GetPointer())
{
somethingChanged = true;
if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
{
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
m_ImageObserverTag = -1;
}
*m_SelectedImageNodes = node;
m_SelectedImage = selectedImage;
m_IsTensorImage = false;
m_FAImage = NULL;
m_RDImage = NULL;
m_ADImage = NULL;
m_MDImage = NULL;
m_CAImage = NULL;
m_DirectionComp1Image = NULL;
m_DirectionComp2Image = NULL;
m_AngularErrorImage = NULL;
// Add change listeners to selected objects
m_ImageObserverTag = m_SelectedImage->AddObserver(
itk::ModifiedEvent(), changeListener );
m_Controls->m_SimilarAnglesFrame->setVisible(false);
m_Controls->m_SimilarAnglesLabel->setVisible(false);
m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
}
}
//planar
if(isPlanar)
{
if(selectedPlanar != m_SelectedPlanarFigure.GetPointer())
{
MITK_DEBUG << "Planar selection changed";
somethingChanged = true;
// Possibly previous change listeners
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
m_PlanarFigureObserverTag = -1;
}
if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
{
m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
m_InitializedObserverTag = -1;
}
m_SelectedPlanarFigure = selectedPlanar;
*m_SelectedPlanarFigureNodes = node;
m_CurrentFigureNodeInitialized = selectedPlanar->IsPlaced();
m_SelectedMaskNode = NULL;
m_SelectedImageMask = NULL;
m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
mitk::EndInteractionPlanarFigureEvent(), changeListener );
if(!m_CurrentFigureNodeInitialized)
{
typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
ITKCommandType::Pointer initializationCommand;
initializationCommand = ITKCommandType::New();
// set the callback function of the member command
initializationCommand->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::PlanarFigureInitialized );
// add an observer
m_InitializedObserverTag = selectedPlanar->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
}
m_Controls->m_SelectedMaskLabel->setText( m_SelectedPlanarFigureNodes->GetNode()->GetName().c_str() );
PlanarFigureFocus(node);
}
}
//mask
this->m_Controls->m_EstimateCircle->setEnabled(isMask && selectedImage->GetDimension()==3);
if(isMask && selectedImage->GetDimension()==3)
{
if(selectedImage != m_SelectedImage.GetPointer())
{
somethingChanged = true;
if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
{
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
m_ImageMaskObserverTag = -1;
}
m_SelectedMaskNode = node;
m_SelectedImageMask = selectedImage;
m_SelectedPlanarFigure = NULL;
m_SelectedPlanarFigureNodes->RemoveAllNodes();
m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
itk::ModifiedEvent(), changeListener );
m_Controls->m_SelectedMaskLabel->setText( m_SelectedMaskNode->GetName().c_str() );
}
}
//tensor image
if(isTensorImage && selectedTensorImage->GetDimension()==3)
{
if(selectedImage != m_SelectedImage.GetPointer())
{
somethingChanged = true;
if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
{
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
m_ImageObserverTag = -1;
}
*m_SelectedImageNodes = node;
m_SelectedImage = selectedImage;
m_IsTensorImage = true;
ExtractTensorImages(selectedImage);
// Add change listeners to selected objects
m_ImageObserverTag = m_SelectedImage->AddObserver(
itk::ModifiedEvent(), changeListener );
m_Controls->m_SimilarAnglesFrame->setVisible(true);
m_Controls->m_SimilarAnglesLabel->setVisible(true);
m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
}
}
}
if(somethingChanged)
{
this->SetMeasurementInfoToRenderWindow("");
if(m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull() )
{
m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_ResampleOptionsFrame->setEnabled(false);
m_Controls->m_HistogramWidget->setEnabled(false);
m_Controls->m_ClassSelector->setEnabled(false);
m_Controls->m_DisplayHistogramCheckbox->setEnabled(false);
m_Controls->m_AdvancedCheckbox->setEnabled(false);
m_Controls->frame_7->setEnabled(false);
}
else
{
m_Controls->m_ResampleOptionsFrame->setEnabled(true);
m_Controls->m_HistogramWidget->setEnabled(true);
m_Controls->m_ClassSelector->setEnabled(true);
m_Controls->m_DisplayHistogramCheckbox->setEnabled(true);
m_Controls->m_AdvancedCheckbox->setEnabled(true);
m_Controls->frame_7->setEnabled(true);
}
// Clear statistics / histogram GUI if nothing is selected
if ( m_SelectedImage.IsNull() )
{
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
m_Controls->m_OpacityFrame->setEnabled(false);
m_Controls->m_SelectedImageLabel->setText("<font color='red'>mandatory</font>");
}
else
{
m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
m_Controls->m_OpacityFrame->setEnabled(true);
}
if( !m_Visible || m_SelectedImage.IsNull()
|| (m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull()) )
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_HistogramWidget->ClearItemModel();
m_CurrentStatisticsValid = false;
}
else
{
m_Controls->m_InputData->setTitle("Input Data");
this->RequestStatisticsUpdate();
}
}
}
void QmitkPartialVolumeAnalysisView::ShowClusteringResults()
{
typedef itk::Image<unsigned char, 3> MaskImageType;
mitk::Image::Pointer mask = 0;
MaskImageType::Pointer itkmask = 0;
if(m_IsTensorImage && m_Controls->m_SimilarAnglesSlider->value() != 0)
{
typedef itk::Image<float, 3> AngularErrorImageType;
typedef mitk::ImageToItk<AngularErrorImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(m_AngularErrorImage);
caster->Update();
typedef itk::BinaryThresholdImageFilter< AngularErrorImageType, MaskImageType > ThreshType;
ThreshType::Pointer thresh = ThreshType::New();
thresh->SetUpperThreshold((90-m_Controls->m_SimilarAnglesSlider->value())*(PVA_PI/180.0));
thresh->SetInsideValue(1.0);
thresh->SetInput(caster->GetOutput());
thresh->Update();
itkmask = thresh->GetOutput();
mask = mitk::Image::New();
mask->InitializeByItk(itkmask.GetPointer());
mask->SetVolume(itkmask->GetBufferPointer());
// GetDefaultDataStorage()->Remove(m_newnode);
// m_newnode = mitk::DataNode::New();
// m_newnode->SetData(mask);
// m_newnode->SetName("masking node");
// m_newnode->SetIntProperty( "layer", 1002 );
// GetDefaultDataStorage()->Add(m_newnode, m_SelectedImageNodes->GetNode());
}
mitk::Image::Pointer clusteredImage;
ClusteringType::Pointer clusterer = ClusteringType::New();
if(m_QuantifyClass==3)
{
if(m_IsTensorImage)
{
double *green_fa, *green_rd, *green_ad, *green_md;
//double *greengray_fa, *greengray_rd, *greengray_ad, *greengray_md;
double *gray_fa, *gray_rd, *gray_ad, *gray_md;
//double *redgray_fa, *redgray_rd, *redgray_ad, *redgray_md;
double *red_fa, *red_rd, *red_ad, *red_md;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
mitk::Image::ConstPointer imgToCluster = tmpImg;
red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
mitk::Image::ConstPointer imgToCluster3 = tmpImg;
red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
mitk::Image::ConstPointer imgToCluster4 = tmpImg;
red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
mitk::Image::ConstPointer imgToCluster5 = tmpImg;
red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
green_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
gray_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
// clipboard
QString clipboardText("FA\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
clipboardText = clipboardText
.arg(red_fa[0]).arg(red_fa[1])
.arg(gray_fa[0]).arg(gray_fa[1])
.arg(green_fa[0]).arg(green_fa[1]);
QString clipboardText3("RD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
clipboardText3 = clipboardText3
.arg(red_rd[0]).arg(red_rd[1])
.arg(gray_rd[0]).arg(gray_rd[1])
.arg(green_rd[0]).arg(green_rd[1]);
QString clipboardText4("AD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
clipboardText4 = clipboardText4
.arg(red_ad[0]).arg(red_ad[1])
.arg(gray_ad[0]).arg(gray_ad[1])
.arg(green_ad[0]).arg(green_ad[1]);
QString clipboardText5("MD\t%1\t%2\t\t%3\t%4\t\t%5\t%6");
clipboardText5 = clipboardText5
.arg(red_md[0]).arg(red_md[1])
.arg(gray_md[0]).arg(gray_md[1])
.arg(green_md[0]).arg(green_md[1]);
QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("%1 %2 %3 \n");
plainInfoText = plainInfoText
.arg("Red ", 20)
.arg("Gray ", 20)
.arg("Green", 20);
QString plainInfoText0("FA:%1 ± %2%3 ± %4%5 ± %6\n");
plainInfoText0 = plainInfoText0
.arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(gray_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(gray_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(green_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(green_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText3("RDx10³:%1 ± %2%3 ± %4%5 ± %6\n");
plainInfoText3 = plainInfoText3
.arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * gray_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * green_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText4("ADx10³:%1 ± %2%3 ± %4%5 ± %6\n");
plainInfoText4 = plainInfoText4
.arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * gray_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * green_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText5("MDx10³:%1 ± %2%3 ± %4%5 ± %6");
plainInfoText5 = plainInfoText5
.arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * gray_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
.arg(1000.0 * green_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
}
else
{
double* green;
double* gray;
double* red;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
mitk::Image::ConstPointer imgToCluster = tmpImg;
red = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r);
green = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g);
gray = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b);
// clipboard
QString clipboardText("%1\t%2\t\t%3\t%4\t\t%5\t%6");
clipboardText = clipboardText.arg(red[0]).arg(red[1])
.arg(gray[0]).arg(gray[1])
.arg(green[0]).arg(green[1]);
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("Red: %1 ± %2\nGray: %3 ± %4\nGreen: %5 ± %6");
plainInfoText = plainInfoText.arg(red[0]).arg(red[1])
.arg(gray[0]).arg(gray[1])
.arg(green[0]).arg(green[1]);
this->SetMeasurementInfoToRenderWindow(plainInfoText);
}
clusteredImage = m_CurrentRGBClusteringResults->rgb;
}
else
{
if(m_IsTensorImage)
{
double *red_fa, *red_rd, *red_ad, *red_md;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
mitk::Image::ConstPointer imgToCluster = tmpImg;
red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
mitk::Image::ConstPointer imgToCluster3 = tmpImg;
red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentPerformClusteringResults->clusteredImage, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
mitk::Image::ConstPointer imgToCluster4 = tmpImg;
red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentPerformClusteringResults->clusteredImage, mask);
tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
mitk::Image::ConstPointer imgToCluster5 = tmpImg;
red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentPerformClusteringResults->clusteredImage, mask);
// clipboard
QString clipboardText("FA\t%1\t%2\t");
clipboardText = clipboardText
.arg(red_fa[0]).arg(red_fa[1]);
QString clipboardText3("RD\t%1\t%2\t");
clipboardText3 = clipboardText3
.arg(red_rd[0]).arg(red_rd[1]);
QString clipboardText4("AD\t%1\t%2\t");
clipboardText4 = clipboardText4
.arg(red_ad[0]).arg(red_ad[1]);
QString clipboardText5("MD\t%1\t%2\t");
clipboardText5 = clipboardText5
.arg(red_md[0]).arg(red_md[1]);
QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("%1 \n");
plainInfoText = plainInfoText
.arg("Red ", 20);
QString plainInfoText0("FA:%1 ± %2\n");
plainInfoText0 = plainInfoText0
.arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText3("RDx10³:%1 ± %2\n");
plainInfoText3 = plainInfoText3
.arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText4("ADx10³:%1 ± %2\n");
plainInfoText4 = plainInfoText4
.arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
QString plainInfoText5("MDx10³:%1 ± %2");
plainInfoText5 = plainInfoText5
.arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
}
else
{
double* quant;
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
mitk::Image::ConstPointer imgToCluster = tmpImg;
quant = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage);
// clipboard
QString clipboardText("%1\t%2");
clipboardText = clipboardText.arg(quant[0]).arg(quant[1]);
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
// now paint infos also on renderwindow
QString plainInfoText("Measurement: %1 ± %2");
plainInfoText = plainInfoText.arg(quant[0]).arg(quant[1]);
this->SetMeasurementInfoToRenderWindow(plainInfoText);
}
clusteredImage = m_CurrentPerformClusteringResults->displayImage;
}
if(mask.IsNotNull())
{
typedef itk::Image<itk::RGBAPixel<unsigned char>,3> RGBImageType;
typedef mitk::ImageToItk<RGBImageType> ClusterCasterType;
ClusterCasterType::Pointer clCaster = ClusterCasterType::New();
clCaster->SetInput(clusteredImage);
clCaster->Update();
clCaster->GetOutput();
typedef itk::MaskImageFilter< RGBImageType, MaskImageType, RGBImageType > MaskType;
MaskType::Pointer masker = MaskType::New();
masker->SetInput1(clCaster->GetOutput());
masker->SetInput2(itkmask);
masker->Update();
clusteredImage = mitk::Image::New();
clusteredImage->InitializeByItk(masker->GetOutput());
clusteredImage->SetVolume(masker->GetOutput()->GetBufferPointer());
}
if(m_ClusteringResult.IsNotNull())
{
this->GetDataStorage()->Remove(m_ClusteringResult);
}
m_ClusteringResult = mitk::DataNode::New();
m_ClusteringResult->SetBoolProperty("helper object", true);
m_ClusteringResult->SetIntProperty( "layer", 1000 );
m_ClusteringResult->SetBoolProperty("texture interpolation", m_TexIsOn);
m_ClusteringResult->SetData(clusteredImage);
m_ClusteringResult->SetName("Clusterprobs");
this->GetDataStorage()->Add(m_ClusteringResult, m_SelectedImageNodes->GetNode());
if(m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
{
m_SelectedPlanarFigureNodes->GetNode()->SetIntProperty( "layer", 1001 );
}
this->RequestRenderWindowUpdate();
}
void QmitkPartialVolumeAnalysisView::UpdateStatistics()
{
if(!m_CurrentFigureNodeInitialized && m_SelectedPlanarFigure.IsNotNull())
{
MITK_DEBUG << "Selected planar figure not initialized. No stats calculation performed.";
return;
}
// Remove any cached images that are no longer referenced elsewhere
this->RemoveOrphanImages();
QmitkStdMultiWidget *multiWidget = 0;
QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
if(multiWidgetEdit){
multiWidget = multiWidgetEdit->GetStdMultiWidget();
}
if ( multiWidget == NULL )
{
return;
}
if ( m_SelectedImage.IsNotNull() )
{
// Check if a the selected image is a multi-channel image. If yes, statistics
// cannot be calculated currently.
if ( !m_IsTensorImage && m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
{
QMessageBox::information( NULL, "Warning", "Non-tensor multi-component images not supported.");
m_Controls->m_HistogramWidget->ClearItemModel();
m_CurrentStatisticsValid = false;
return;
}
m_CurrentStatisticsCalculator = NULL;
if(!m_IsTensorImage)
{
// Retrieve HistogramStatisticsCalculator from has map (or create a new one
// for this image if non-existant)
PartialVolumeAnalysisMapType::iterator it =
m_PartialVolumeAnalysisMap.find( m_SelectedImage );
if ( it != m_PartialVolumeAnalysisMap.end() )
{
m_CurrentStatisticsCalculator = it->second;
}
}
if(m_CurrentStatisticsCalculator.IsNull())
{
m_CurrentStatisticsCalculator = mitk::PartialVolumeAnalysisHistogramCalculator::New();
m_CurrentStatisticsCalculator->SetPlanarFigureThickness(m_Controls->m_PlanarFiguresThickness->value());
if(m_IsTensorImage)
{
m_CurrentStatisticsCalculator->SetImage( m_CAImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_FAImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp1Image );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp2Image );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_RDImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_ADImage );
m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_MDImage );
}
else
{
m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
}
m_PartialVolumeAnalysisMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
MITK_DEBUG << "Creating StatisticsCalculator";
}
std::string maskName;
std::string maskType;
unsigned int maskDimension;
if ( m_SelectedImageMask.IsNotNull() )
{
mitk::PixelType pixelType = m_SelectedImageMask->GetPixelType();
MITK_DEBUG << pixelType.GetPixelTypeAsString();
if(pixelType.GetComponentTypeAsString() == "char")
{
MITK_DEBUG << "Pixel type is char instead of uchar";
return;
}
if(pixelType.GetBitsPerComponent() == 16)
{
//convert from short to uchar
typedef itk::Image<short, 3> ShortImageType;
typedef itk::Image<unsigned char, 3> CharImageType;
CharImageType::Pointer charImage;
ShortImageType::Pointer shortImage;
mitk::CastToItkImage(m_SelectedImageMask, shortImage);
typedef itk::CastImageFilter<ShortImageType, CharImageType> ImageCasterType;
ImageCasterType::Pointer caster = ImageCasterType::New();
caster->SetInput( shortImage );
caster->Update();
charImage = caster->GetOutput();
mitk::CastToMitkImage(charImage, m_SelectedImageMask);
}
m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
m_CurrentStatisticsCalculator->SetMaskingModeToImage();
maskName = m_SelectedMaskNode->GetName();
maskType = m_SelectedImageMask->GetNameOfClass();
maskDimension = 3;
std::stringstream maskLabel;
maskLabel << maskName;
if ( maskDimension > 0 )
{
maskLabel << " [" << maskDimension << "D " << maskType << "]";
}
m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
}
else if ( m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
{
m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
maskName = m_SelectedPlanarFigureNodes->GetNode()->GetName();
maskType = m_SelectedPlanarFigure->GetNameOfClass();
maskDimension = 2;
}
else
{
m_CurrentStatisticsCalculator->SetMaskingModeToNone();
maskName = "-";
maskType = "";
maskDimension = 0;
}
bool statisticsChanged = false;
bool statisticsCalculationSuccessful = false;
// Initialize progress bar
mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
// Install listener for progress events and initialize progress bar
typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
ITKCommandType::Pointer progressListener;
progressListener = ITKCommandType::New();
progressListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::UpdateProgressBar );
unsigned long progressObserverTag = m_CurrentStatisticsCalculator
->AddObserver( itk::ProgressEvent(), progressListener );
ClusteringType::ParamsType *cparams = 0;
ClusteringType::ClusterResultType *cresult = 0;
ClusteringType::HistType *chist = 0;
try
{
m_CurrentStatisticsCalculator->SetNumberOfBins(m_Controls->m_NumberBins->text().toInt());
m_CurrentStatisticsCalculator->SetUpsamplingFactor(m_Controls->m_Upsampling->text().toDouble());
m_CurrentStatisticsCalculator->SetGaussianSigma(m_Controls->m_GaussianSigma->text().toDouble());
// Compute statistics
statisticsChanged =
m_CurrentStatisticsCalculator->ComputeStatistics( );
mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
mitk::Image::ConstPointer imgToCluster = tmpImg;
if(imgToCluster.IsNotNull())
{
// perform clustering
const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram( );
if(histogram != NULL)
{
ClusteringType::Pointer clusterer = ClusteringType::New();
clusterer->SetStepsNumIntegration(200);
clusterer->SetMaxIt(1000);
mitk::Image::Pointer pFiberImg;
if(m_QuantifyClass==3)
{
if(m_Controls->m_Quantiles->isChecked())
{
m_CurrentRGBClusteringResults = clusterer->PerformRGBQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
}
else
{
m_CurrentRGBClusteringResults = clusterer->PerformRGBClustering(imgToCluster, histogram);
}
pFiberImg = m_CurrentRGBClusteringResults->rgbChannels->r;
cparams = m_CurrentRGBClusteringResults->params;
cresult = m_CurrentRGBClusteringResults->result;
chist = m_CurrentRGBClusteringResults->hist;
}
else
{
if(m_Controls->m_Quantiles->isChecked())
{
m_CurrentPerformClusteringResults =
clusterer->PerformQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
}
else
{
m_CurrentPerformClusteringResults =
clusterer->PerformClustering(imgToCluster, histogram, m_QuantifyClass);
}
pFiberImg = m_CurrentPerformClusteringResults->clusteredImage;
cparams = m_CurrentPerformClusteringResults->params;
cresult = m_CurrentPerformClusteringResults->result;
chist = m_CurrentPerformClusteringResults->hist;
}
if(m_IsTensorImage)
{
m_AngularErrorImage = clusterer->CaculateAngularErrorImage(
m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1),
m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2),
pFiberImg);
// GetDefaultDataStorage()->Remove(m_newnode2);
// m_newnode2 = mitk::DataNode::New();
// m_newnode2->SetData(m_AngularErrorImage);
// m_newnode2->SetName(("AngularError"));
// m_newnode2->SetIntProperty( "layer", 1003 );
// GetDefaultDataStorage()->Add(m_newnode2, m_SelectedImageNodes->GetNode());
// newnode = mitk::DataNode::New();
// newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1));
// newnode->SetName(("Comp1"));
// GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
// newnode = mitk::DataNode::New();
// newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2));
// newnode->SetName(("Comp2"));
// GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
}
ShowClusteringResults();
}
}
statisticsCalculationSuccessful = true;
}
catch ( const std::runtime_error &e )
{
QMessageBox::information( NULL, "Warning", e.what());
}
catch ( const std::exception &e )
{
MITK_ERROR << "Caught exception: " << e.what();
QMessageBox::information( NULL, "Warning", e.what());
}
m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
// Make sure that progress bar closes
mitk::ProgressBar::GetInstance()->Progress( 100 );
if ( statisticsCalculationSuccessful )
{
if ( statisticsChanged )
{
// Do not show any error messages
m_CurrentStatisticsValid = true;
}
// m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
m_Controls->m_HistogramWidget->SetParameters(
cparams, cresult, chist );
// m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
}
else
{
m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
// Clear statistics and histogram
m_Controls->m_HistogramWidget->ClearItemModel();
m_CurrentStatisticsValid = false;
// If a (non-closed) PlanarFigure is selected, display a line profile widget
if ( m_SelectedPlanarFigure.IsNotNull() )
{
// TODO: enable line profile widget
//m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );
//m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
//m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
//m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
}
}
}
}
void QmitkPartialVolumeAnalysisView::SetMeasurementInfoToRenderWindow(const QString& text)
{
FindRenderWindow(m_SelectedPlanarFigureNodes->GetNode());
if(m_LastRenderWindow != m_SelectedRenderWindow)
{
if(m_LastRenderWindow)
{
QObject::disconnect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
, this, SLOT( OnRenderWindowDelete(QObject*) ) );
}
m_LastRenderWindow = m_SelectedRenderWindow;
if(m_LastRenderWindow)
{
QObject::connect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
, this, SLOT( OnRenderWindowDelete(QObject*) ) );
}
}
if(m_LastRenderWindow && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
{
if (!text.isEmpty())
{
m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->InsertForegroundRenderer(
m_MeasurementInfoRenderer, true);
}
else
{
if (mitk::VtkLayerController::GetInstance(
m_LastRenderWindow->GetRenderWindow()) ->IsRendererInserted(
m_MeasurementInfoRenderer))
mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->RemoveRenderer(
m_MeasurementInfoRenderer);
}
}
else
{
QmitkStdMultiWidget *multiWidget = 0;
QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
if(multiWidgetEdit){
multiWidget = multiWidgetEdit->GetStdMultiWidget();
}
if ( multiWidget == NULL )
{
return;
}
if (!text.isEmpty())
{
m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(
m_MeasurementInfoRenderer, true);
}
else
{
if (mitk::VtkLayerController::GetInstance(
multiWidget->GetRenderWindow1()->GetRenderWindow()) ->IsRendererInserted(
m_MeasurementInfoRenderer))
mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer(
m_MeasurementInfoRenderer);
}
}
}
void QmitkPartialVolumeAnalysisView::UpdateProgressBar()
{
mitk::ProgressBar::GetInstance()->Progress();
}
void QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate()
{
if ( !m_StatisticsUpdatePending )
{
QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
m_StatisticsUpdatePending = true;
}
}
void QmitkPartialVolumeAnalysisView::RemoveOrphanImages()
{
PartialVolumeAnalysisMapType::iterator it = m_PartialVolumeAnalysisMap.begin();
while ( it != m_PartialVolumeAnalysisMap.end() )
{
mitk::Image *image = it->first;
mitk::PartialVolumeAnalysisHistogramCalculator *calculator = it->second;
++it;
mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
if ( this->GetDataStorage()->GetNode( hasImage ) == NULL )
{
if ( m_SelectedImage == image )
{
m_SelectedImage = NULL;
m_SelectedImageNodes->RemoveAllNodes();
}
if ( m_CurrentStatisticsCalculator == calculator )
{
m_CurrentStatisticsCalculator = NULL;
}
m_PartialVolumeAnalysisMap.erase( image );
it = m_PartialVolumeAnalysisMap.begin();
}
}
}
void QmitkPartialVolumeAnalysisView::ExtractTensorImages(
mitk::Image::Pointer tensorimage)
{
typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
typedef mitk::ImageToItk<TensorImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(tensorimage);
caster->Update();
TensorImageType::Pointer image = caster->GetOutput();
typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::FA);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer fa = measurementsCalculator->GetOutput();
m_FAImage = mitk::Image::New();
m_FAImage->InitializeByItk(fa.GetPointer());
m_FAImage->SetVolume(fa->GetBufferPointer());
// mitk::DataNode::Pointer node = mitk::DataNode::New();
// node->SetData(m_FAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::CA);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer ca = measurementsCalculator->GetOutput();
m_CAImage = mitk::Image::New();
m_CAImage->InitializeByItk(ca.GetPointer());
m_CAImage->SetVolume(ca->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::RD);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer rd = measurementsCalculator->GetOutput();
m_RDImage = mitk::Image::New();
m_RDImage->InitializeByItk(rd.GetPointer());
m_RDImage->SetVolume(rd->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::AD);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer ad = measurementsCalculator->GetOutput();
m_ADImage = mitk::Image::New();
m_ADImage->InitializeByItk(ad.GetPointer());
m_ADImage->SetVolume(ad->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(image );
measurementsCalculator->SetMeasure(MeasurementsType::RA);
measurementsCalculator->Update();
MeasurementsType::OutputImageType::Pointer md = measurementsCalculator->GetOutput();
m_MDImage = mitk::Image::New();
m_MDImage->InitializeByItk(md.GetPointer());
m_MDImage->SetVolume(md->GetBufferPointer());
// node = mitk::DataNode::New();
// node->SetData(m_CAImage);
// GetDefaultDataStorage()->Add(node);
typedef DirectionsFilterType::OutputImageType DirImageType;
DirectionsFilterType::Pointer dirFilter = DirectionsFilterType::New();
dirFilter->SetInput(image );
dirFilter->Update();
itk::ImageRegionIterator<DirImageType>
itd(dirFilter->GetOutput(), dirFilter->GetOutput()->GetLargestPossibleRegion());
itd = itd.Begin();
while( !itd.IsAtEnd() )
{
DirImageType::PixelType direction = itd.Get();
direction[0] = fabs(direction[0]);
direction[1] = fabs(direction[1]);
direction[2] = fabs(direction[2]);
itd.Set(direction);
++itd;
}
typedef itk::CartesianToPolarVectorImageFilter<
DirImageType, DirImageType, true> C2PFilterType;
C2PFilterType::Pointer cpFilter = C2PFilterType::New();
cpFilter->SetInput(dirFilter->GetOutput());
cpFilter->Update();
DirImageType::Pointer dir = cpFilter->GetOutput();
typedef itk::Image<float, 3> CompImageType;
CompImageType::Pointer comp1 = CompImageType::New();
comp1->SetSpacing( dir->GetSpacing() ); // Set the image spacing
comp1->SetOrigin( dir->GetOrigin() ); // Set the image origin
comp1->SetDirection( dir->GetDirection() ); // Set the image direction
comp1->SetRegions( dir->GetLargestPossibleRegion() );
comp1->Allocate();
CompImageType::Pointer comp2 = CompImageType::New();
comp2->SetSpacing( dir->GetSpacing() ); // Set the image spacing
comp2->SetOrigin( dir->GetOrigin() ); // Set the image origin
comp2->SetDirection( dir->GetDirection() ); // Set the image direction
comp2->SetRegions( dir->GetLargestPossibleRegion() );
comp2->Allocate();
itk::ImageRegionConstIterator<DirImageType>
it(dir, dir->GetLargestPossibleRegion());
itk::ImageRegionIterator<CompImageType>
it1(comp1, comp1->GetLargestPossibleRegion());
itk::ImageRegionIterator<CompImageType>
it2(comp2, comp2->GetLargestPossibleRegion());
it = it.Begin();
it1 = it1.Begin();
it2 = it2.Begin();
while( !it.IsAtEnd() )
{
it1.Set(it.Get()[1]);
it2.Set(it.Get()[2]);
++it;
++it1;
++it2;
}
m_DirectionComp1Image = mitk::Image::New();
m_DirectionComp1Image->InitializeByItk(comp1.GetPointer());
m_DirectionComp1Image->SetVolume(comp1->GetBufferPointer());
m_DirectionComp2Image = mitk::Image::New();
m_DirectionComp2Image->InitializeByItk(comp2.GetPointer());
m_DirectionComp2Image->SetVolume(comp2->GetBufferPointer());
}
void QmitkPartialVolumeAnalysisView::OnRenderWindowDelete(QObject * obj)
{
if(obj == m_LastRenderWindow)
m_LastRenderWindow = 0;
if(obj == m_SelectedRenderWindow)
m_SelectedRenderWindow = 0;
}
bool QmitkPartialVolumeAnalysisView::event( QEvent *event )
{
if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
{
// Update statistics
m_StatisticsUpdatePending = false;
this->UpdateStatistics();
return true;
}
return false;
}
bool QmitkPartialVolumeAnalysisView::IsExclusiveFunctionality() const
{
return true;
}
void QmitkPartialVolumeAnalysisView::Activated()
{
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigure* figure = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
// finally add all nodes to the model
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figure)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New();
us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode( node );
}
}
}
}
void QmitkPartialVolumeAnalysisView::Deactivated()
{
}
void QmitkPartialVolumeAnalysisView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer reference)
{
this->SetMeasurementInfoToRenderWindow("");
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigure* figure = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
// finally add all nodes to the model
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figure)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
if(figureInteractor)
figureInteractor->SetDataNode( NULL );
}
}
}
void QmitkPartialVolumeAnalysisView::Hidden()
{
if (m_ClusteringResult.IsNotNull())
{
this->GetDataStorage()->Remove(m_ClusteringResult);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
Select(NULL, true, true);
m_Visible = false;
}
void QmitkPartialVolumeAnalysisView::Visible()
{
m_Visible = true;
berry::IWorkbenchPart::Pointer bla;
if (!this->GetCurrentSelection().empty())
{
this->OnSelectionChanged(bla, this->GetCurrentSelection());
}
else
{
this->OnSelectionChanged(bla, this->GetDataManagerSelection());
}
}
void QmitkPartialVolumeAnalysisView::SetFocus()
{
}
void QmitkPartialVolumeAnalysisView::GreenRadio(bool checked)
{
if(checked)
{
m_Controls->m_PartialVolumeRadio->setChecked(false);
m_Controls->m_BlueRadio->setChecked(false);
m_Controls->m_AllRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
}
m_QuantifyClass = 0;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::PartialVolumeRadio(bool checked)
{
if(checked)
{
m_Controls->m_GreenRadio->setChecked(false);
m_Controls->m_BlueRadio->setChecked(false);
m_Controls->m_AllRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
}
m_QuantifyClass = 1;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::BlueRadio(bool checked)
{
if(checked)
{
m_Controls->m_PartialVolumeRadio->setChecked(false);
m_Controls->m_GreenRadio->setChecked(false);
m_Controls->m_AllRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
}
m_QuantifyClass = 2;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::AllRadio(bool checked)
{
if(checked)
{
m_Controls->m_BlueRadio->setChecked(false);
m_Controls->m_PartialVolumeRadio->setChecked(false);
m_Controls->m_GreenRadio->setChecked(false);
m_Controls->m_ExportClusteringResultsButton->setEnabled(false);
}
m_QuantifyClass = 3;
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::NumberBinsChangedSlider(int v )
{
m_Controls->m_NumberBins->setText(QString("%1").arg(m_Controls->m_NumberBinsSlider->value()*5.0));
}
void QmitkPartialVolumeAnalysisView::UpsamplingChangedSlider( int v)
{
m_Controls->m_Upsampling->setText(QString("%1").arg(m_Controls->m_UpsamplingSlider->value()/10.0));
}
void QmitkPartialVolumeAnalysisView::GaussianSigmaChangedSlider(int v )
{
m_Controls->m_GaussianSigma->setText(QString("%1").arg(m_Controls->m_GaussianSigmaSlider->value()/100.0));
}
void QmitkPartialVolumeAnalysisView::SimilarAnglesChangedSlider(int v )
{
m_Controls->m_SimilarAngles->setText(QString("%1°").arg(90-m_Controls->m_SimilarAnglesSlider->value()));
ShowClusteringResults();
}
void QmitkPartialVolumeAnalysisView::OpacityChangedSlider(int v )
{
if(m_SelectedImageNodes->GetNode().IsNotNull())
{
float opacImag = 1.0f-(v-5)/5.0f;
opacImag = opacImag < 0 ? 0 : opacImag;
m_SelectedImageNodes->GetNode()->SetFloatProperty("opacity", opacImag);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if(m_ClusteringResult.IsNotNull())
{
float opacClust = v/5.0f;
opacClust = opacClust > 1 ? 1 : opacClust;
m_ClusteringResult->SetFloatProperty("opacity", opacClust);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkPartialVolumeAnalysisView::NumberBinsReleasedSlider( )
{
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::UpsamplingReleasedSlider( )
{
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::GaussianSigmaReleasedSlider( )
{
RequestStatisticsUpdate();
}
void QmitkPartialVolumeAnalysisView::SimilarAnglesReleasedSlider( )
{
}
void QmitkPartialVolumeAnalysisView::ToClipBoard()
{
std::vector<std::vector<double>* > vals = m_Controls->m_HistogramWidget->m_Vals;
QString clipboardText;
for (std::vector<std::vector<double>* >::iterator it = vals.begin(); it
!= vals.end(); ++it)
{
for (std::vector<double>::iterator it2 = (**it).begin(); it2 != (**it).end(); ++it2)
{
clipboardText.append(QString("%1 \t").arg(*it2));
}
clipboardText.append(QString("\n"));
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
void QmitkPartialVolumeAnalysisView::PropertyChanged(const mitk::DataNode* /*node*/, const mitk::BaseProperty* /*prop*/)
{
}
void QmitkPartialVolumeAnalysisView::NodeChanged(const mitk::DataNode* /*node*/)
{
}
void QmitkPartialVolumeAnalysisView::NodeRemoved(const mitk::DataNode* node)
{
if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
this->GetDataStorage()->Remove(m_ClusteringResult);
if( node == m_SelectedPlanarFigureNodes->GetNode().GetPointer()
|| node == m_SelectedMaskNode.GetPointer() )
{
this->Select(NULL,true,false);
SetMeasurementInfoToRenderWindow("");
}
if( node == m_SelectedImageNodes->GetNode().GetPointer() )
{
this->Select(NULL,false,true);
SetMeasurementInfoToRenderWindow("");
}
}
void QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage(const mitk::DataNode* node)
{
if(!m_Visible)
return;
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(nonConstNode->GetData());
if(figure)
{
// set interactor for new node (if not already set)
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New();
us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode( nonConstNode );
}
// remove uninitialized old planars
if( m_SelectedPlanarFigureNodes->GetNode().IsNotNull() && m_CurrentFigureNodeInitialized == false )
{
mitk::Interactor::Pointer oldInteractor = m_SelectedPlanarFigureNodes->GetNode()->GetInteractor();
if(oldInteractor.IsNotNull())
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
this->GetDataStorage()->Remove(m_SelectedPlanarFigureNodes->GetNode());
}
}
}
void QmitkPartialVolumeAnalysisView::TextIntON()
{
if(m_ClusteringResult.IsNotNull())
{
if(m_TexIsOn)
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
}
else
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
}
m_ClusteringResult->SetBoolProperty("texture interpolation", !m_TexIsOn);
m_TexIsOn = !m_TexIsOn;
this->RequestRenderWindowUpdate();
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
index f088491113..c4142c284c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
@@ -1,1781 +1,1892 @@
/*===================================================================
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
#include "QmitkPreprocessingView.h"
#include "mitkDiffusionImagingConfigure.h"
// qt includes
#include <QMessageBox>
// itk includes
#include "itkTimeProbe.h"
#include "itkB0ImageExtractionImageFilter.h"
#include "itkB0ImageExtractionToSeparateImageFilter.h"
#include "itkBrainMaskExtractionImageFilter.h"
#include "itkCastImageFilter.h"
#include "itkVectorContainer.h"
#include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
#include <itkMergeDiffusionImagesFilter.h>
#include <itkDwiGradientLengthCorrectionFilter.h>
#include <itkDwiNormilzationFilter.h>
// Multishell includes
#include <itkRadialMultishellToSingleshellImageFilter.h>
// Multishell Functors
#include <itkADCAverageFunctor.h>
#include <itkKurtosisFitFunctor.h>
#include <itkBiExpFitFunctor.h>
#include <itkADCFitFunctor.h>
// mitk includes
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkNodePredicateDataType.h"
#include "mitkProperties.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include "mitkLookupTable.h"
#include "mitkLookupTableProperty.h"
#include "mitkTransferFunction.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include <mitkPointSet.h>
#include <itkAdcImageFilter.h>
#include <itkBrainMaskExtractionImageFilter.h>
#include <mitkImageCast.h>
#include <mitkRotationOperation.h>
#include <QTableWidgetItem>
#include <QTableWidget>
#include <mitkInteractionConst.h>
#include <mitkImageAccessByItk.h>
#include <itkResampleDwiImageFilter.h>
#include <itkResampleImageFilter.h>
#include <itkImageDuplicator.h>
#include <itkMaskImageFilter.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateOr.h>
#include <itkCropImageFilter.h>
#include <itkDiffusionTensor3DReconstructionImageFilter.h>
#include <itkRemoveDwiChannelFilter.h>
#include <itkExtractDwiChannelFilter.h>
+#include <mitkITKImageImport.h>
+#include <mitkBValueMapProperty.h>
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkMeasurementFrameProperty.h>
const std::string QmitkPreprocessingView::VIEW_ID =
- "org.mitk.views.preprocessing";
+ "org.mitk.views.preprocessing";
#define DI_INFO MITK_INFO("DiffusionImaging")
typedef float TTensorPixelType;
QmitkPreprocessingView::QmitkPreprocessingView()
- : QmitkFunctionality(),
- m_Controls(NULL),
- m_MultiWidget(NULL),
- m_DiffusionImage(NULL)
+ : QmitkFunctionality(),
+ m_Controls(NULL),
+ m_MultiWidget(NULL)
{
}
QmitkPreprocessingView::~QmitkPreprocessingView()
{
}
void QmitkPreprocessingView::CreateQtPartControl(QWidget *parent)
{
- if (!m_Controls)
- {
- // create GUI widgets
- m_Controls = new Ui::QmitkPreprocessingViewControls;
- m_Controls->setupUi(parent);
- this->CreateConnections();
+ if (!m_Controls)
+ {
+ // create GUI widgets
+ m_Controls = new Ui::QmitkPreprocessingViewControls;
+ m_Controls->setupUi(parent);
+ this->CreateConnections();
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
- m_Controls->m_MeasurementFrameTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
- m_Controls->m_MeasurementFrameTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
- m_Controls->m_DirectionMatrixTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
- m_Controls->m_DirectionMatrixTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
+ m_Controls->m_MeasurementFrameTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+ m_Controls->m_MeasurementFrameTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
+ m_Controls->m_DirectionMatrixTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+ m_Controls->m_DirectionMatrixTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
#else
- m_Controls->m_MeasurementFrameTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
- m_Controls->m_MeasurementFrameTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
- m_Controls->m_DirectionMatrixTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
- m_Controls->m_DirectionMatrixTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+ m_Controls->m_MeasurementFrameTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+ m_Controls->m_MeasurementFrameTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+ m_Controls->m_DirectionMatrixTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+ m_Controls->m_DirectionMatrixTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
#endif
- }
+ }
}
void QmitkPreprocessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
- m_MultiWidget = &stdMultiWidget;
+ m_MultiWidget = &stdMultiWidget;
}
void QmitkPreprocessingView::StdMultiWidgetNotAvailable()
{
- m_MultiWidget = NULL;
+ m_MultiWidget = NULL;
}
void QmitkPreprocessingView::CreateConnections()
{
- if ( m_Controls )
- {
- m_Controls->m_NormalizationMaskBox->SetDataStorage(this->GetDataStorage());
- mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
- mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
- mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
- mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
- mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
- isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
- mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
- mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
- mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
- finalPredicate = mitk::NodePredicateAnd::New(finalPredicate, isBinaryPredicate);
- m_Controls->m_NormalizationMaskBox->SetPredicate(finalPredicate);
-
- m_Controls->m_ExtractBrainMask->setVisible(false);
- m_Controls->m_BrainMaskIterationsBox->setVisible(false);
- m_Controls->m_ResampleIntFrame->setVisible(false);
- connect( (QObject*)(m_Controls->m_ButtonAverageGradients), SIGNAL(clicked()), this, SLOT(AverageGradients()) );
- connect( (QObject*)(m_Controls->m_ButtonExtractB0), SIGNAL(clicked()), this, SLOT(ExtractB0()) );
- connect( (QObject*)(m_Controls->m_ModifyMeasurementFrame), SIGNAL(clicked()), this, SLOT(DoApplyMesurementFrame()) );
- connect( (QObject*)(m_Controls->m_ReduceGradientsButton), SIGNAL(clicked()), this, SLOT(DoReduceGradientDirections()) );
- connect( (QObject*)(m_Controls->m_ShowGradientsButton), SIGNAL(clicked()), this, SLOT(DoShowGradientDirections()) );
- connect( (QObject*)(m_Controls->m_MirrorGradientToHalfSphereButton), SIGNAL(clicked()), this, SLOT(DoHalfSphereGradientDirections()) );
- connect( (QObject*)(m_Controls->m_MergeDwisButton), SIGNAL(clicked()), this, SLOT(MergeDwis()) );
- connect( (QObject*)(m_Controls->m_ProjectSignalButton), SIGNAL(clicked()), this, SLOT(DoProjectSignal()) );
- connect( (QObject*)(m_Controls->m_B_ValueMap_Rounder_SpinBox), SIGNAL(valueChanged(int)), this, SLOT(UpdateDwiBValueMapRounder(int)));
- connect( (QObject*)(m_Controls->m_CreateLengthCorrectedDwi), SIGNAL(clicked()), this, SLOT(DoLengthCorrection()) );
- connect( (QObject*)(m_Controls->m_CalcAdcButton), SIGNAL(clicked()), this, SLOT(DoAdcCalculation()) );
- connect( (QObject*)(m_Controls->m_NormalizeImageValuesButton), SIGNAL(clicked()), this, SLOT(DoDwiNormalization()) );
- connect( (QObject*)(m_Controls->m_ModifyDirection), SIGNAL(clicked()), this, SLOT(DoApplyDirectionMatrix()) );
- connect( (QObject*)(m_Controls->m_ModifySpacingButton), SIGNAL(clicked()), this, SLOT(DoApplySpacing()) );
- connect( (QObject*)(m_Controls->m_ModifyOriginButton), SIGNAL(clicked()), this, SLOT(DoApplyOrigin()) );
- connect( (QObject*)(m_Controls->m_ResampleImageButton), SIGNAL(clicked()), this, SLOT(DoResampleImage()) );
- connect( (QObject*)(m_Controls->m_ResampleTypeBox), SIGNAL(currentIndexChanged(int)), this, SLOT(DoUpdateInterpolationGui(int)) );
- connect( (QObject*)(m_Controls->m_CropImageButton), SIGNAL(clicked()), this, SLOT(DoCropImage()) );
- connect( (QObject*)(m_Controls->m_RemoveGradientButton), SIGNAL(clicked()), this, SLOT(DoRemoveGradient()) );
- connect( (QObject*)(m_Controls->m_ExtractGradientButton), SIGNAL(clicked()), this, SLOT(DoExtractGradient()) );
-
-
- // connect( (QObject*)(m_Controls->m_ExtractBrainMask), SIGNAL(clicked()), this, SLOT(DoExtractBrainMask()) );
- }
+ if ( m_Controls )
+ {
+ m_Controls->m_NormalizationMaskBox->SetDataStorage(this->GetDataStorage());
+ mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+ mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
+ mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
+ mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
+ mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
+ isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
+ mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
+ mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
+ mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
+ finalPredicate = mitk::NodePredicateAnd::New(finalPredicate, isBinaryPredicate);
+ m_Controls->m_NormalizationMaskBox->SetPredicate(finalPredicate);
+
+ m_Controls->m_ExtractBrainMask->setVisible(false);
+ m_Controls->m_BrainMaskIterationsBox->setVisible(false);
+ m_Controls->m_ResampleIntFrame->setVisible(false);
+ connect( (QObject*)(m_Controls->m_ButtonAverageGradients), SIGNAL(clicked()), this, SLOT(AverageGradients()) );
+ connect( (QObject*)(m_Controls->m_ButtonExtractB0), SIGNAL(clicked()), this, SLOT(ExtractB0()) );
+ connect( (QObject*)(m_Controls->m_ModifyMeasurementFrame), SIGNAL(clicked()), this, SLOT(DoApplyMesurementFrame()) );
+ connect( (QObject*)(m_Controls->m_ReduceGradientsButton), SIGNAL(clicked()), this, SLOT(DoReduceGradientDirections()) );
+ connect( (QObject*)(m_Controls->m_ShowGradientsButton), SIGNAL(clicked()), this, SLOT(DoShowGradientDirections()) );
+ connect( (QObject*)(m_Controls->m_MirrorGradientToHalfSphereButton), SIGNAL(clicked()), this, SLOT(DoHalfSphereGradientDirections()) );
+ connect( (QObject*)(m_Controls->m_MergeDwisButton), SIGNAL(clicked()), this, SLOT(MergeDwis()) );
+ connect( (QObject*)(m_Controls->m_ProjectSignalButton), SIGNAL(clicked()), this, SLOT(DoProjectSignal()) );
+ connect( (QObject*)(m_Controls->m_B_ValueMap_Rounder_SpinBox), SIGNAL(valueChanged(int)), this, SLOT(UpdateDwiBValueMapRounder(int)));
+ connect( (QObject*)(m_Controls->m_CreateLengthCorrectedDwi), SIGNAL(clicked()), this, SLOT(DoLengthCorrection()) );
+ connect( (QObject*)(m_Controls->m_CalcAdcButton), SIGNAL(clicked()), this, SLOT(DoAdcCalculation()) );
+ connect( (QObject*)(m_Controls->m_NormalizeImageValuesButton), SIGNAL(clicked()), this, SLOT(DoDwiNormalization()) );
+ connect( (QObject*)(m_Controls->m_ModifyDirection), SIGNAL(clicked()), this, SLOT(DoApplyDirectionMatrix()) );
+ connect( (QObject*)(m_Controls->m_ModifySpacingButton), SIGNAL(clicked()), this, SLOT(DoApplySpacing()) );
+ connect( (QObject*)(m_Controls->m_ModifyOriginButton), SIGNAL(clicked()), this, SLOT(DoApplyOrigin()) );
+ connect( (QObject*)(m_Controls->m_ResampleImageButton), SIGNAL(clicked()), this, SLOT(DoResampleImage()) );
+ connect( (QObject*)(m_Controls->m_ResampleTypeBox), SIGNAL(currentIndexChanged(int)), this, SLOT(DoUpdateInterpolationGui(int)) );
+ connect( (QObject*)(m_Controls->m_CropImageButton), SIGNAL(clicked()), this, SLOT(DoCropImage()) );
+ connect( (QObject*)(m_Controls->m_RemoveGradientButton), SIGNAL(clicked()), this, SLOT(DoRemoveGradient()) );
+ connect( (QObject*)(m_Controls->m_ExtractGradientButton), SIGNAL(clicked()), this, SLOT(DoExtractGradient()) );
+
+
+ // connect( (QObject*)(m_Controls->m_ExtractBrainMask), SIGNAL(clicked()), this, SLOT(DoExtractBrainMask()) );
+ }
}
void QmitkPreprocessingView::DoRemoveGradient()
{
- if (m_DiffusionImage.IsNull())
- return;
-
- std::vector< unsigned int > channelsToRemove; channelsToRemove.push_back(m_Controls->m_RemoveGradientBox->value());
- itk::RemoveDwiChannelFilter< short >::Pointer filter = itk::RemoveDwiChannelFilter< short >::New();
- filter->SetInput(m_DiffusionImage->GetVectorImage());
- filter->SetChannelIndices(channelsToRemove);
- filter->SetDirections(m_DiffusionImage->GetDirections());
- filter->Update();
-
- MitkDwiType::Pointer image = MitkDwiType::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
- image->SetDirections( filter->GetNewDirections() );
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_removedgradients").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
- mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( !isDiffusionImage )
+ {
+ return;
+ }
+
+ std::vector< unsigned int > channelsToRemove; channelsToRemove.push_back(m_Controls->m_RemoveGradientBox->value());
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ itk::RemoveDwiChannelFilter< short >::Pointer filter = itk::RemoveDwiChannelFilter< short >::New();
+ filter->SetInput(itkVectorImagePointer);
+ filter->SetChannelIndices(channelsToRemove);
+ filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ filter->Update();
+
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetNewDirections() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+
+ imageNode->SetName((name+"_removedgradients").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+
+ mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPreprocessingView::DoExtractGradient()
{
- if (m_DiffusionImage.IsNull())
- return;
-
- unsigned int channel = m_Controls->m_ExtractGradientBox->value();
- itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
- filter->SetInput(m_DiffusionImage->GetVectorImage());
- filter->SetChannelIndex(channel);
- filter->Update();
-
- mitk::Image::Pointer mitkImage = mitk::Image::New();
- mitkImage->InitializeByItk( filter->GetOutput() );
- mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( mitkImage );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_direction-"+QString::number(channel)).toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
-
- mitk::RenderingManager::GetInstance()->InitializeViews(imageNode->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( !isDiffusionImage )
+ {
+ return;
+ }
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ unsigned int channel = m_Controls->m_ExtractGradientBox->value();
+ itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
+ filter->SetInput( itkVectorImagePointer);
+ filter->SetChannelIndex(channel);
+ filter->Update();
+
+ mitk::Image::Pointer mitkImage = mitk::Image::New();
+ mitkImage->InitializeByItk( filter->GetOutput() );
+ mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( mitkImage );
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+ imageNode->SetName((name+"_direction-"+QString::number(channel)).toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+
+ mitk::RenderingManager::GetInstance()->InitializeViews(imageNode->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
void QmitkPreprocessingView::DoCropImage()
{
- if (m_DiffusionImage.IsNotNull())
- {
- ItkDwiType::SizeType lower;
- ItkDwiType::SizeType upper;
- lower[0] = m_Controls->m_XstartBox->value();
- lower[1] = m_Controls->m_YstartBox->value();
- lower[2] = m_Controls->m_ZstartBox->value();
- upper[0] = m_Controls->m_XendBox->value();
- upper[1] = m_Controls->m_YendBox->value();
- upper[2] = m_Controls->m_ZendBox->value();
-
- itk::CropImageFilter< ItkDwiType, ItkDwiType >::Pointer cropper = itk::CropImageFilter< ItkDwiType, ItkDwiType >::New();
- cropper->SetLowerBoundaryCropSize(lower);
- cropper->SetUpperBoundaryCropSize(upper);
- cropper->SetInput(m_DiffusionImage->GetVectorImage());
- cropper->Update();
-
- MitkDwiType::Pointer image = MitkDwiType::New();
- image->SetVectorImage( cropper->GetOutput() );
- image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
- image->SetDirections( m_DiffusionImage->GetDirections() );
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_cropped").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
- mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
- mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- else if(m_SelectedImage.IsNotNull())
- {
- AccessFixedDimensionByItk(m_SelectedImage, TemplatedCropImage,3);
- }
-}
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage)
-{
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( isDiffusionImage )
+ {
ItkDwiType::SizeType lower;
ItkDwiType::SizeType upper;
lower[0] = m_Controls->m_XstartBox->value();
lower[1] = m_Controls->m_YstartBox->value();
lower[2] = m_Controls->m_ZstartBox->value();
upper[0] = m_Controls->m_XendBox->value();
upper[1] = m_Controls->m_YendBox->value();
upper[2] = m_Controls->m_ZendBox->value();
- typedef itk::Image<TPixel, VImageDimension> ImageType;
- typename itk::CropImageFilter< ImageType, ImageType >::Pointer cropper = itk::CropImageFilter< ImageType, ImageType >::New();
+ itk::CropImageFilter< ItkDwiType, ItkDwiType >::Pointer cropper = itk::CropImageFilter< ItkDwiType, ItkDwiType >::New();
cropper->SetLowerBoundaryCropSize(lower);
cropper->SetUpperBoundaryCropSize(upper);
- cropper->SetInput(itkImage);
+ cropper->SetInput( itkVectorImagePointer );
cropper->Update();
- mitk::Image::Pointer image = mitk::Image::New();
- image->InitializeByItk( cropper->GetOutput() );
- image->SetVolume( cropper->GetOutput()->GetBufferPointer() );
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( cropper->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
- QString name = m_SelectedImageNode->GetName().c_str();
-
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
imageNode->SetName((name+"_cropped").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+ mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+ else if(m_SelectedImage.IsNotNull())
+ {
+ AccessFixedDimensionByItk(m_SelectedImage, TemplatedCropImage,3);
+ }
}
-void QmitkPreprocessingView::DoApplySpacing()
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage)
{
- if (m_DiffusionImage.IsNotNull())
- {
- mitk::Vector3D spacing;
- spacing[0] = m_Controls->m_HeaderSpacingX->value();
- spacing[1] = m_Controls->m_HeaderSpacingY->value();
- spacing[2] = m_Controls->m_HeaderSpacingZ->value();
-
- MitkDwiType::Pointer image = m_DiffusionImage->Clone();
- image->GetVectorImage()->SetSpacing(spacing);
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_newspacing").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
- mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- else if(m_SelectedImage.IsNotNull())
- {
- AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageSpacing,3);
- }
+ ItkDwiType::SizeType lower;
+ ItkDwiType::SizeType upper;
+ lower[0] = m_Controls->m_XstartBox->value();
+ lower[1] = m_Controls->m_YstartBox->value();
+ lower[2] = m_Controls->m_ZstartBox->value();
+ upper[0] = m_Controls->m_XendBox->value();
+ upper[1] = m_Controls->m_YendBox->value();
+ upper[2] = m_Controls->m_ZendBox->value();
+
+ typedef itk::Image<TPixel, VImageDimension> ImageType;
+ typename itk::CropImageFilter< ImageType, ImageType >::Pointer cropper = itk::CropImageFilter< ImageType, ImageType >::New();
+ cropper->SetLowerBoundaryCropSize(lower);
+ cropper->SetUpperBoundaryCropSize(upper);
+ cropper->SetInput(itkImage);
+ cropper->Update();
+
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk( cropper->GetOutput() );
+ image->SetVolume( cropper->GetOutput()->GetBufferPointer() );
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedImageNode->GetName().c_str();
+
+ imageNode->SetName((name+"_cropped").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+
+ mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage)
+void QmitkPreprocessingView::DoApplySpacing()
{
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( isDiffusionImage )
+ {
mitk::Vector3D spacing;
spacing[0] = m_Controls->m_HeaderSpacingX->value();
spacing[1] = m_Controls->m_HeaderSpacingY->value();
spacing[2] = m_Controls->m_HeaderSpacingZ->value();
- typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
- typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
- duplicator->SetInputImage( itkImage );
- duplicator->Update();
- typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
- newImage->SetSpacing(spacing);
+ mitk::Image::Pointer image = m_SelectedImage->Clone();
+ image->GetGeometry()->SetSpacing( spacing );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
- mitk::Image::Pointer image = mitk::Image::New();
- image->InitializeByItk( newImage.GetPointer() );
- image->SetVolume( newImage->GetBufferPointer() );
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
- QString name = m_SelectedImageNode->GetName().c_str();
-
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
imageNode->SetName((name+"_newspacing").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+ else if(m_SelectedImage.IsNotNull())
+ {
+ AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageSpacing,3);
+ }
}
-void QmitkPreprocessingView::DoApplyOrigin()
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage)
{
- if (m_DiffusionImage.IsNotNull())
- {
- mitk::Vector3D origin;
- origin[0] = m_Controls->m_HeaderOriginX->value();
- origin[1] = m_Controls->m_HeaderOriginY->value();
- origin[2] = m_Controls->m_HeaderOriginZ->value();
-
- MitkDwiType::Pointer image = m_DiffusionImage->Clone();
- image->GetVectorImage()->SetOrigin(origin);
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_neworigin").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
- mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- else if(m_SelectedImage.IsNotNull())
- {
- AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageOrigin,3);
- }
+ mitk::Vector3D spacing;
+ spacing[0] = m_Controls->m_HeaderSpacingX->value();
+ spacing[1] = m_Controls->m_HeaderSpacingY->value();
+ spacing[2] = m_Controls->m_HeaderSpacingZ->value();
+
+ typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
+ typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
+ duplicator->SetInputImage( itkImage );
+ duplicator->Update();
+ typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
+ newImage->SetSpacing(spacing);
+
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk( newImage.GetPointer() );
+ image->SetVolume( newImage->GetBufferPointer() );
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedImageNode->GetName().c_str();
+
+ imageNode->SetName((name+"_newspacing").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+ mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage)
+void QmitkPreprocessingView::DoApplyOrigin()
{
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( isDiffusionImage )
+ {
mitk::Vector3D origin;
origin[0] = m_Controls->m_HeaderOriginX->value();
origin[1] = m_Controls->m_HeaderOriginY->value();
origin[2] = m_Controls->m_HeaderOriginZ->value();
- typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
- typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
- duplicator->SetInputImage( itkImage );
- duplicator->Update();
- typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
- newImage->SetOrigin(origin);
+ mitk::Image::Pointer image = m_SelectedImage->Clone();
+
+ image->GetGeometry()->SetOrigin( origin );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
- mitk::Image::Pointer image = mitk::Image::New();
- image->InitializeByItk( newImage.GetPointer() );
- image->SetVolume( newImage->GetBufferPointer() );
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
- QString name = m_SelectedImageNode->GetName().c_str();
-
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
imageNode->SetName((name+"_neworigin").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+ else if(m_SelectedImage.IsNotNull())
+ {
+ AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageOrigin,3);
+ }
+}
+
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage)
+{
+ mitk::Vector3D origin;
+ origin[0] = m_Controls->m_HeaderOriginX->value();
+ origin[1] = m_Controls->m_HeaderOriginY->value();
+ origin[2] = m_Controls->m_HeaderOriginZ->value();
+
+ typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
+ typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
+ duplicator->SetInputImage( itkImage );
+ duplicator->Update();
+ typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
+ newImage->SetOrigin(origin);
+
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk( newImage.GetPointer() );
+ image->SetVolume( newImage->GetBufferPointer() );
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedImageNode->GetName().c_str();
+
+ imageNode->SetName((name+"_neworigin").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+ mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPreprocessingView::DoUpdateInterpolationGui(int i)
{
- switch (i)
- {
- case 0:
+ if( m_SelectedImageNode && m_SelectedImageNode.IsNull() )
+ {
+ return;
+ }
+ switch (i)
+ {
+ case 0:
+ {
+ m_Controls->m_ResampleIntFrame->setVisible(false);
+ m_Controls->m_ResampleDoubleFrame->setVisible(true);
+ break;
+ }
+ case 1:
+ {
+ m_Controls->m_ResampleIntFrame->setVisible(false);
+ m_Controls->m_ResampleDoubleFrame->setVisible(true);
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ if (itkVectorImagePointer.IsNotNull())
{
- m_Controls->m_ResampleIntFrame->setVisible(false);
- m_Controls->m_ResampleDoubleFrame->setVisible(true);
- break;
+ m_Controls->m_ResampleDoubleX->setValue(itkVectorImagePointer->GetSpacing()[0]);
+ m_Controls->m_ResampleDoubleY->setValue(itkVectorImagePointer->GetSpacing()[1]);
+ m_Controls->m_ResampleDoubleZ->setValue(itkVectorImagePointer->GetSpacing()[2]);
}
- case 1:
+ else if (m_SelectedImage.IsNotNull())
{
- m_Controls->m_ResampleIntFrame->setVisible(false);
- m_Controls->m_ResampleDoubleFrame->setVisible(true);
-
- if (m_DiffusionImage.IsNotNull())
- {
- ItkDwiType::Pointer itkDwi = m_DiffusionImage->GetVectorImage();
- m_Controls->m_ResampleDoubleX->setValue(itkDwi->GetSpacing()[0]);
- m_Controls->m_ResampleDoubleY->setValue(itkDwi->GetSpacing()[1]);
- m_Controls->m_ResampleDoubleZ->setValue(itkDwi->GetSpacing()[2]);
- }
- else if (m_SelectedImage.IsNotNull())
- {
- mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
- m_Controls->m_ResampleDoubleX->setValue(geom->GetSpacing()[0]);
- m_Controls->m_ResampleDoubleY->setValue(geom->GetSpacing()[1]);
- m_Controls->m_ResampleDoubleZ->setValue(geom->GetSpacing()[2]);
- }
- break;
+ mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
+ m_Controls->m_ResampleDoubleX->setValue(geom->GetSpacing()[0]);
+ m_Controls->m_ResampleDoubleY->setValue(geom->GetSpacing()[1]);
+ m_Controls->m_ResampleDoubleZ->setValue(geom->GetSpacing()[2]);
}
- case 2:
- {
- m_Controls->m_ResampleIntFrame->setVisible(true);
- m_Controls->m_ResampleDoubleFrame->setVisible(false);
+ break;
+ }
+ case 2:
+ {
+ m_Controls->m_ResampleIntFrame->setVisible(true);
+ m_Controls->m_ResampleDoubleFrame->setVisible(false);
- if (m_DiffusionImage.IsNotNull())
- {
- ItkDwiType::Pointer itkDwi = m_DiffusionImage->GetVectorImage();
- m_Controls->m_ResampleIntX->setValue(itkDwi->GetLargestPossibleRegion().GetSize(0));
- m_Controls->m_ResampleIntY->setValue(itkDwi->GetLargestPossibleRegion().GetSize(1));
- m_Controls->m_ResampleIntZ->setValue(itkDwi->GetLargestPossibleRegion().GetSize(2));
- }
- else if (m_SelectedImage.IsNotNull())
- {
- mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
- m_Controls->m_ResampleIntX->setValue(geom->GetExtent(0));
- m_Controls->m_ResampleIntY->setValue(geom->GetExtent(1));
- m_Controls->m_ResampleIntZ->setValue(geom->GetExtent(2));
- }
- break;
- }
- default:
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ if (itkVectorImagePointer.IsNotNull())
{
- m_Controls->m_ResampleIntFrame->setVisible(false);
- m_Controls->m_ResampleDoubleFrame->setVisible(true);
+ m_Controls->m_ResampleIntX->setValue(itkVectorImagePointer->GetLargestPossibleRegion().GetSize(0));
+ m_Controls->m_ResampleIntY->setValue(itkVectorImagePointer->GetLargestPossibleRegion().GetSize(1));
+ m_Controls->m_ResampleIntZ->setValue(itkVectorImagePointer->GetLargestPossibleRegion().GetSize(2));
}
+ else if (m_SelectedImage.IsNotNull())
+ {
+ mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
+ m_Controls->m_ResampleIntX->setValue(geom->GetExtent(0));
+ m_Controls->m_ResampleIntY->setValue(geom->GetExtent(1));
+ m_Controls->m_ResampleIntZ->setValue(geom->GetExtent(2));
}
+ break;
+ }
+ default:
+ {
+ m_Controls->m_ResampleIntFrame->setVisible(false);
+ m_Controls->m_ResampleDoubleFrame->setVisible(true);
+ }
+ }
}
void QmitkPreprocessingView::DoExtractBrainMask()
{
- // if (m_SelectedImage.IsNull())
- // return;
-
- // typedef itk::Image<unsigned short, 3> ShortImageType;
- // ShortImageType::Pointer itkImage = ShortImageType::New();
- // mitk::CastToItkImage(m_SelectedImage, itkImage);
-
- // typedef itk::BrainMaskExtractionImageFilter< unsigned char > FilterType;
- // FilterType::Pointer filter = FilterType::New();
- // filter->SetInput(itkImage);
- // filter->SetMaxNumIterations(m_Controls->m_BrainMaskIterationsBox->value());
- // filter->Update();
-
- // mitk::Image::Pointer image = mitk::Image::New();
- // image->InitializeByItk( filter->GetOutput() );
- // image->SetVolume( filter->GetOutput()->GetBufferPointer() );
- // mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- // imageNode->SetData( image );
- // imageNode->SetName("BRAINMASK");
- // GetDefaultDataStorage()->Add(imageNode);
+ // if (m_SelectedImage.IsNull())
+ // return;
+
+ // typedef itk::Image<unsigned short, 3> ShortImageType;
+ // ShortImageType::Pointer itkImage = ShortImageType::New();
+ // mitk::CastToItkImage(m_SelectedImage, itkImage);
+
+ // typedef itk::BrainMaskExtractionImageFilter< unsigned char > FilterType;
+ // FilterType::Pointer filter = FilterType::New();
+ // filter->SetInput(itkImage);
+ // filter->SetMaxNumIterations(m_Controls->m_BrainMaskIterationsBox->value());
+ // filter->Update();
+
+ // mitk::Image::Pointer image = mitk::Image::New();
+ // image->InitializeByItk( filter->GetOutput() );
+ // image->SetVolume( filter->GetOutput()->GetBufferPointer() );
+ // mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ // imageNode->SetData( image );
+ // imageNode->SetName("BRAINMASK");
+ // GetDefaultDataStorage()->Add(imageNode);
}
void QmitkPreprocessingView::DoResampleImage()
{
- if (m_DiffusionImage.IsNotNull())
- {
- typedef itk::ResampleDwiImageFilter< short > ResampleFilter;
- ResampleFilter::Pointer resampler = ResampleFilter::New();
- resampler->SetInput(m_DiffusionImage->GetVectorImage());
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
- switch (m_Controls->m_ResampleTypeBox->currentIndex())
- {
- case 0:
- {
- itk::Vector< double, 3 > samplingFactor;
- samplingFactor[0] = m_Controls->m_ResampleDoubleX->value();
- samplingFactor[1] = m_Controls->m_ResampleDoubleY->value();
- samplingFactor[2] = m_Controls->m_ResampleDoubleZ->value();
- resampler->SetSamplingFactor(samplingFactor);
- break;
- }
- case 1:
- {
- itk::Vector< double, 3 > newSpacing;
- newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
- newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
- newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
- resampler->SetNewSpacing(newSpacing);
- break;
- }
- case 2:
- {
- itk::ImageRegion<3> newRegion;
- newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
- newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
- newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
- resampler->SetNewImageSize(newRegion);
- break;
- }
- default:
- {
- MITK_WARN << "Unknown resampling parameters!";
- return;
- }
- }
-
- QString outAdd;
- switch (m_Controls->m_InterpolatorBox->currentIndex())
- {
- case 0:
- {
- resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
- outAdd = "NearestNeighbour";
- break;
- }
- case 1:
- {
- resampler->SetInterpolation(ResampleFilter::Interpolate_Linear);
- outAdd = "Linear";
- break;
- }
- case 2:
- {
- resampler->SetInterpolation(ResampleFilter::Interpolate_BSpline);
- outAdd = "BSpline";
- break;
- }
- case 3:
- {
- resampler->SetInterpolation(ResampleFilter::Interpolate_WindowedSinc);
- outAdd = "WindowedSinc";
- break;
- }
- default:
- {
- resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
- outAdd = "NearestNeighbour";
- }
- }
-
- resampler->Update();
-
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage( resampler->GetOutput() );
- image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
- image->SetDirections( m_DiffusionImage->GetDirections() );
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-
- imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
- }
- else if (m_SelectedImage.IsNotNull())
- {
- AccessFixedDimensionByItk(m_SelectedImage, TemplatedResampleImage,3);
- }
-}
-
-
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage)
-{
- itk::Vector< double, 3 > newSpacing;
- itk::ImageRegion<3> newRegion;
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( isDiffusionImage )
+ {
+ typedef itk::ResampleDwiImageFilter< short > ResampleFilter;
+ ResampleFilter::Pointer resampler = ResampleFilter::New();
+ resampler->SetInput( itkVectorImagePointer );
switch (m_Controls->m_ResampleTypeBox->currentIndex())
{
case 0:
{
- itk::Vector< double, 3 > sampling;
- sampling[0] = m_Controls->m_ResampleDoubleX->value();
- sampling[1] = m_Controls->m_ResampleDoubleY->value();
- sampling[2] = m_Controls->m_ResampleDoubleZ->value();
-
- newSpacing = itkImage->GetSpacing();
- newSpacing[0] /= sampling[0];
- newSpacing[1] /= sampling[1];
- newSpacing[2] /= sampling[2];
- newRegion = itkImage->GetLargestPossibleRegion();
- newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
- newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
- newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
-
- break;
+ itk::Vector< double, 3 > samplingFactor;
+ samplingFactor[0] = m_Controls->m_ResampleDoubleX->value();
+ samplingFactor[1] = m_Controls->m_ResampleDoubleY->value();
+ samplingFactor[2] = m_Controls->m_ResampleDoubleZ->value();
+ resampler->SetSamplingFactor(samplingFactor);
+ break;
}
case 1:
{
- newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
- newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
- newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
-
- itk::Vector< double, 3 > oldSpacing = itkImage->GetSpacing();
- itk::Vector< double, 3 > sampling;
- sampling[0] = oldSpacing[0]/newSpacing[0];
- sampling[1] = oldSpacing[1]/newSpacing[1];
- sampling[2] = oldSpacing[2]/newSpacing[2];
- newRegion = itkImage->GetLargestPossibleRegion();
- newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
- newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
- newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
- break;
+ itk::Vector< double, 3 > newSpacing;
+ newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
+ newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
+ newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
+ resampler->SetNewSpacing(newSpacing);
+ break;
}
case 2:
{
- newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
- newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
- newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
-
- itk::ImageRegion<3> oldRegion = itkImage->GetLargestPossibleRegion();
- itk::Vector< double, 3 > sampling;
- sampling[0] = (double)newRegion.GetSize(0)/oldRegion.GetSize(0);
- sampling[1] = (double)newRegion.GetSize(1)/oldRegion.GetSize(1);
- sampling[2] = (double)newRegion.GetSize(2)/oldRegion.GetSize(2);
-
- newSpacing = itkImage->GetSpacing();
- newSpacing[0] /= sampling[0];
- newSpacing[1] /= sampling[1];
- newSpacing[2] /= sampling[2];
- break;
+ itk::ImageRegion<3> newRegion;
+ newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
+ newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
+ newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
+ resampler->SetNewImageSize(newRegion);
+ break;
}
default:
{
- MITK_WARN << "Unknown resampling parameters!";
- return;
+ MITK_WARN << "Unknown resampling parameters!";
+ return;
}
}
- itk::Point<double,3> origin = itkImage->GetOrigin();
- origin[0] -= itkImage->GetSpacing()[0]/2;
- origin[1] -= itkImage->GetSpacing()[1]/2;
- origin[2] -= itkImage->GetSpacing()[2]/2;
- origin[0] += newSpacing[0]/2;
- origin[1] += newSpacing[1]/2;
- origin[2] += newSpacing[2]/2;
-
- typedef itk::Image<TPixel, VImageDimension> ImageType;
- typename ImageType::Pointer outImage = ImageType::New();
- outImage->SetSpacing( newSpacing );
- outImage->SetOrigin( origin );
- outImage->SetDirection( itkImage->GetDirection() );
- outImage->SetLargestPossibleRegion( newRegion );
- outImage->SetBufferedRegion( newRegion );
- outImage->SetRequestedRegion( newRegion );
- outImage->Allocate();
-
- typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilter;
- typename ResampleFilter::Pointer resampler = ResampleFilter::New();
- resampler->SetInput(itkImage);
- resampler->SetOutputParametersFromImage(outImage);
-
QString outAdd;
switch (m_Controls->m_InterpolatorBox->currentIndex())
{
case 0:
{
- typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
- resampler->SetInterpolator(interp);
- outAdd = "NearestNeighbour";
- break;
+ resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
+ outAdd = "NearestNeighbour";
+ break;
}
case 1:
{
- typename itk::LinearInterpolateImageFunction<ImageType>::Pointer interp = itk::LinearInterpolateImageFunction<ImageType>::New();
- resampler->SetInterpolator(interp);
- outAdd = "Linear";
- break;
+ resampler->SetInterpolation(ResampleFilter::Interpolate_Linear);
+ outAdd = "Linear";
+ break;
}
case 2:
{
- typename itk::BSplineInterpolateImageFunction<ImageType>::Pointer interp = itk::BSplineInterpolateImageFunction<ImageType>::New();
- resampler->SetInterpolator(interp);
- outAdd = "BSpline";
- break;
+ resampler->SetInterpolation(ResampleFilter::Interpolate_BSpline);
+ outAdd = "BSpline";
+ break;
}
case 3:
{
- typename itk::WindowedSincInterpolateImageFunction<ImageType, 3>::Pointer interp = itk::WindowedSincInterpolateImageFunction<ImageType, 3>::New();
- resampler->SetInterpolator(interp);
- outAdd = "WindowedSinc";
- break;
+ resampler->SetInterpolation(ResampleFilter::Interpolate_WindowedSinc);
+ outAdd = "WindowedSinc";
+ break;
}
default:
{
- typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
- resampler->SetInterpolator(interp);
- outAdd = "NearestNeighbour";
+ resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
+ outAdd = "NearestNeighbour";
}
}
resampler->Update();
- mitk::Image::Pointer image = mitk::Image::New();
- image->InitializeByItk( resampler->GetOutput() );
- image->SetVolume( resampler->GetOutput()->GetBufferPointer() );
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( resampler->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
- QString name = m_SelectedImageNode->GetName().c_str();
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+ }
+ else if (m_SelectedImage.IsNotNull())
+ {
+ AccessFixedDimensionByItk(m_SelectedImage, TemplatedResampleImage,3);
+ }
}
-void QmitkPreprocessingView::DoApplyDirectionMatrix()
-{
- if (m_DiffusionImage.IsNotNull())
- {
- MitkDwiType::Pointer newDwi = m_DiffusionImage->Clone();
- ItkDwiType::DirectionType newDirection;
- for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
- if (!item)
- return;
- newDirection[r][c] = item->text().toDouble();
- }
-
- ItkDwiType::Pointer itkDwi = newDwi->GetVectorImage();
-
- typedef mitk::DiffusionImage<DiffusionPixelType> MitkDwiType;
- vnl_matrix_fixed< double,3,3 > oldInverseDirection = itkDwi->GetDirection().GetInverse();
- MitkDwiType::GradientDirectionContainerType::Pointer oldGradients = m_DiffusionImage->GetDirectionsWithoutMeasurementFrame();
- MitkDwiType::GradientDirectionContainerType::Pointer newGradients = MitkDwiType::GradientDirectionContainerType::New();
-
- for (unsigned int i=0; i<oldGradients->Size(); i++)
- {
- MitkDwiType::GradientDirectionType g = oldGradients->GetElement(i);
- double mag = g.magnitude();
- MitkDwiType::GradientDirectionType newG = oldInverseDirection*g;
- newG = newDirection.GetVnlMatrix()*newG;
- newG.normalize();
- newGradients->InsertElement(i, newG*mag);
- }
-
- newDwi->SetDirections(newGradients);
- itkDwi->SetDirection(newDirection);
- newDwi->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( newDwi );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_newdirection").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
- mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
- }
- else if (m_SelectedImage.IsNotNull())
- {
- AccessFixedDimensionByItk(m_SelectedImage, TemplatedApplyRotation,3);
- }
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage)
+{
+ itk::Vector< double, 3 > newSpacing;
+ itk::ImageRegion<3> newRegion;
+
+ switch (m_Controls->m_ResampleTypeBox->currentIndex())
+ {
+ case 0:
+ {
+ itk::Vector< double, 3 > sampling;
+ sampling[0] = m_Controls->m_ResampleDoubleX->value();
+ sampling[1] = m_Controls->m_ResampleDoubleY->value();
+ sampling[2] = m_Controls->m_ResampleDoubleZ->value();
+
+ newSpacing = itkImage->GetSpacing();
+ newSpacing[0] /= sampling[0];
+ newSpacing[1] /= sampling[1];
+ newSpacing[2] /= sampling[2];
+ newRegion = itkImage->GetLargestPossibleRegion();
+ newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
+ newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
+ newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
+
+ break;
+ }
+ case 1:
+ {
+ newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
+ newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
+ newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
+
+ itk::Vector< double, 3 > oldSpacing = itkImage->GetSpacing();
+ itk::Vector< double, 3 > sampling;
+ sampling[0] = oldSpacing[0]/newSpacing[0];
+ sampling[1] = oldSpacing[1]/newSpacing[1];
+ sampling[2] = oldSpacing[2]/newSpacing[2];
+ newRegion = itkImage->GetLargestPossibleRegion();
+ newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
+ newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
+ newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
+ break;
+ }
+ case 2:
+ {
+ newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
+ newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
+ newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
+
+ itk::ImageRegion<3> oldRegion = itkImage->GetLargestPossibleRegion();
+ itk::Vector< double, 3 > sampling;
+ sampling[0] = (double)newRegion.GetSize(0)/oldRegion.GetSize(0);
+ sampling[1] = (double)newRegion.GetSize(1)/oldRegion.GetSize(1);
+ sampling[2] = (double)newRegion.GetSize(2)/oldRegion.GetSize(2);
+
+ newSpacing = itkImage->GetSpacing();
+ newSpacing[0] /= sampling[0];
+ newSpacing[1] /= sampling[1];
+ newSpacing[2] /= sampling[2];
+ break;
+ }
+ default:
+ {
+ MITK_WARN << "Unknown resampling parameters!";
+ return;
+ }
+ }
+
+ itk::Point<double,3> origin = itkImage->GetOrigin();
+ origin[0] -= itkImage->GetSpacing()[0]/2;
+ origin[1] -= itkImage->GetSpacing()[1]/2;
+ origin[2] -= itkImage->GetSpacing()[2]/2;
+ origin[0] += newSpacing[0]/2;
+ origin[1] += newSpacing[1]/2;
+ origin[2] += newSpacing[2]/2;
+
+ typedef itk::Image<TPixel, VImageDimension> ImageType;
+ typename ImageType::Pointer outImage = ImageType::New();
+ outImage->SetSpacing( newSpacing );
+ outImage->SetOrigin( origin );
+ outImage->SetDirection( itkImage->GetDirection() );
+ outImage->SetLargestPossibleRegion( newRegion );
+ outImage->SetBufferedRegion( newRegion );
+ outImage->SetRequestedRegion( newRegion );
+ outImage->Allocate();
+
+ typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilter;
+ typename ResampleFilter::Pointer resampler = ResampleFilter::New();
+ resampler->SetInput(itkImage);
+ resampler->SetOutputParametersFromImage(outImage);
+
+ QString outAdd;
+ switch (m_Controls->m_InterpolatorBox->currentIndex())
+ {
+ case 0:
+ {
+ typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
+ resampler->SetInterpolator(interp);
+ outAdd = "NearestNeighbour";
+ break;
+ }
+ case 1:
+ {
+ typename itk::LinearInterpolateImageFunction<ImageType>::Pointer interp = itk::LinearInterpolateImageFunction<ImageType>::New();
+ resampler->SetInterpolator(interp);
+ outAdd = "Linear";
+ break;
+ }
+ case 2:
+ {
+ typename itk::BSplineInterpolateImageFunction<ImageType>::Pointer interp = itk::BSplineInterpolateImageFunction<ImageType>::New();
+ resampler->SetInterpolator(interp);
+ outAdd = "BSpline";
+ break;
+ }
+ case 3:
+ {
+ typename itk::WindowedSincInterpolateImageFunction<ImageType, 3>::Pointer interp = itk::WindowedSincInterpolateImageFunction<ImageType, 3>::New();
+ resampler->SetInterpolator(interp);
+ outAdd = "WindowedSinc";
+ break;
+ }
+ default:
+ {
+ typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
+ resampler->SetInterpolator(interp);
+ outAdd = "NearestNeighbour";
+ }
+ }
+
+ resampler->Update();
+
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk( resampler->GetOutput() );
+ image->SetVolume( resampler->GetOutput()->GetBufferPointer() );
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedImageNode->GetName().c_str();
+
+ imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
}
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage)
+void QmitkPreprocessingView::DoApplyDirectionMatrix()
{
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( isDiffusionImage )
+ {
+ mitk::Image::Pointer newDwi = m_SelectedImage->Clone();
ItkDwiType::DirectionType newDirection;
for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
- if (!item)
- return;
- newDirection[r][c] = item->text().toDouble();
- }
- typedef itk::Image<TPixel, VImageDimension> ImageType;
-
- typename ImageType::Pointer newImage = ImageType::New();
- newImage->SetSpacing( itkImage->GetSpacing() );
- newImage->SetOrigin( itkImage->GetOrigin() );
- newImage->SetDirection( newDirection );
- newImage->SetLargestPossibleRegion( itkImage->GetLargestPossibleRegion() );
- newImage->SetBufferedRegion( itkImage->GetLargestPossibleRegion() );
- newImage->SetRequestedRegion( itkImage->GetLargestPossibleRegion() );
- newImage->Allocate();
- newImage->FillBuffer(0);
-
- itk::ImageRegionIterator< itk::Image<TPixel, VImageDimension> > it(itkImage, itkImage->GetLargestPossibleRegion());
- while(!it.IsAtEnd())
{
- newImage->SetPixel(it.GetIndex(), it.Get());
- ++it;
+ for (int c=0; c<3; c++)
+ {
+ QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+ if (!item)
+ return;
+ newDirection[r][c] = item->text().toDouble();
+ }
}
+ ItkDwiType::Pointer itkDwi = ItkDwiType::New();
+ mitk::CastToItkImage(newDwi, itkDwi);
- mitk::Image::Pointer newMitkImage = mitk::Image::New();
- newMitkImage->InitializeByItk(newImage.GetPointer());
- newMitkImage->SetVolume(newImage->GetBufferPointer());
+ vnl_matrix_fixed< double,3,3 > oldInverseDirection = itkDwi->GetDirection().GetInverse();
+ mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer oldGradients = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+ mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer newGradients = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+
+ for (unsigned int i=0; i<oldGradients->Size(); i++)
+ {
+ mitk::GradientDirectionsProperty::GradientDirectionType g = oldGradients->GetElement(i);
+ double mag = g.magnitude();
+ mitk::GradientDirectionsProperty::GradientDirectionType newG = oldInverseDirection*g;
+ newG = newDirection.GetVnlMatrix()*newG;
+ newG.normalize();
+ newGradients->InsertElement(i, newG*mag);
+ }
+
+ itkDwi->SetDirection(newDirection);
+ newDwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newGradients ) );
+ newDwi->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ newDwi->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+
+ mitk::DiffusionPropertyHelper propertyHelper( newDwi );
+ propertyHelper.InitializeImage();
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( newMitkImage );
- QString name = m_SelectedImageNode->GetName().c_str();
+ imageNode->SetData( newDwi );
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
imageNode->SetName((name+"_newdirection").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ }
+ else if (m_SelectedImage.IsNotNull())
+ {
+ AccessFixedDimensionByItk(m_SelectedImage, TemplatedApplyRotation,3);
+ }
}
-void QmitkPreprocessingView::DoProjectSignal()
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage)
{
- switch(m_Controls->m_ProjectionMethodBox->currentIndex())
+ ItkDwiType::DirectionType newDirection;
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
{
- case 0:
- DoADCAverage();
- break;
- case 1:
- DoAKCFit();
- break;
- case 2:
- DoBiExpFit();
- break;
- default:
- DoADCAverage();
+ QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+ if (!item)
+ return;
+ newDirection[r][c] = item->text().toDouble();
}
+ typedef itk::Image<TPixel, VImageDimension> ImageType;
+
+ typename ImageType::Pointer newImage = ImageType::New();
+ newImage->SetSpacing( itkImage->GetSpacing() );
+ newImage->SetOrigin( itkImage->GetOrigin() );
+ newImage->SetDirection( newDirection );
+ newImage->SetLargestPossibleRegion( itkImage->GetLargestPossibleRegion() );
+ newImage->SetBufferedRegion( itkImage->GetLargestPossibleRegion() );
+ newImage->SetRequestedRegion( itkImage->GetLargestPossibleRegion() );
+ newImage->Allocate();
+ newImage->FillBuffer(0);
+
+ itk::ImageRegionIterator< itk::Image<TPixel, VImageDimension> > it(itkImage, itkImage->GetLargestPossibleRegion());
+ while(!it.IsAtEnd())
+ {
+ newImage->SetPixel(it.GetIndex(), it.Get());
+ ++it;
+ }
+
+ mitk::Image::Pointer newMitkImage = mitk::Image::New();
+ newMitkImage->InitializeByItk(newImage.GetPointer());
+ newMitkImage->SetVolume(newImage->GetBufferPointer());
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( newMitkImage );
+ QString name = m_SelectedImageNode->GetName().c_str();
+ imageNode->SetName((name+"_newdirection").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+
+ mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
-void QmitkPreprocessingView::DoDwiNormalization()
+void QmitkPreprocessingView::DoProjectSignal()
{
- if (m_DiffusionImage.IsNull())
- return;
-
- int b0Index = -1;
- for (unsigned int i=0; i<m_DiffusionImage->GetNumberOfChannels(); i++)
- {
- GradientDirectionType g = m_DiffusionImage->GetDirections()->GetElement(i);
- if (g.magnitude()<0.001)
- {
- b0Index = i;
- break;
- }
- }
- if (b0Index==-1)
- return;
+ switch(m_Controls->m_ProjectionMethodBox->currentIndex())
+ {
+ case 0:
+ DoADCAverage();
+ break;
+ case 1:
+ DoAKCFit();
+ break;
+ case 2:
+ DoBiExpFit();
+ break;
+ default:
+ DoADCAverage();
+ }
+}
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef itk::DwiNormilzationFilter<short> FilterType;
+void QmitkPreprocessingView::DoDwiNormalization()
+{
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( ! isDiffusionImage )
+ return;
- FilterType::Pointer filter = FilterType::New();
- filter->SetInput(m_DiffusionImage->GetVectorImage());
- filter->SetGradientDirections(m_DiffusionImage->GetDirections());
+ GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
- UcharImageType::Pointer itkImage = NULL;
- if (m_Controls->m_NormalizationMaskBox->GetSelectedNode().IsNotNull())
+ int b0Index = -1;
+ for (unsigned int i=0; i<gradientContainer->size(); i++)
+ {
+ GradientDirectionType g = gradientContainer->GetElement(i);
+ if (g.magnitude()<0.001)
{
- itkImage = UcharImageType::New();
- mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_NormalizationMaskBox->GetSelectedNode()->GetData()), itkImage);
- filter->SetMaskImage(itkImage);
+ b0Index = i;
+ break;
}
-
- // determin normalization reference
- switch(m_Controls->m_NormalizationReferenceBox->currentIndex())
+ }
+ if (b0Index==-1)
+ return;
+
+ typedef itk::DwiNormilzationFilter<short> FilterType;
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput( itkVectorImagePointer );
+ filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+
+ UcharImageType::Pointer itkImage = NULL;
+ if (m_Controls->m_NormalizationMaskBox->GetSelectedNode().IsNotNull())
+ {
+ itkImage = UcharImageType::New();
+ mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_NormalizationMaskBox->GetSelectedNode()->GetData()), itkImage);
+ filter->SetMaskImage(itkImage);
+ }
+
+ // determin normalization reference
+ switch(m_Controls->m_NormalizationReferenceBox->currentIndex())
+ {
+ case 0: // normalize relative to mean white matter signal intensity
+ {
+ typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
+ TensorReconstructionImageFilterType::Pointer dtFilter = TensorReconstructionImageFilterType::New();
+ dtFilter->SetGradientImage( gradientContainer, itkVectorImagePointer );
+ dtFilter->SetBValue( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ dtFilter->Update();
+ itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = dtFilter->GetOutput();
+ itk::ImageRegionIterator< itk::Image< itk::DiffusionTensor3D< double >, 3 > > inIt(tensorImage, tensorImage->GetLargestPossibleRegion());
+ double ref = 0;
+ unsigned int count = 0;
+ while ( !inIt.IsAtEnd() )
{
- case 0: // normalize relative to mean white matter signal intensity
- {
- typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
- TensorReconstructionImageFilterType::Pointer dtFilter = TensorReconstructionImageFilterType::New();
- dtFilter->SetGradientImage( m_DiffusionImage->GetDirections(), m_DiffusionImage->GetVectorImage() );
- dtFilter->SetBValue(m_DiffusionImage->GetReferenceBValue());
- dtFilter->Update();
- itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = dtFilter->GetOutput();
- itk::ImageRegionIterator< itk::Image< itk::DiffusionTensor3D< double >, 3 > > inIt(tensorImage, tensorImage->GetLargestPossibleRegion());
- double ref = 0;
- unsigned int count = 0;
- while ( !inIt.IsAtEnd() )
- {
- if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
- {
- ++inIt;
- continue;
- }
-
- double FA = inIt.Get().GetFractionalAnisotropy();
- if (FA>0.4 && FA<0.99)
- {
- ref += m_DiffusionImage->GetVectorImage()->GetPixel(inIt.GetIndex())[b0Index];
- count++;
- }
- ++inIt;
- }
- if (count>0)
- {
- ref /= count;
- filter->SetUseGlobalReference(true);
- filter->SetReference(ref);
- }
- break;
+ if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
+ {
+ ++inIt;
+ continue;
+ }
+
+ double FA = inIt.Get().GetFractionalAnisotropy();
+ if (FA>0.4 && FA<0.99)
+ {
+ ref += itkVectorImagePointer->GetPixel(inIt.GetIndex())[b0Index];
+ count++;
+ }
+ ++inIt;
}
- case 1: // normalize relative to mean CSF signal intensity
+ if (count>0)
{
- itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
- adcFilter->SetInput(m_DiffusionImage->GetVectorImage());
- adcFilter->SetGradientDirections(m_DiffusionImage->GetDirections());
- adcFilter->SetB_value(m_DiffusionImage->GetReferenceBValue());
- adcFilter->Update();
- ItkDoubleImageType::Pointer adcImage = adcFilter->GetOutput();
- itk::ImageRegionIterator<ItkDoubleImageType> inIt(adcImage, adcImage->GetLargestPossibleRegion());
- double max = 0.0030;
- double ref = 0;
- unsigned int count = 0;
- while ( !inIt.IsAtEnd() )
- {
- if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
- {
- ++inIt;
- continue;
- }
- if (inIt.Get()>max && inIt.Get()<0.004)
- {
- ref += m_DiffusionImage->GetVectorImage()->GetPixel(inIt.GetIndex())[b0Index];
- count++;
- }
- ++inIt;
- }
- if (count>0)
- {
- ref /= count;
- filter->SetUseGlobalReference(true);
- filter->SetReference(ref);
- }
- break;
+ ref /= count;
+ filter->SetUseGlobalReference(true);
+ filter->SetReference(ref);
}
- case 2:
+ break;
+ }
+ case 1: // normalize relative to mean CSF signal intensity
+ {
+ itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
+ adcFilter->SetInput( itkVectorImagePointer );
+ adcFilter->SetGradientDirections( gradientContainer);
+ adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ adcFilter->Update();
+ ItkDoubleImageType::Pointer adcImage = adcFilter->GetOutput();
+ itk::ImageRegionIterator<ItkDoubleImageType> inIt(adcImage, adcImage->GetLargestPossibleRegion());
+ double max = 0.0030;
+ double ref = 0;
+ unsigned int count = 0;
+ while ( !inIt.IsAtEnd() )
{
- filter->SetUseGlobalReference(false);
+ if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
+ {
+ ++inIt;
+ continue;
+ }
+ if (inIt.Get()>max && inIt.Get()<0.004)
+ {
+ ref += itkVectorImagePointer->GetPixel(inIt.GetIndex())[b0Index];
+ count++;
+ }
+ ++inIt;
}
+ if (count>0)
+ {
+ ref /= count;
+ filter->SetUseGlobalReference(true);
+ filter->SetReference(ref);
}
- filter->Update();
-
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
- image->SetDirections( m_DiffusionImage->GetDirections() );
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-
- imageNode->SetName((name+"_normalized").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+ break;
+ }
+ case 2:
+ {
+ filter->SetUseGlobalReference(false);
+ }
+ }
+ filter->Update();
+
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+
+ imageNode->SetName((name+"_normalized").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
}
void QmitkPreprocessingView::DoLengthCorrection()
{
- if (m_DiffusionImage.IsNull())
- return;
-
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef itk::DwiGradientLengthCorrectionFilter FilterType;
-
- FilterType::Pointer filter = FilterType::New();
- filter->SetRoundingValue( m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
- filter->SetReferenceBValue(m_DiffusionImage->GetReferenceBValue());
- filter->SetReferenceGradientDirectionContainer(m_DiffusionImage->GetDirections());
- filter->Update();
-
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage( m_DiffusionImage->GetVectorImage());
- image->SetReferenceBValue( filter->GetNewBValue() );
- image->SetDirections( filter->GetOutputGradientDirectionContainer());
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-
- imageNode->SetName((name+"_rounded").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( ! isDiffusionImage )
+ return;
+
+ typedef itk::DwiGradientLengthCorrectionFilter FilterType;
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetRoundingValue( m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
+ filter->SetReferenceBValue( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ filter->SetReferenceGradientDirectionContainer( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ filter->Update();
+
+ mitk::Image::Pointer image = mitk::ImportItkImage( itkVectorImagePointer );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradientDirectionContainer() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetNewBValue() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+
+ imageNode->SetName((name+"_rounded").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
}
void QmitkPreprocessingView::UpdateDwiBValueMapRounder(int i)
{
- if (m_DiffusionImage.IsNull())
- return;
- //m_DiffusionImage->UpdateBValueMap();
- UpdateBValueTableWidget(i);
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( ! isDiffusionImage )
+ return;
+ //m_DiffusionImage->UpdateBValueMap();
+ UpdateBValueTableWidget(i);
}
-void QmitkPreprocessingView::CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::DiffusionImage<DiffusionPixelType>::Pointer ImPtr, QString imageName, mitk::DataNode* parent)
+void QmitkPreprocessingView::CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::Image::Pointer ImPtr, QString imageName, mitk::DataNode* parent)
{
- typedef itk::RadialMultishellToSingleshellImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
-
- // filter input parameter
- const mitk::DiffusionImage<DiffusionPixelType>::BValueMap
- &originalShellMap = ImPtr->GetBValueMap();
+ typedef itk::RadialMultishellToSingleshellImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
+
+ // filter input parameter
+ const mitk::BValueMapProperty::BValueMap
+ &originalShellMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+ ItkDwiType
+ *vectorImage = itkVectorImagePointer.GetPointer();
+
+ const mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer
+ gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+ const unsigned int
+ &bValue = static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+
+ mitk::DataNode::Pointer imageNode = 0;
+
+ // filter call
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput(vectorImage);
+ filter->SetOriginalGradientDirections(gradientContainer);
+ filter->SetOriginalBValueMap(originalShellMap);
+ filter->SetOriginalBValue(bValue);
+ filter->SetFunctor(functor);
+ filter->Update();
+
+ // create new DWI image
+ mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( m_Controls->m_targetBValueSpinBox->value() ) );
+ outImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( outImage );
+ propertyHelper.InitializeImage();
+
+ imageNode = mitk::DataNode::New();
+ imageNode->SetData( outImage );
+ imageNode->SetName(imageName.toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, parent);
+
+ // if(m_Controls->m_OutputRMSErrorImage->isChecked()){
+ // // create new Error image
+ // FilterType::ErrorImageType::Pointer errImage = filter->GetErrorImage();
+ // mitk::Image::Pointer mitkErrImage = mitk::Image::New();
+ // mitkErrImage->InitializeByItk<FilterType::ErrorImageType>(errImage);
+ // mitkErrImage->SetVolume(errImage->GetBufferPointer());
+
+ // imageNode = mitk::DataNode::New();
+ // imageNode->SetData( mitkErrImage );
+ // imageNode->SetName((imageName+"_Error").toStdString().c_str());
+ // GetDefaultDataStorage()->Add(imageNode);
+ // }
+}
- const mitk::DiffusionImage<DiffusionPixelType>::ImageType
- *vectorImage = ImPtr->GetVectorImage();
+void QmitkPreprocessingView::DoBiExpFit()
+{
+ itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
- const mitk::DiffusionImage<DiffusionPixelType>::GradientDirectionContainerType::Pointer
- gradientContainer = ImPtr->GetDirections();
+ for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+ {
+ mitk::Image::Pointer inImage =
+ dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
- const unsigned int
- &bValue = ImPtr->GetReferenceBValue();
+ QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
- mitk::DataNode::Pointer imageNode = 0;
+ const mitk::BValueMapProperty::BValueMap
+ &originalShellMap = static_cast<mitk::BValueMapProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
- // filter call
- FilterType::Pointer filter = FilterType::New();
- filter->SetInput(vectorImage);
- filter->SetOriginalGradientDirections(gradientContainer);
- filter->SetOriginalBValueMap(originalShellMap);
- filter->SetOriginalBValue(bValue);
- filter->SetFunctor(functor);
- filter->Update();
+ mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
+ ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
+ vnl_vector<double> bValueList(originalShellMap.size()-1);
+ while(it != originalShellMap.end())
+ bValueList.put(s++,(it++)->first);
- // create new DWI image
- mitk::DiffusionImage<DiffusionPixelType>::Pointer outImage = mitk::DiffusionImage<DiffusionPixelType>::New();
- outImage->SetVectorImage( filter->GetOutput() );
- outImage->SetReferenceBValue( m_Controls->m_targetBValueSpinBox->value() );
- outImage->SetDirections( filter->GetTargetGradientDirections() );
- outImage->InitializeFromVectorImage();
-
- imageNode = mitk::DataNode::New();
- imageNode->SetData( outImage );
- imageNode->SetName(imageName.toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, parent);
-
- // if(m_Controls->m_OutputRMSErrorImage->isChecked()){
- // // create new Error image
- // FilterType::ErrorImageType::Pointer errImage = filter->GetErrorImage();
- // mitk::Image::Pointer mitkErrImage = mitk::Image::New();
- // mitkErrImage->InitializeByItk<FilterType::ErrorImageType>(errImage);
- // mitkErrImage->SetVolume(errImage->GetBufferPointer());
-
- // imageNode = mitk::DataNode::New();
- // imageNode->SetData( mitkErrImage );
- // imageNode->SetName((imageName+"_Error").toStdString().c_str());
- // GetDefaultDataStorage()->Add(imageNode);
- // }
+ const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
+ functor->setListOfBValues(bValueList);
+ functor->setTargetBValue(targetBValue);
+ CallMultishellToSingleShellFilter(functor,inImage,name + "_BiExp", m_SelectedDiffusionNodes.at(i));
+ }
}
-void QmitkPreprocessingView::DoBiExpFit()
+void QmitkPreprocessingView::DoAKCFit()
{
- itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
+ itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
- for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
- {
- mitk::DiffusionImage<DiffusionPixelType>::Pointer inImage =
- dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >(m_SelectedDiffusionNodes.at(i)->GetData());
-
- QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
-
- const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & originalShellMap = inImage->GetBValueMap();
- mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = originalShellMap.begin();
- ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
- vnl_vector<double> bValueList(originalShellMap.size()-1);
- while(it != originalShellMap.end())
- bValueList.put(s++,(it++)->first);
-
- const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
- functor->setListOfBValues(bValueList);
- functor->setTargetBValue(targetBValue);
- CallMultishellToSingleShellFilter(functor,inImage,name + "_BiExp", m_SelectedDiffusionNodes.at(i));
- }
-}
+ for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+ {
+ mitk::Image::Pointer inImage =
+ dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
-void QmitkPreprocessingView::DoAKCFit()
-{
- itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
+ QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
- for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
- {
- mitk::DiffusionImage<DiffusionPixelType>::Pointer inImage =
- dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >(m_SelectedDiffusionNodes.at(i)->GetData());
-
- QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
-
- const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & originalShellMap = inImage->GetBValueMap();
- mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = originalShellMap.begin();
- ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
- vnl_vector<double> bValueList(originalShellMap.size()-1);
- while(it != originalShellMap.end())
- bValueList.put(s++,(it++)->first);
-
- const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
- functor->setListOfBValues(bValueList);
- functor->setTargetBValue(targetBValue);
- CallMultishellToSingleShellFilter(functor,inImage,name + "_AKC", m_SelectedDiffusionNodes.at(i));
- }
+ const mitk::BValueMapProperty::BValueMap
+ &originalShellMap = static_cast<mitk::BValueMapProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+ mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
+ ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
+ vnl_vector<double> bValueList(originalShellMap.size()-1);
+ while(it != originalShellMap.end())
+ bValueList.put(s++,(it++)->first);
+
+ const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
+ functor->setListOfBValues(bValueList);
+ functor->setTargetBValue(targetBValue);
+ CallMultishellToSingleShellFilter(functor,inImage,name + "_AKC", m_SelectedDiffusionNodes.at(i));
+ }
}
void QmitkPreprocessingView::DoADCFit()
{
- // later
+ // later
}
void QmitkPreprocessingView::DoADCAverage()
{
- itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
+ itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
- for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
- {
- mitk::DiffusionImage<DiffusionPixelType>::Pointer inImage =
- dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >(m_SelectedDiffusionNodes.at(i)->GetData());
-
- QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
-
- const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & originalShellMap = inImage->GetBValueMap();
- mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = originalShellMap.begin();
- ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
- vnl_vector<double> bValueList(originalShellMap.size()-1);
- while(it != originalShellMap.end())
- bValueList.put(s++,(it++)->first);
-
- const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
- functor->setListOfBValues(bValueList);
- functor->setTargetBValue(targetBValue);
- CallMultishellToSingleShellFilter(functor,inImage,name + "_ADC", m_SelectedDiffusionNodes.at(i));
- }
+ for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+ {
+ mitk::Image::Pointer inImage =
+ dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
+
+ QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
+
+ const mitk::BValueMapProperty::BValueMap
+ &originalShellMap = static_cast<mitk::BValueMapProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+ mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
+ ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
+ vnl_vector<double> bValueList(originalShellMap.size()-1);
+ while(it != originalShellMap.end())
+ bValueList.put(s++,(it++)->first);
+
+ const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
+ functor->setListOfBValues(bValueList);
+ functor->setTargetBValue(targetBValue);
+ CallMultishellToSingleShellFilter(functor,inImage,name + "_ADC", m_SelectedDiffusionNodes.at(i));
+ }
}
void QmitkPreprocessingView::DoAdcCalculation()
{
- if (m_DiffusionImage.IsNull())
- return;
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( ! isDiffusionImage )
+ return;
- typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
- typedef itk::AdcImageFilter< DiffusionPixelType, double > FilterType;
+ typedef itk::AdcImageFilter< DiffusionPixelType, double > FilterType;
- for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
- {
- DiffusionImageType::Pointer inImage = dynamic_cast< DiffusionImageType* >(m_SelectedDiffusionNodes.at(i)->GetData());
- FilterType::Pointer filter = FilterType::New();
- filter->SetInput(inImage->GetVectorImage());
- filter->SetGradientDirections(inImage->GetDirections());
- filter->SetB_value(inImage->GetReferenceBValue());
- filter->Update();
-
- mitk::Image::Pointer image = mitk::Image::New();
- image->InitializeByItk( filter->GetOutput() );
- image->SetVolume( filter->GetOutput()->GetBufferPointer() );
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- QString name = m_SelectedDiffusionNodes.at(i)->GetName().c_str();
-
- imageNode->SetName((name+"_ADC").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.at(i));
- }
+ for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+ {
+ mitk::Image::Pointer inImage = dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(inImage, itkVectorImagePointer);
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput( itkVectorImagePointer );
+ filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( inImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ filter->SetB_value( static_cast<mitk::FloatProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ filter->Update();
+
+ mitk::Image::Pointer image = mitk::Image::New();
+ image->InitializeByItk( filter->GetOutput() );
+ image->SetVolume( filter->GetOutput()->GetBufferPointer() );
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ QString name = m_SelectedDiffusionNodes.at(i)->GetName().c_str();
+
+ imageNode->SetName((name+"_ADC").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.at(i));
+ }
}
void QmitkPreprocessingView::UpdateBValueTableWidget(int i)
{
- if (m_DiffusionImage.IsNull())
+ bool isDiffusionImage(false);
+ if( m_SelectedImageNode && m_SelectedImageNode.IsNotNull() )
+ {
+ isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData()));
+ }
+
+ if ( ! isDiffusionImage )
+ {
+ m_Controls->m_B_ValueMap_TableWidget->clear();
+ m_Controls->m_B_ValueMap_TableWidget->setRowCount(1);
+ QStringList headerList;
+ headerList << "b-Value" << "Number of gradients";
+ m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
+ m_Controls->m_B_ValueMap_TableWidget->setItem(0,0,new QTableWidgetItem("-"));
+ m_Controls->m_B_ValueMap_TableWidget->setItem(0,1,new QTableWidgetItem("-"));
+ }else{
+
+ typedef mitk::BValueMapProperty::BValueMap BValueMap;
+ typedef mitk::BValueMapProperty::BValueMap::iterator BValueMapIterator;
+
+ BValueMapIterator it;
+
+ BValueMap roundedBValueMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+ m_Controls->m_B_ValueMap_TableWidget->clear();
+ m_Controls->m_B_ValueMap_TableWidget->setRowCount(roundedBValueMap.size() );
+ QStringList headerList;
+ headerList << "b-Value" << "Number of gradients";
+ m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
+
+ int i = 0 ;
+ for(it = roundedBValueMap.begin() ;it != roundedBValueMap.end(); it++)
{
- m_Controls->m_B_ValueMap_TableWidget->clear();
- m_Controls->m_B_ValueMap_TableWidget->setRowCount(1);
- QStringList headerList;
- headerList << "b-Value" << "Number of gradients";
- m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
- m_Controls->m_B_ValueMap_TableWidget->setItem(0,0,new QTableWidgetItem("-"));
- m_Controls->m_B_ValueMap_TableWidget->setItem(0,1,new QTableWidgetItem("-"));
- }else{
-
- typedef mitk::DiffusionImage<short>::BValueMap BValueMap;
- typedef mitk::DiffusionImage<short>::BValueMap::iterator BValueMapIterator;
-
- BValueMapIterator it;
-
- BValueMap roundedBValueMap = m_DiffusionImage->GetBValueMap();
-
- m_Controls->m_B_ValueMap_TableWidget->clear();
- m_Controls->m_B_ValueMap_TableWidget->setRowCount(roundedBValueMap.size() );
- QStringList headerList;
- headerList << "b-Value" << "Number of gradients";
- m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
-
- int i = 0 ;
- for(it = roundedBValueMap.begin() ;it != roundedBValueMap.end(); it++)
- {
- m_Controls->m_B_ValueMap_TableWidget->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
- QTableWidgetItem* item = m_Controls->m_B_ValueMap_TableWidget->item(i,0);
- item->setFlags(item->flags() & ~Qt::ItemIsEditable);
- m_Controls->m_B_ValueMap_TableWidget->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
- i++;
- }
+ m_Controls->m_B_ValueMap_TableWidget->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
+ QTableWidgetItem* item = m_Controls->m_B_ValueMap_TableWidget->item(i,0);
+ item->setFlags(item->flags() & ~Qt::ItemIsEditable);
+ m_Controls->m_B_ValueMap_TableWidget->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
+ i++;
}
+ }
}
template < typename TPixel, unsigned int VImageDimension >
void QmitkPreprocessingView::TemplatedUpdateGui( itk::Image<TPixel, VImageDimension>* itkImage)
{
- for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
- delete item;
- item = new QTableWidgetItem();
- item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
- item->setText(QString::number(itkImage->GetDirection()[r][c]));
- m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
- }
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
+ {
+ QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+ delete item;
+ item = new QTableWidgetItem();
+ item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
+ item->setText(QString::number(itkImage->GetDirection()[r][c]));
+ m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
+ }
}
void QmitkPreprocessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
- bool foundDwiVolume = false;
- bool foundImageVolume = false;
- m_DiffusionImage = NULL;
- m_SelectedImage = NULL;
- m_SelectedImageNode = NULL;
- m_SelectedDiffusionNodes.clear();
-
- // iterate selection
- for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+ bool foundDwiVolume = false;
+ bool foundImageVolume = false;
+ m_SelectedImage = NULL;
+ m_SelectedImageNode = NULL;
+ m_SelectedDiffusionNodes.clear();
+
+ // iterate selection
+ for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+ {
+ mitk::DataNode::Pointer node = *it;
+
+ if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
- mitk::DataNode::Pointer node = *it;
+ foundImageVolume = true;
+ m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
+ m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
+ m_SelectedImageNode = node;
+
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if( isDiffusionImage )
+ {
+ foundDwiVolume = true;
+ m_SelectedDiffusionNodes.push_back(node);
+ }
+ }
+ }
+
+ m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
+ m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);
+ m_Controls->m_CheckExtractAll->setEnabled(foundDwiVolume);
+ m_Controls->m_ModifyMeasurementFrame->setEnabled(foundDwiVolume);
+ m_Controls->m_MeasurementFrameTable->setEnabled(foundDwiVolume);
+ m_Controls->m_ReduceGradientsButton->setEnabled(foundDwiVolume);
+ m_Controls->m_ShowGradientsButton->setEnabled(foundDwiVolume);
+ m_Controls->m_MirrorGradientToHalfSphereButton->setEnabled(foundDwiVolume);
+ m_Controls->m_MergeDwisButton->setEnabled(foundDwiVolume);
+ m_Controls->m_B_ValueMap_Rounder_SpinBox->setEnabled(foundDwiVolume);
+ m_Controls->m_ProjectSignalButton->setEnabled(foundDwiVolume);
+ m_Controls->m_CreateLengthCorrectedDwi->setEnabled(foundDwiVolume);
+ m_Controls->m_CalcAdcButton->setEnabled(foundDwiVolume);
+ m_Controls->m_targetBValueSpinBox->setEnabled(foundDwiVolume);
+ m_Controls->m_NormalizeImageValuesButton->setEnabled(foundDwiVolume);
+ m_Controls->m_DirectionMatrixTable->setEnabled(foundImageVolume);
+ m_Controls->m_ModifyDirection->setEnabled(foundImageVolume);
+ m_Controls->m_ExtractBrainMask->setEnabled(foundImageVolume);
+ m_Controls->m_ResampleImageButton->setEnabled(foundImageVolume);
+ m_Controls->m_ModifySpacingButton->setEnabled(foundImageVolume);
+ m_Controls->m_ModifyOriginButton->setEnabled(foundImageVolume);
+ m_Controls->m_CropImageButton->setEnabled(foundImageVolume);
+ m_Controls->m_RemoveGradientButton->setEnabled(foundDwiVolume);
+ m_Controls->m_ExtractGradientButton->setEnabled(foundDwiVolume);
+
+ // reset sampling frame to 1 and update all ealted components
+ m_Controls->m_B_ValueMap_Rounder_SpinBox->setValue(1);
+
+ UpdateBValueTableWidget(m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
+ DoUpdateInterpolationGui(m_Controls->m_ResampleTypeBox->currentIndex());
+
+ if( m_SelectedImageNode.IsNull() )
+ {
+ return;
+ }
+
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+
+ if (foundDwiVolume && isDiffusionImage)
+ {
+ m_Controls->m_InputData->setTitle("Input Data");
+ vnl_matrix_fixed< double, 3, 3 > mf = static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
+ {
+ // Measurement frame
+ {
+ QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+ delete item;
+ item = new QTableWidgetItem();
+ item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
+ item->setText(QString::number(mf.get(r,c)));
+ m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
+ }
- if( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+ // Direction matrix
{
- foundDwiVolume = true;
- foundImageVolume = true;
- m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(node->GetData());
- m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
- m_SelectedDiffusionNodes.push_back(node);
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+ delete item;
+ item = new QTableWidgetItem();
+ item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
+ item->setText(QString::number(itkVectorImagePointer->GetDirection()[r][c]));
+ m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
}
- else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
+ }
+
+ //calculate target bValue for MultishellToSingleShellfilter
+ const mitk::BValueMapProperty::BValueMap & bValMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+ mitk::BValueMapProperty::BValueMap::const_iterator it = bValMap.begin();
+ unsigned int targetBVal = 0;
+ while(it != bValMap.end())
+ targetBVal += (it++)->first;
+ targetBVal /= (float)bValMap.size()-1;
+ m_Controls->m_targetBValueSpinBox->setValue(targetBVal);
+
+ m_Controls->m_HeaderSpacingX->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[0]);
+ m_Controls->m_HeaderSpacingY->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[1]);
+ m_Controls->m_HeaderSpacingZ->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[2]);
+ m_Controls->m_HeaderOriginX->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[0]);
+ m_Controls->m_HeaderOriginY->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[1]);
+ m_Controls->m_HeaderOriginZ->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[2]);
+ m_Controls->m_XstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+ m_Controls->m_YstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+ m_Controls->m_ZstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+ m_Controls->m_XendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+ m_Controls->m_YendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+ m_Controls->m_ZendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+ m_Controls->m_RemoveGradientBox->setMaximum(static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size()-1);
+ m_Controls->m_ExtractGradientBox->setMaximum(static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size()-1);
+ }
+ else if (foundImageVolume)
+ {
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
+ {
+ QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+ delete item;
+ item = new QTableWidgetItem();
+ m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
+ }
+
+ m_Controls->m_HeaderSpacingX->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[0]);
+ m_Controls->m_HeaderSpacingY->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[1]);
+ m_Controls->m_HeaderSpacingZ->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[2]);
+ m_Controls->m_HeaderOriginX->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[0]);
+ m_Controls->m_HeaderOriginY->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[1]);
+ m_Controls->m_HeaderOriginZ->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[2]);
+ m_Controls->m_XstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+ m_Controls->m_YstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+ m_Controls->m_ZstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+ m_Controls->m_XendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+ m_Controls->m_YendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+ m_Controls->m_ZendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+
+ AccessFixedDimensionByItk(m_SelectedImage, TemplatedUpdateGui,3);
+ }
+ else
+ {
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
+ {
{
- foundImageVolume = true;
- m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
- m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
- m_SelectedImageNode = node;
+ QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+ delete item;
+ item = new QTableWidgetItem();
+ m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
}
- }
+ {
+ QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+ delete item;
+ item = new QTableWidgetItem();
+ m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
+ }
+ }
- m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
- m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);
- m_Controls->m_CheckExtractAll->setEnabled(foundDwiVolume);
- m_Controls->m_ModifyMeasurementFrame->setEnabled(foundDwiVolume);
- m_Controls->m_MeasurementFrameTable->setEnabled(foundDwiVolume);
- m_Controls->m_ReduceGradientsButton->setEnabled(foundDwiVolume);
- m_Controls->m_ShowGradientsButton->setEnabled(foundDwiVolume);
- m_Controls->m_MirrorGradientToHalfSphereButton->setEnabled(foundDwiVolume);
- m_Controls->m_MergeDwisButton->setEnabled(foundDwiVolume);
- m_Controls->m_B_ValueMap_Rounder_SpinBox->setEnabled(foundDwiVolume);
- m_Controls->m_ProjectSignalButton->setEnabled(foundDwiVolume);
- m_Controls->m_CreateLengthCorrectedDwi->setEnabled(foundDwiVolume);
- m_Controls->m_CalcAdcButton->setEnabled(foundDwiVolume);
- m_Controls->m_targetBValueSpinBox->setEnabled(foundDwiVolume);
- m_Controls->m_NormalizeImageValuesButton->setEnabled(foundDwiVolume);
- m_Controls->m_DirectionMatrixTable->setEnabled(foundImageVolume);
- m_Controls->m_ModifyDirection->setEnabled(foundImageVolume);
- m_Controls->m_ExtractBrainMask->setEnabled(foundImageVolume);
- m_Controls->m_ResampleImageButton->setEnabled(foundImageVolume);
- m_Controls->m_ModifySpacingButton->setEnabled(foundImageVolume);
- m_Controls->m_ModifyOriginButton->setEnabled(foundImageVolume);
- m_Controls->m_CropImageButton->setEnabled(foundImageVolume);
- m_Controls->m_RemoveGradientButton->setEnabled(foundDwiVolume);
- m_Controls->m_ExtractGradientButton->setEnabled(foundDwiVolume);
-
- // reset sampling frame to 1 and update all ealted components
- m_Controls->m_B_ValueMap_Rounder_SpinBox->setValue(1);
-
- UpdateBValueTableWidget(m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
- DoUpdateInterpolationGui(m_Controls->m_ResampleTypeBox->currentIndex());
-
- if (foundDwiVolume)
- {
- m_Controls->m_InputData->setTitle("Input Data");
- vnl_matrix_fixed< double, 3, 3 > mf = m_DiffusionImage->GetMeasurementFrame();
- for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- // Measurement frame
- {
- QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
- delete item;
- item = new QTableWidgetItem();
- item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
- item->setText(QString::number(mf.get(r,c)));
- m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
- }
-
- // Direction matrix
- {
- QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
- delete item;
- item = new QTableWidgetItem();
- item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
- item->setText(QString::number(m_DiffusionImage->GetVectorImage()->GetDirection()[r][c]));
- m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
- }
- }
-
- //calculate target bValue for MultishellToSingleShellfilter
- const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & bValMap = m_DiffusionImage->GetBValueMap();
- mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = bValMap.begin();
- unsigned int targetBVal = 0;
- while(it != bValMap.end())
- targetBVal += (it++)->first;
- targetBVal /= (float)bValMap.size()-1;
- m_Controls->m_targetBValueSpinBox->setValue(targetBVal);
-
- m_Controls->m_HeaderSpacingX->setValue(m_DiffusionImage->GetGeometry()->GetSpacing()[0]);
- m_Controls->m_HeaderSpacingY->setValue(m_DiffusionImage->GetGeometry()->GetSpacing()[1]);
- m_Controls->m_HeaderSpacingZ->setValue(m_DiffusionImage->GetGeometry()->GetSpacing()[2]);
- m_Controls->m_HeaderOriginX->setValue(m_DiffusionImage->GetGeometry()->GetOrigin()[0]);
- m_Controls->m_HeaderOriginY->setValue(m_DiffusionImage->GetGeometry()->GetOrigin()[1]);
- m_Controls->m_HeaderOriginZ->setValue(m_DiffusionImage->GetGeometry()->GetOrigin()[2]);
- m_Controls->m_XstartBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(0)-1);
- m_Controls->m_YstartBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(1)-1);
- m_Controls->m_ZstartBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(2)-1);
- m_Controls->m_XendBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(0)-1);
- m_Controls->m_YendBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(1)-1);
- m_Controls->m_ZendBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(2)-1);
- m_Controls->m_RemoveGradientBox->setMaximum(m_DiffusionImage->GetDirections()->Size()-1);
- m_Controls->m_ExtractGradientBox->setMaximum(m_DiffusionImage->GetDirections()->Size()-1);
- }
- else if (foundImageVolume)
- {
- for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
- delete item;
- item = new QTableWidgetItem();
- m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
- }
-
- m_Controls->m_HeaderSpacingX->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[0]);
- m_Controls->m_HeaderSpacingY->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[1]);
- m_Controls->m_HeaderSpacingZ->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[2]);
- m_Controls->m_HeaderOriginX->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[0]);
- m_Controls->m_HeaderOriginY->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[1]);
- m_Controls->m_HeaderOriginZ->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[2]);
- m_Controls->m_XstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
- m_Controls->m_YstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
- m_Controls->m_ZstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
- m_Controls->m_XendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
- m_Controls->m_YendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
- m_Controls->m_ZendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
-
- AccessFixedDimensionByItk(m_SelectedImage, TemplatedUpdateGui,3);
- }
- else
- {
- for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- {
- QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
- delete item;
- item = new QTableWidgetItem();
- m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
- }
- {
- QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
- delete item;
- item = new QTableWidgetItem();
- m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
- }
- }
-
- m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
- m_Controls->m_InputData->setTitle("Please Select Input Data");
- }
+ m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
+ m_Controls->m_InputData->setTitle("Please Select Input Data");
+ }
}
void QmitkPreprocessingView::Activated()
{
- QmitkFunctionality::Activated();
+ QmitkFunctionality::Activated();
}
void QmitkPreprocessingView::Deactivated()
{
- QmitkFunctionality::Deactivated();
+ QmitkFunctionality::Deactivated();
}
void QmitkPreprocessingView::DoHalfSphereGradientDirections()
{
- MitkDwiType::Pointer newDwi = m_DiffusionImage->Clone();
- GradientDirectionContainerType::Pointer gradientContainer = newDwi->GetDirections();
+ mitk::Image::Pointer newDwi = m_SelectedImage->Clone();
+ GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( newDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
- for (unsigned int j=0; j<gradientContainer->Size(); j++)
- if (gradientContainer->at(j)[0]<0)
- gradientContainer->at(j) = -gradientContainer->at(j);
+ for (unsigned int j=0; j<gradientContainer->Size(); j++)
+ if (gradientContainer->at(j)[0]<0)
+ gradientContainer->at(j) = -gradientContainer->at(j);
- newDwi->SetDirections(gradientContainer);
+ newDwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientContainer ) );
+ mitk::DiffusionPropertyHelper propertyHelper( newDwi );
+ propertyHelper.InitializeImage();
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( newDwi );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_halfsphere").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( newDwi );
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+ imageNode->SetName((name+"_halfsphere").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
}
void QmitkPreprocessingView::DoApplyMesurementFrame()
{
- if (m_DiffusionImage.IsNull())
- return;
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( !isDiffusionImage )
+ return;
- vnl_matrix_fixed< double, 3, 3 > mf;
- for (int r=0; r<3; r++)
- for (int c=0; c<3; c++)
- {
- QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
- if (!item)
- return;
- mf[r][c] = item->text().toDouble();
- }
+ vnl_matrix_fixed< double, 3, 3 > mf;
+ for (int r=0; r<3; r++)
+ for (int c=0; c<3; c++)
+ {
+ QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+ if (!item)
+ return;
+ mf[r][c] = item->text().toDouble();
+ }
- MitkDwiType::Pointer newDwi = m_DiffusionImage->Clone();
- newDwi->SetMeasurementFrame(mf);
+ mitk::Image::Pointer newDwi = m_SelectedImage->Clone();
+ newDwi->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( mf ) );
+ mitk::DiffusionPropertyHelper propertyHelper( newDwi );
+ propertyHelper.InitializeImage();
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( newDwi );
- QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
- imageNode->SetName((name+"_new-MF").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( newDwi );
+ QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+ imageNode->SetName((name+"_new-MF").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
}
void QmitkPreprocessingView::DoShowGradientDirections()
{
- if (m_DiffusionImage.IsNull())
- return;
-
- int maxIndex = 0;
- unsigned int maxSize = m_DiffusionImage->GetDimension(0);
- if (maxSize<m_DiffusionImage->GetDimension(1))
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( !isDiffusionImage )
+ return;
+
+ int maxIndex = 0;
+ unsigned int maxSize = m_SelectedImage->GetDimension(0);
+ if (maxSize<m_SelectedImage->GetDimension(1))
+ {
+ maxSize = m_SelectedImage->GetDimension(1);
+ maxIndex = 1;
+ }
+ if (maxSize<m_SelectedImage->GetDimension(2))
+ {
+ maxSize = m_SelectedImage->GetDimension(2);
+ maxIndex = 2;
+ }
+
+ mitk::Point3D origin = m_SelectedImage->GetGeometry()->GetOrigin();
+ mitk::PointSet::Pointer originSet = mitk::PointSet::New();
+
+ typedef mitk::BValueMapProperty::BValueMap BValueMap;
+ typedef mitk::BValueMapProperty::BValueMap::iterator BValueMapIterator;
+ BValueMap bValMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+ GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+ mitk::BaseGeometry::Pointer geometry = m_SelectedImage->GetGeometry();
+ int shellCount = 1;
+ for(BValueMapIterator it = bValMap.begin(); it!=bValMap.end(); ++it)
+ {
+ mitk::PointSet::Pointer pointset = mitk::PointSet::New();
+ for (unsigned int j=0; j<it->second.size(); j++)
{
- maxSize = m_DiffusionImage->GetDimension(1);
- maxIndex = 1;
- }
- if (maxSize<m_DiffusionImage->GetDimension(2))
- {
- maxSize = m_DiffusionImage->GetDimension(2);
- maxIndex = 2;
- }
-
- mitk::Point3D origin = m_DiffusionImage->GetGeometry()->GetOrigin();
- mitk::PointSet::Pointer originSet = mitk::PointSet::New();
-
- typedef mitk::DiffusionImage<short>::BValueMap BValueMap;
- typedef mitk::DiffusionImage<short>::BValueMap::iterator BValueMapIterator;
- BValueMap bValMap = m_DiffusionImage->GetBValueMap();
-
- GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
- mitk::BaseGeometry::Pointer geometry = m_DiffusionImage->GetGeometry();
- int shellCount = 1;
- for(BValueMapIterator it = bValMap.begin(); it!=bValMap.end(); ++it)
- {
- mitk::PointSet::Pointer pointset = mitk::PointSet::New();
- for (unsigned int j=0; j<it->second.size(); j++)
- {
- mitk::Point3D ip;
- vnl_vector_fixed< double, 3 > v = gradientContainer->at(it->second[j]);
- if (v.magnitude()>mitk::eps)
- {
- ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_DiffusionImage->GetDimension(0)/2;
- ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_DiffusionImage->GetDimension(1)/2;
- ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_DiffusionImage->GetDimension(2)/2;
-
- pointset->InsertPoint(j, ip);
- }
- else if (originSet->IsEmpty())
- {
- ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_DiffusionImage->GetDimension(0)/2;
- ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_DiffusionImage->GetDimension(1)/2;
- ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_DiffusionImage->GetDimension(2)/2;
-
- originSet->InsertPoint(j, ip);
- }
- }
- if (it->first<mitk::eps)
- continue;
-
- // add shell to datastorage
- mitk::DataNode::Pointer node = mitk::DataNode::New();
- node->SetData(pointset);
- QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
- name += "_Shell_";
- name += QString::number(it->first);
- node->SetName(name.toStdString().c_str());
- node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
- int b0 = shellCount%2;
- int b1 = 0;
- int b2 = 0;
- if (shellCount>4)
- b2 = 1;
- if (shellCount%4 >= 2)
- b1 = 1;
-
- node->SetProperty("color", mitk::ColorProperty::New(b2, b1, b0));
- GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
- shellCount++;
+ mitk::Point3D ip;
+ vnl_vector_fixed< double, 3 > v = gradientContainer->at(it->second[j]);
+ if (v.magnitude()>mitk::eps)
+ {
+ ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_SelectedImage->GetDimension(0)/2;
+ ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_SelectedImage->GetDimension(1)/2;
+ ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_SelectedImage->GetDimension(2)/2;
+
+ pointset->InsertPoint(j, ip);
+ }
+ else if (originSet->IsEmpty())
+ {
+ ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_SelectedImage->GetDimension(0)/2;
+ ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_SelectedImage->GetDimension(1)/2;
+ ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_SelectedImage->GetDimension(2)/2;
+
+ originSet->InsertPoint(j, ip);
+ }
}
+ if (it->first<mitk::eps)
+ continue;
- // add origin to datastorage
+ // add shell to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
- node->SetData(originSet);
+ node->SetData(pointset);
QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
- name += "_Origin";
+ name += "_Shell_";
+ name += QString::number(it->first);
node->SetName(name.toStdString().c_str());
node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
- node->SetProperty("color", mitk::ColorProperty::New(1,1,1));
+ int b0 = shellCount%2;
+ int b1 = 0;
+ int b2 = 0;
+ if (shellCount>4)
+ b2 = 1;
+ if (shellCount%4 >= 2)
+ b1 = 1;
+
+ node->SetProperty("color", mitk::ColorProperty::New(b2, b1, b0));
GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
+ shellCount++;
+ }
+
+ // add origin to datastorage
+ mitk::DataNode::Pointer node = mitk::DataNode::New();
+ node->SetData(originSet);
+ QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
+ name += "_Origin";
+ node->SetName(name.toStdString().c_str());
+ node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
+ node->SetProperty("color", mitk::ColorProperty::New(1,1,1));
+ GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
}
void QmitkPreprocessingView::DoReduceGradientDirections()
{
- if (m_DiffusionImage.IsNull())
- return;
-
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
- typedef DiffusionImageType::BValueMap BValueMap;
-
- // GetShellSelection from GUI
- BValueMap shellSlectionMap;
- BValueMap originalShellMap = m_DiffusionImage->GetBValueMap();
- std::vector<unsigned int> newNumGradientDirections;
- int shellCounter = 0;
-
- QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
- for (int i=0; i<m_Controls->m_B_ValueMap_TableWidget->rowCount(); i++)
- {
- double BValue = m_Controls->m_B_ValueMap_TableWidget->item(i,0)->text().toDouble();
- shellSlectionMap[BValue] = originalShellMap[BValue];
- unsigned int num = m_Controls->m_B_ValueMap_TableWidget->item(i,1)->text().toUInt();
- newNumGradientDirections.push_back(num);
- name += "_";
- name += QString::number(num);
- shellCounter++;
- }
-
- if (newNumGradientDirections.empty())
- return;
-
- GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
- FilterType::Pointer filter = FilterType::New();
- filter->SetInput(m_DiffusionImage->GetVectorImage());
- filter->SetOriginalGradientDirections(gradientContainer);
- filter->SetNumGradientDirections(newNumGradientDirections);
- filter->SetOriginalBValueMap(originalShellMap);
- filter->SetShellSelectionBValueMap(shellSlectionMap);
- filter->Update();
-
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue(m_DiffusionImage->GetReferenceBValue());
- image->SetDirections(filter->GetGradientDirections());
- image->SetMeasurementFrame(m_DiffusionImage->GetMeasurementFrame());
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
-
- imageNode->SetName(name.toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+ if ( !isDiffusionImage )
+ return;
+
+ typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
+ typedef mitk::BValueMapProperty::BValueMap BValueMap;
+
+ // GetShellSelection from GUI
+ BValueMap shellSlectionMap;
+ BValueMap originalShellMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+ std::vector<unsigned int> newNumGradientDirections;
+ int shellCounter = 0;
+
+ QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
+ for (int i=0; i<m_Controls->m_B_ValueMap_TableWidget->rowCount(); i++)
+ {
+ double BValue = m_Controls->m_B_ValueMap_TableWidget->item(i,0)->text().toDouble();
+ shellSlectionMap[BValue] = originalShellMap[BValue];
+ unsigned int num = m_Controls->m_B_ValueMap_TableWidget->item(i,1)->text().toUInt();
+ newNumGradientDirections.push_back(num);
+ name += "_";
+ name += QString::number(num);
+ shellCounter++;
+ }
+
+ if (newNumGradientDirections.empty())
+ return;
+
+ GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput( itkVectorImagePointer );
+ filter->SetOriginalGradientDirections(gradientContainer);
+ filter->SetNumGradientDirections(newNumGradientDirections);
+ filter->SetOriginalBValueMap(originalShellMap);
+ filter->SetShellSelectionBValueMap(shellSlectionMap);
+ filter->Update();
+
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetGradientDirections() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+
+ imageNode->SetName(name.toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
}
void QmitkPreprocessingView::MergeDwis()
{
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef DiffusionImageType::GradientDirectionContainerType GradientContainerType;
+ typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType GradientContainerType;
- if (m_SelectedDiffusionNodes.size()<2)
- return;
+ if (m_SelectedDiffusionNodes.size()<2)
+ return;
- typedef itk::VectorImage<DiffusionPixelType,3> DwiImageType;
- typedef DwiImageType::PixelType DwiPixelType;
- typedef DwiImageType::RegionType DwiRegionType;
- typedef std::vector< DwiImageType::Pointer > DwiImageContainerType;
+ typedef itk::VectorImage<DiffusionPixelType,3> DwiImageType;
+ typedef DwiImageType::PixelType DwiPixelType;
+ typedef DwiImageType::RegionType DwiRegionType;
+ typedef std::vector< DwiImageType::Pointer > DwiImageContainerType;
- typedef std::vector< GradientContainerType::Pointer > GradientListContainerType;
+ typedef std::vector< GradientContainerType::Pointer > GradientListContainerType;
- DwiImageContainerType imageContainer;
- GradientListContainerType gradientListContainer;
- std::vector< double > bValueContainer;
+ DwiImageContainerType imageContainer;
+ GradientListContainerType gradientListContainer;
+ std::vector< double > bValueContainer;
- QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
- for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+ QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
+ for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+ {
+ mitk::Image::Pointer dwi = dynamic_cast< mitk::Image* >( m_SelectedDiffusionNodes.at(i)->GetData() );
+ if ( dwi.IsNotNull() )
{
- DiffusionImageType::Pointer dwi = dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >( m_SelectedDiffusionNodes.at(i)->GetData() );
- if ( dwi.IsNotNull() )
- {
- imageContainer.push_back(dwi->GetVectorImage());
- gradientListContainer.push_back(dwi->GetDirections());
- bValueContainer.push_back(dwi->GetReferenceBValue());
- if (i>0)
- {
- name += "+";
- name += m_SelectedDiffusionNodes.at(i)->GetName().c_str();
- }
- }
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
+ imageContainer.push_back( itkVectorImagePointer );
+ gradientListContainer.push_back( static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ bValueContainer.push_back( static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ if (i>0)
+ {
+ name += "+";
+ name += m_SelectedDiffusionNodes.at(i)->GetName().c_str();
+ }
}
-
- typedef itk::MergeDiffusionImagesFilter<short> FilterType;
- FilterType::Pointer filter = FilterType::New();
- filter->SetImageVolumes(imageContainer);
- filter->SetGradientLists(gradientListContainer);
- filter->SetBValues(bValueContainer);
- filter->Update();
-
- vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
- DiffusionImageType::Pointer image = DiffusionImageType::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue(filter->GetB_Value());
- image->SetDirections(filter->GetOutputGradients());
- image->SetMeasurementFrame(mf);
- image->InitializeFromVectorImage();
-
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( image );
- imageNode->SetName(name.toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode);
+ }
+
+ typedef itk::MergeDiffusionImagesFilter<short> FilterType;
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetImageVolumes(imageContainer);
+ filter->SetGradientLists(gradientListContainer);
+ filter->SetBValues(bValueContainer);
+ filter->Update();
+
+ vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradients() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( mf ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetB_Value() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( image );
+ imageNode->SetName(name.toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode);
}
void QmitkPreprocessingView::ExtractB0()
{
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef DiffusionImageType::GradientDirectionContainerType GradientContainerType;
+ typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType GradientContainerType;
- int nrFiles = m_SelectedDiffusionNodes.size();
- if (!nrFiles) return;
+ int nrFiles = m_SelectedDiffusionNodes.size();
+ if (!nrFiles) return;
- // call the extraction withou averaging if the check-box is checked
- if( this->m_Controls->m_CheckExtractAll->isChecked() )
- {
- DoExtractBOWithoutAveraging();
- return;
- }
+ // call the extraction withou averaging if the check-box is checked
+ if( this->m_Controls->m_CheckExtractAll->isChecked() )
+ {
+ DoExtractBOWithoutAveraging();
+ return;
+ }
- mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
- mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+ mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
+ mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
- std::vector<mitk::DataNode::Pointer> nodes;
- while ( itemiter != itemiterend ) // for all items
- {
+ std::vector<mitk::DataNode::Pointer> nodes;
+ while ( itemiter != itemiterend ) // for all items
+ {
- DiffusionImageType* vols =
- static_cast<DiffusionImageType*>(
- (*itemiter)->GetData());
+ mitk::Image* vols =
+ static_cast<mitk::Image*>(
+ (*itemiter)->GetData());
- std::string nodename;
- (*itemiter)->GetStringProperty("name", nodename);
+ std::string nodename;
+ (*itemiter)->GetStringProperty("name", nodename);
- // Extract image using found index
- typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
- FilterType::Pointer filter = FilterType::New();
- filter->SetInput(vols->GetVectorImage());
- filter->SetDirections(vols->GetDirections());
- filter->Update();
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
- mitk::Image::Pointer mitkImage = mitk::Image::New();
- mitkImage->InitializeByItk( filter->GetOutput() );
- mitkImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
- mitk::DataNode::Pointer node=mitk::DataNode::New();
- node->SetData( mitkImage );
- node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0"));
+ // Extract image using found index
+ typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput( itkVectorImagePointer );
+ filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ filter->Update();
- GetDefaultDataStorage()->Add(node, (*itemiter));
+ mitk::Image::Pointer mitkImage = mitk::Image::New();
+ mitkImage->InitializeByItk( filter->GetOutput() );
+ mitkImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
+ mitk::DataNode::Pointer node=mitk::DataNode::New();
+ node->SetData( mitkImage );
+ node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0"));
- ++itemiter;
- }
+ GetDefaultDataStorage()->Add(node, (*itemiter));
+
+ ++itemiter;
+ }
}
void QmitkPreprocessingView::DoExtractBOWithoutAveraging()
{
- // typedefs
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef DiffusionImageType::GradientDirectionContainerType GradientContainerType;
- typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
-
- // check number of selected objects, return if empty
- int nrFiles = m_SelectedDiffusionNodes.size();
- if (!nrFiles)
- return;
+ // typedefs
+ typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType GradientContainerType;
+ typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
- mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
- mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+ // check number of selected objects, return if empty
+ int nrFiles = m_SelectedDiffusionNodes.size();
+ if (!nrFiles)
+ return;
- while ( itemiter != itemiterend ) // for all items
- {
- DiffusionImageType* vols =
- static_cast<DiffusionImageType*>(
- (*itemiter)->GetData());
+ mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
+ mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+
+ while ( itemiter != itemiterend ) // for all items
+ {
+ mitk::Image* vols =
+ static_cast<mitk::Image*>(
+ (*itemiter)->GetData());
+
+ std::string nodename;
+ (*itemiter)->GetStringProperty("name", nodename);
- std::string nodename;
- (*itemiter)->GetStringProperty("name", nodename);
+ ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
- // Extract image using found index
- FilterType::Pointer filter = FilterType::New();
- filter->SetInput(vols->GetVectorImage());
- filter->SetDirections(vols->GetDirections());
- filter->Update();
+ // Extract image using found index
+ FilterType::Pointer filter = FilterType::New();
+ filter->SetInput( itkVectorImagePointer );
+ filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+ filter->Update();
- mitk::Image::Pointer mitkImage = mitk::Image::New();
- mitkImage->InitializeByItk( filter->GetOutput() );
- mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
- mitk::DataNode::Pointer node=mitk::DataNode::New();
- node->SetData( mitkImage );
- node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0_ALL"));
+ mitk::Image::Pointer mitkImage = mitk::Image::New();
+ mitkImage->InitializeByItk( filter->GetOutput() );
+ mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
+ mitk::DataNode::Pointer node=mitk::DataNode::New();
+ node->SetData( mitkImage );
+ node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0_ALL"));
- GetDefaultDataStorage()->Add(node, (*itemiter));
+ GetDefaultDataStorage()->Add(node, (*itemiter));
- /*A reinitialization is needed to access the time channels via the ImageNavigationController
+ /*A reinitialization is needed to access the time channels via the ImageNavigationController
The Global-Geometry can not recognize the time channel without a re-init.
(for a new selection in datamanger a automatically updated of the Global-Geometry should be done - if it contains the time channel)*/
- mitk::RenderingManager::GetInstance()->InitializeViews(node->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
+ mitk::RenderingManager::GetInstance()->InitializeViews(node->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
- ++itemiter;
- }
+ ++itemiter;
+ }
}
void QmitkPreprocessingView::AverageGradients()
{
- int nrFiles = m_SelectedDiffusionNodes.size();
- if (!nrFiles) return;
+ int nrFiles = m_SelectedDiffusionNodes.size();
+ if (!nrFiles) return;
- mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
- mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+ mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
+ mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
- while ( itemiter != itemiterend ) // for all items
- {
- mitk::DiffusionImage<DiffusionPixelType>* mitkDwi =
- static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
- (*itemiter)->GetData());
+ while ( itemiter != itemiterend ) // for all items
+ {
+ mitk::Image* mitkDwi =
+ static_cast<mitk::Image*>(
+ (*itemiter)->GetData());
- MitkDwiType::Pointer newDwi = mitkDwi->Clone();
- newDwi->AverageRedundantGradients(m_Controls->m_Blur->value());
+ mitk::Image::Pointer newDwi = mitkDwi->Clone();
+ newDwi->SetPropertyList(mitkDwi->GetPropertyList()->Clone());
- mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
- imageNode->SetData( newDwi );
- QString name = (*itemiter)->GetName().c_str();
- imageNode->SetName((name+"_averaged").toStdString().c_str());
- GetDefaultDataStorage()->Add(imageNode, (*itemiter));
+ mitk::DiffusionPropertyHelper propertyHelper(newDwi);
+ propertyHelper.AverageRedundantGradients(m_Controls->m_Blur->value());
+ propertyHelper.InitializeImage();
- ++itemiter;
- }
+ mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+ imageNode->SetData( newDwi );
+ QString name = (*itemiter)->GetName().c_str();
+ imageNode->SetName((name+"_averaged").toStdString().c_str());
+ GetDefaultDataStorage()->Add(imageNode, (*itemiter));
+
+ ++itemiter;
+ }
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
index 4c49a9cd63..d2e798d963 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
@@ -1,155 +1,159 @@
/*===================================================================
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 _QMITKPREPROCESSINGVIEW_H_INCLUDED
#define _QMITKPREPROCESSINGVIEW_H_INCLUDED
#include <QmitkFunctionality.h>
+#include "ui_QmitkPreprocessingViewControls.h"
+
+// st includes
#include <string>
-#include "ui_QmitkPreprocessingViewControls.h"
+// itk includes
+#include <itkImage.h>
+#include <itkVectorImage.h>
+// mitk includes
+#include <mitkImage.h>
#include "itkDWIVoxelFunctor.h"
-
-#include "mitkDiffusionImage.h"
+#include <mitkDiffusionPropertyHelper.h>
typedef short DiffusionPixelType;
struct PrpSelListener;
/*!
* \ingroup org_mitk_gui_qt_preprocessing_internal
*
* \brief QmitkPreprocessingView
*
* Document your class here.
*
* \sa QmitkFunctionality
*/
class QmitkPreprocessingView : public QmitkFunctionality
{
friend struct PrpSelListener;
// this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
static const std::string VIEW_ID;
- typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
- typedef itk::VectorContainer< unsigned int, GradientDirectionType > GradientDirectionContainerType;
- typedef mitk::DiffusionImage<short> MitkDwiType;
- typedef itk::VectorImage< short, 3 > ItkDwiType;
- typedef itk::Image< unsigned char, 3 > UcharImageType;
- typedef itk::Image< double, 3 > ItkDoubleImageType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
+ typedef itk::VectorImage< short, 3 > ItkDwiType;
+ typedef itk::Image< unsigned char, 3 > UcharImageType;
+ typedef itk::Image< double, 3 > ItkDoubleImageType;
QmitkPreprocessingView();
virtual ~QmitkPreprocessingView();
virtual void CreateQtPartControl(QWidget *parent);
/// \brief Creation of the connections of main and control widget
virtual void CreateConnections();
/// \brief Called when the functionality is activated
virtual void Activated();
virtual void Deactivated();
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
static const int nrconvkernels;
protected slots:
void AverageGradients();
void ExtractB0();
void MergeDwis();
void DoApplySpacing();
void DoApplyOrigin();
void DoApplyDirectionMatrix();
void DoApplyMesurementFrame();
void DoReduceGradientDirections();
void DoShowGradientDirections();
void DoHalfSphereGradientDirections();
void UpdateDwiBValueMapRounder(int i);
void DoLengthCorrection();
void DoAdcCalculation();
void DoDwiNormalization();
void DoProjectSignal();
void DoExtractBrainMask();
void DoResampleImage();
void DoCropImage();
void DoUpdateInterpolationGui(int i);
void DoRemoveGradient();
void DoExtractGradient();
protected:
void DoADCFit();
void DoAKCFit();
void DoBiExpFit();
void DoADCAverage();
template < typename TPixel, unsigned int VImageDimension >
void TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage);
template < typename TPixel, unsigned int VImageDimension >
void TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage);
template < typename TPixel, unsigned int VImageDimension >
void TemplatedUpdateGui( itk::Image<TPixel, VImageDimension>* itkImage);
template < typename TPixel, unsigned int VImageDimension >
void TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage);
template < typename TPixel, unsigned int VImageDimension >
void TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage);
template < typename TPixel, unsigned int VImageDimension >
void TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage);
/** Called by ExtractB0 if check-box activated, extracts all b0 images without averaging */
void DoExtractBOWithoutAveraging();
void UpdateBValueTableWidget(int i);
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkPreprocessingViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
mitk::DataNode::Pointer m_SelectedImageNode;
mitk::Image::Pointer m_SelectedImage;
- mitk::DiffusionImage<DiffusionPixelType>::Pointer m_DiffusionImage;
std::vector< mitk::DataNode::Pointer > m_SelectedDiffusionNodes;
- void CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::DiffusionImage<DiffusionPixelType>::Pointer ImPtr, QString imageName, mitk::DataNode* parent);
+ void CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::Image::Pointer ImPtr, QString imageName, mitk::DataNode* parent);
};
#endif // _QMITKPREPROCESSINGVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
index 32e86ab070..c116f927ea 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
@@ -1,1086 +1,1120 @@
/*===================================================================
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
#include "QmitkQBallReconstructionView.h"
-#include "mitkDiffusionImagingConfigure.h"
// qt includes
#include <QMessageBox>
// itk includes
#include "itkTimeProbe.h"
// mitk includes
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkNodePredicateDataType.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "itkDiffusionQballReconstructionImageFilter.h"
#include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
#include "itkDiffusionMultiShellQballReconstructionImageFilter.h"
#include "itkVectorContainer.h"
#include "itkB0ImageExtractionImageFilter.h"
#include <itkBinaryThresholdImageFilter.h>
#include "mitkQBallImage.h"
#include "mitkProperties.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include "mitkLookupTable.h"
#include "mitkLookupTableProperty.h"
#include "mitkTransferFunction.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
+#include <mitkImageCast.h>
+#include "mitkDiffusionImagingConfigure.h"
#include "berryIStructuredSelection.h"
#include "berryIWorkbenchWindow.h"
#include "berryISelectionService.h"
#include <boost/version.hpp>
const std::string QmitkQBallReconstructionView::VIEW_ID = "org.mitk.views.qballreconstruction";
typedef float TTensorPixelType;
const int QmitkQBallReconstructionView::nrconvkernels = 252;
struct QbrShellSelection
{
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
+ typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMapType;
+ typedef itk::VectorImage< DiffusionPixelType, 3 > ITKDiffusionImageType;
+
QmitkQBallReconstructionView* m_View;
mitk::DataNode * m_Node;
std::string m_NodeName;
std::vector<QCheckBox *> m_CheckBoxes;
QLabel * m_Label;
- mitk::DiffusionImage<DiffusionPixelType> * m_Image;
- typedef mitk::DiffusionImage<DiffusionPixelType>::BValueMap BValueMap;
+ mitk::Image * m_Image;
QbrShellSelection(QmitkQBallReconstructionView* view, mitk::DataNode * node)
: m_View(view),
m_Node(node),
m_NodeName(node->GetName())
{
- m_Image = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * > (node->GetData());
- if(!m_Image){MITK_INFO << "QmitkQBallReconstructionView::QbrShellSelection : fail to initialize DiffusionImage "; return;}
+ m_Image = dynamic_cast<mitk::Image * > (node->GetData());
+
+ if(!m_Image)
+ {
+ MITK_ERROR << "QmitkQBallReconstructionView::QbrShellSelection : no image selected";
+ return;
+ }
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_Node->GetData())) );
+
+ if( !isDiffusionImage )
+ {
+ MITK_ERROR <<
+ "QmitkQBallReconstructionView::QbrShellSelection : selected image contains no diffusion information";
+ return;
+ }
GenerateCheckboxes();
}
void GenerateCheckboxes()
{
- BValueMap origMap = m_Image->GetBValueMap();
- BValueMap::iterator itStart = origMap.begin();
+ BValueMapType origMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+ BValueMapType::iterator itStart = origMap.begin();
itStart++;
- BValueMap::iterator itEnd = origMap.end();
+ BValueMapType::iterator itEnd = origMap.end();
m_Label = new QLabel(m_NodeName.c_str());
m_Label->setVisible(true);
m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(m_Label);
- for(BValueMap::iterator it = itStart ; it!= itEnd; it++)
+ for(BValueMapType::iterator it = itStart ; it!= itEnd; it++)
{
QCheckBox * box = new QCheckBox(QString::number(it->first));
m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(box);
box->setChecked(true);
box->setCheckable(true);
// box->setVisible(true);
m_CheckBoxes.push_back(box);
}
}
void SetVisible(bool vis)
{
foreach(QCheckBox * box, m_CheckBoxes)
{
box->setVisible(vis);
}
}
- BValueMap GetBValueSelctionMap()
+ BValueMapType GetBValueSelctionMap()
{
- BValueMap inputMap = m_Image->GetBValueMap();
- BValueMap outputMap;
+ BValueMapType inputMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+ BValueMapType outputMap;
unsigned int val = 0;
if(inputMap.find(0) == inputMap.end()){
MITK_INFO << "QbrShellSelection: return empty BValueMap from GUI Selection";
return outputMap;
}else{
outputMap[val] = inputMap[val];
MITK_INFO << val;
}
foreach(QCheckBox * box, m_CheckBoxes)
{
if(box->isChecked()){
val = box->text().toDouble();
outputMap[val] = inputMap[val];
MITK_INFO << val;
}
}
return outputMap;
}
~QbrShellSelection()
{
m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget(m_Label);
delete m_Label;
for(std::vector<QCheckBox *>::iterator it = m_CheckBoxes.begin() ; it!= m_CheckBoxes.end(); it++)
{
m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget((*it));
delete (*it);
}
m_CheckBoxes.clear();
}
};
using namespace berry;
struct QbrSelListener : ISelectionListener
{
berryObjectMacro(QbrSelListener);
QbrSelListener(QmitkQBallReconstructionView* view)
{
m_View = view;
}
void DoSelectionChanged(ISelection::ConstPointer selection)
{
// save current selection in member variable
m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
// do something with the selected items
if(m_View->m_CurrentSelection)
{
bool foundDwiVolume = false;
m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_View->m_Controls->m_InputData->setTitle("Please Select Input Data");
QString selected_images = "";
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
// iterate selection
for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
i != m_View->m_CurrentSelection->End(); ++i)
{
// extract datatree node
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
- mitk::DiffusionImage<DiffusionPixelType>* diffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * >(node->GetData());
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+ mitk::Image* diffusionImage = dynamic_cast<mitk::Image * >(node->GetData());
// only look at interesting types
- if(diffusionImage)
+ if(diffusionImage && isDiffusionImage)
{
foundDwiVolume = true;
selected_images += QString(node->GetName().c_str());
if(i + 1 != m_View->m_CurrentSelection->End())
selected_images += "\n";
set->InsertElement(at++, node);
}
}
}
m_View->GenerateShellSelectionUI(set);
m_View->m_Controls->m_DiffusionImageLabel->setText(selected_images);
m_View->m_Controls->m_ButtonStandard->setEnabled(foundDwiVolume);
if (foundDwiVolume)
m_View->m_Controls->m_InputData->setTitle("Input Data");
else
m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
}
}
void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
{
// check, if selection comes from datamanager
if (part)
{
QString partname(part->GetPartName().c_str());
if(partname.compare("Data Manager")==0)
{
// apply selection
DoSelectionChanged(selection);
}
}
}
QmitkQBallReconstructionView* m_View;
};
// --------------- QmitkQBallReconstructionView----------------- //
QmitkQBallReconstructionView::QmitkQBallReconstructionView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL)
{
}
QmitkQBallReconstructionView::~QmitkQBallReconstructionView()
{
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
}
void QmitkQBallReconstructionView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkQBallReconstructionViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
QStringList items;
items << "2" << "4" << "6" << "8" << "10" << "12";
m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
MethodChoosen(m_Controls->m_QBallReconstructionMethodComboBox->currentIndex());
#ifndef DIFFUSION_IMAGING_EXTENDED
m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
#endif
AdvancedCheckboxClicked();
}
m_SelListener = berry::ISelectionListener::Pointer(new QbrSelListener(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
}
void QmitkQBallReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkQBallReconstructionView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkQBallReconstructionView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_ButtonStandard), SIGNAL(clicked()), this, SLOT(ReconstructStandard()) );
connect( (QObject*)(m_Controls->m_AdvancedCheckbox), SIGNAL(clicked()), this, SLOT(AdvancedCheckboxClicked()) );
connect( (QObject*)(m_Controls->m_QBallReconstructionMethodComboBox), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
connect( (QObject*)(m_Controls->m_QBallReconstructionThreasholdEdit), SIGNAL(valueChanged(int)), this, SLOT(PreviewThreshold(int)) );
}
}
void QmitkQBallReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> )
{
}
void QmitkQBallReconstructionView::Activated()
{
QmitkFunctionality::Activated();
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
}
void QmitkQBallReconstructionView::Deactivated()
{
mitk::DataStorage::SetOfObjects::ConstPointer objects = this->GetDefaultDataStorage()->GetAll();
mitk::DataStorage::SetOfObjects::const_iterator itemiter( objects->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( objects->end() );
while ( itemiter != itemiterend ) // for all items
{
mitk::DataNode::Pointer node = *itemiter;
if (node.IsNull())
continue;
// only look at interesting types
- if(dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()))
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+ if( isDiffusionImage )
{
if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
{
node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
this->GetDefaultDataStorage()->Remove(node);
}
}
itemiter++;
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Deactivated();
}
void QmitkQBallReconstructionView::ReconstructStandard()
{
int index = m_Controls->m_QBallReconstructionMethodComboBox->currentIndex();
#ifndef DIFFUSION_IMAGING_EXTENDED
if(index>=3)
{
index = index + 1;
}
#endif
switch(index)
{
case 0:
{
// Numerical
Reconstruct(0,0);
break;
}
case 1:
{
// Standard
Reconstruct(1,0);
break;
}
case 2:
{
// Solid Angle
Reconstruct(1,6);
break;
}
case 3:
{
// Constrained Solid Angle
Reconstruct(1,7);
break;
}
case 4:
{
// ADC
Reconstruct(1,4);
break;
}
case 5:
{
// Raw Signal
Reconstruct(1,5);
break;
}
case 6:
{
// Q-Ball reconstruction
Reconstruct(2,0);
break;
}
}
}
void QmitkQBallReconstructionView::MethodChoosen(int method)
{
#ifndef DIFFUSION_IMAGING_EXTENDED
if(method>=3)
{
method = method + 1;
}
#endif
m_Controls->m_QBallSelectionBox->setHidden(true);
m_Controls->m_OutputCoeffsImage->setHidden(true);
if (method==0)
m_Controls->m_ShFrame->setVisible(false);
else
m_Controls->m_ShFrame->setVisible(true);
switch(method)
{
case 0:
m_Controls->m_Description->setText("Numerical recon. (Tuch 2004)");
break;
case 1:
m_Controls->m_Description->setText("Spherical harmonics recon. (Descoteaux 2007)");
m_Controls->m_OutputCoeffsImage->setHidden(false);
break;
case 2:
m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj 2009)");
m_Controls->m_OutputCoeffsImage->setHidden(false);
break;
case 3:
m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh 2009)");
break;
case 4:
m_Controls->m_Description->setText("SH recon. of the plain ADC-profiles");
break;
case 5:
m_Controls->m_Description->setText("SH recon. of the raw diffusion signal");
break;
case 6:
m_Controls->m_Description->setText("SH recon. of the multi shell diffusion signal (Aganj 2010)");
m_Controls->m_QBallSelectionBox->setHidden(false);
m_Controls->m_OutputCoeffsImage->setHidden(false);
break;
}
}
void QmitkQBallReconstructionView::AdvancedCheckboxClicked()
{
bool check = m_Controls->m_AdvancedCheckbox->isChecked();
m_Controls->m_QBallReconstructionMaxLLevelTextLabel_2->setVisible(check);
m_Controls->m_QBallReconstructionMaxLLevelComboBox->setVisible(check);
m_Controls->m_QBallReconstructionLambdaTextLabel_2->setVisible(check);
m_Controls->m_QBallReconstructionLambdaLineEdit->setVisible(check);
m_Controls->m_QBallReconstructionThresholdLabel_2->setVisible(check);
m_Controls->m_QBallReconstructionThreasholdEdit->setVisible(check);
m_Controls->label_2->setVisible(check);
m_Controls->frame_2->setVisible(check);
}
void QmitkQBallReconstructionView::Reconstruct(int method, int normalization)
{
if (m_CurrentSelection)
{
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
i != m_CurrentSelection->End();
++i)
{
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
- if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
+
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+ if ( isDiffusionImage )
{
set->InsertElement(at++, node);
}
}
}
if(method == 0)
{
NumericalQBallReconstruction(set, normalization);
}
else
{
#if BOOST_VERSION / 100000 > 0
#if BOOST_VERSION / 100 % 1000 > 34
if(method == 1)
{
AnalyticalQBallReconstruction(set, normalization);
}
if(method == 2)
{
MultiQBallReconstruction(set);
}
#else
std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
#endif
#else
std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
#endif
}
}
}
void QmitkQBallReconstructionView::NumericalQBallReconstruction
(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
while ( itemiter != itemiterend ) // for all items
{
- mitk::DiffusionImage<DiffusionPixelType>* vols =
- static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
+ mitk::Image* vols =
+ static_cast<mitk::Image*>(
(*itemiter)->GetData());
std::string nodename;
(*itemiter)->GetStringProperty("name", nodename);
// QBALL RECONSTRUCTION
clock.Start();
MITK_INFO << "QBall reconstruction ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
"QBall reconstruction for %s", nodename.c_str()).toLatin1());
typedef itk::DiffusionQballReconstructionImageFilter
<DiffusionPixelType, DiffusionPixelType, TTensorPixelType, QBALL_ODFSIZE>
QballReconstructionImageFilterType;
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
+
QballReconstructionImageFilterType::Pointer filter =
QballReconstructionImageFilterType::New();
- filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
- filter->SetBValue(vols->GetReferenceBValue());
+ filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ filter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
std::string nodePostfix;
switch(normalization)
{
case 0:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
nodePostfix = "_Numerical_Qball";
break;
}
case 1:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
nodePostfix = "_Numerical_ZeroBvalueNormalization_Qball";
break;
}
case 2:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
nodePostfix = "_NumericalQball_ZeroNormalization_Qball";
break;
}
case 3:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
nodePostfix = "_NumericalQball_NoNormalization_Qball";
break;
}
default:
{
filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
nodePostfix = "_NumericalQball_Qball";
}
}
filter->Update();
clock.Stop();
MITK_DEBUG << "took " << clock.GetMean() << "s." ;
// ODFs TO DATATREE
mitk::QBallImage::Pointer image = mitk::QBallImage::New();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
SetDefaultNodeProperties(node, nodename+nodePostfix);
mitk::ProgressBar::GetInstance()->Progress();
GetDefaultDataStorage()->Add(node, *itemiter);
++itemiter;
}
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
m_MultiWidget->RequestUpdate();
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
return ;
}
}
void QmitkQBallReconstructionView::AnalyticalQBallReconstruction(
mitk::DataStorage::SetOfObjects::Pointer inImages,
int normalization)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
std::vector<float> lambdas;
float minLambda = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
lambdas.push_back(minLambda);
int nLambdas = lambdas.size();
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
std::vector<mitk::DataNode::Pointer>* nodes
= new std::vector<mitk::DataNode::Pointer>();
while ( itemiter != itemiterend ) // for all items
{
// QBALL RECONSTRUCTION
clock.Start();
MITK_INFO << "QBall reconstruction ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("QBall reconstruction for %s", (*itemiter)->GetName().c_str()).toLatin1());
for(int i=0; i<nLambdas; i++)
{
float currentLambda = lambdas[i];
switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
{
case 0:
{
TemplatedAnalyticalQBallReconstruction<2>(*itemiter, currentLambda, normalization);
break;
}
case 1:
{
TemplatedAnalyticalQBallReconstruction<4>(*itemiter, currentLambda, normalization);
break;
}
case 2:
{
TemplatedAnalyticalQBallReconstruction<6>(*itemiter, currentLambda, normalization);
break;
}
case 3:
{
TemplatedAnalyticalQBallReconstruction<8>(*itemiter, currentLambda, normalization);
break;
}
case 4:
{
TemplatedAnalyticalQBallReconstruction<10>(*itemiter, currentLambda, normalization);
break;
}
case 5:
{
TemplatedAnalyticalQBallReconstruction<12>(*itemiter, currentLambda, normalization);
break;
}
}
clock.Stop();
MITK_DEBUG << "took " << clock.GetMean() << "s." ;
mitk::ProgressBar::GetInstance()->Progress();
itemiter++;
}
}
std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
GetDefaultDataStorage()->Add(*nodeIt);
m_MultiWidget->RequestUpdate();
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
return;
}
}
template<int L>
void QmitkQBallReconstructionView::TemplatedAnalyticalQBallReconstruction(mitk::DataNode* dataNodePointer, float lambda, int normalization)
{
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
<DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
typename FilterType::Pointer filter = FilterType::New();
- mitk::DiffusionImage<DiffusionPixelType>* vols = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(dataNodePointer->GetData());
- filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
- filter->SetBValue(vols->GetReferenceBValue());
+ mitk::Image* vols = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
+
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
+
+ filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+ filter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
filter->SetLambda(lambda);
std::string nodePostfix;
switch(normalization)
{
case 0:
{
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
nodePostfix = "_SphericalHarmonics_Qball";
break;
}
case 1:
{
filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
nodePostfix = "_SphericalHarmonics_1_Qball";
break;
}
case 2:
{
filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
nodePostfix = "_SphericalHarmonics_2_Qball";
break;
}
case 3:
{
filter->SetNormalizationMethod(FilterType::QBAR_NONE);
nodePostfix = "_SphericalHarmonics_3_Qball";
break;
}
case 4:
{
filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
nodePostfix = "_AdcProfile";
break;
}
case 5:
{
filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
nodePostfix = "_RawSignal";
break;
}
case 6:
{
filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
nodePostfix = "_SphericalHarmonics_CSA_Qball";
break;
}
case 7:
{
filter->SetNormalizationMethod(FilterType::QBAR_NONNEG_SOLID_ANGLE);
nodePostfix = "_SphericalHarmonics_NonNegCSA_Qball";
break;
}
default:
{
filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
}
}
filter->Update();
// ODFs TO DATATREE
mitk::QBallImage::Pointer image = mitk::QBallImage::New();
image->InitializeByItk( filter->GetOutput() );
image->SetVolume( filter->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
SetDefaultNodeProperties(node, dataNodePointer->GetName()+nodePostfix);
GetDefaultDataStorage()->Add(node, dataNodePointer);
if(m_Controls->m_OutputCoeffsImage->isChecked())
{
mitk::Image::Pointer coeffsImage = mitk::Image::New();
coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
coeffsNode->SetData( coeffsImage );
coeffsNode->SetProperty( "name", mitk::StringProperty::New(dataNodePointer->GetName()+"_SH-Coeffs") );
coeffsNode->SetVisibility(false);
GetDefaultDataStorage()->Add(coeffsNode, node);
}
}
void QmitkQBallReconstructionView::MultiQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
std::vector<float> lambdas;
float minLambda = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
lambdas.push_back(minLambda);
int nLambdas = lambdas.size();
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
while ( itemiter != itemiterend ) // for all items
{
mitk::DataNode* nodePointer = (*itemiter).GetPointer();
std::string nodename;
(*itemiter)->GetStringProperty("name",nodename);
itemiter++;
// QBALL RECONSTRUCTION
clock.Start();
MITK_INFO << "QBall reconstruction ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("QBall reconstruction for %s", nodename.c_str()).toLatin1());
for(int i=0; i<nLambdas; i++)
{
float currentLambda = lambdas[i];
switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
{
case 0:
{
TemplatedMultiQBallReconstruction<2>(currentLambda, nodePointer);
break;
}
case 1:
{
TemplatedMultiQBallReconstruction<4>(currentLambda, nodePointer);
break;
}
case 2:
{
TemplatedMultiQBallReconstruction<6>(currentLambda, nodePointer);
break;
}
case 3:
{
TemplatedMultiQBallReconstruction<8>(currentLambda, nodePointer);
break;
}
case 4:
{
TemplatedMultiQBallReconstruction<10>(currentLambda, nodePointer);
break;
}
case 5:
{
TemplatedMultiQBallReconstruction<12>(currentLambda, nodePointer);
break;
}
}
clock.Stop();
MITK_DEBUG << "took " << clock.GetMean() << "s." ;
mitk::ProgressBar::GetInstance()->Progress();
}
}
m_MultiWidget->RequestUpdate();
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
return ;
}
}
template<int L>
void QmitkQBallReconstructionView::TemplatedMultiQBallReconstruction(float lambda, mitk::DataNode* dataNodePointer)
{
typedef itk::DiffusionMultiShellQballReconstructionImageFilter
<DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
typename FilterType::Pointer filter = FilterType::New();
std::string nodename;
dataNodePointer->GetStringProperty("name",nodename);
- mitk::DiffusionImage<DiffusionPixelType>* dwi = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(dataNodePointer->GetData());
- mitk::DiffusionImage<short>::BValueMap currSelectionMap = m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap();
+ mitk::Image* dwi = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
+ BValueMapType currSelectionMap = m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap();
if(currSelectionMap.size() != 4 && currSelectionMap.find(0) != currSelectionMap.end())
{
QMessageBox::information(0, "Reconstruction not possible:" ,QString("Only three shells in a equidistant configuration is supported. (ImageName: " + QString(nodename.c_str()) + ")"));
return;
}
- mitk::DiffusionImage<short>::BValueMap::reverse_iterator it1 = currSelectionMap.rbegin();
- mitk::DiffusionImage<short>::BValueMap::reverse_iterator it2 = currSelectionMap.rbegin();
+ BValueMapType::reverse_iterator it1 = currSelectionMap.rbegin();
+ BValueMapType::reverse_iterator it2 = currSelectionMap.rbegin();
++it2;
// Get average distance
int avdistance = 0;
for(; it2 != currSelectionMap.rend(); ++it1,++it2)
avdistance += (int)it1->first - (int)it2->first;
avdistance /= currSelectionMap.size()-1;
// Check if all shells are using the same averae distance
it1 = currSelectionMap.rbegin();
it2 = currSelectionMap.rbegin();
++it2;
for(; it2 != currSelectionMap.rend(); ++it1,++it2)
if(avdistance != (int)it1->first - (int)it2->first)
{
QMessageBox::information(0, "Reconstruction not possible:" ,QString("Selected Shells are not in a equidistant configuration. (ImageName: " + QString(nodename.c_str()) + ")"));
return;
}
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(dwi, itkVectorImagePointer);
- filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
- filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage(), dwi->GetReferenceBValue() );
- filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
- filter->SetLambda(lambda);
- filter->Update();
+ filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
+ filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer, static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+ filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
+ filter->SetLambda(lambda);
+ filter->Update();
- // ODFs TO DATATREE
- mitk::QBallImage::Pointer image = mitk::QBallImage::New();
- image->InitializeByItk( filter->GetOutput() );
- image->SetVolume( filter->GetOutput()->GetBufferPointer() );
- mitk::DataNode::Pointer node=mitk::DataNode::New();
- node->SetData( image );
- SetDefaultNodeProperties(node, nodename+"_SphericalHarmonics_MultiShell_Qball");
+ // ODFs TO DATATREE
+ mitk::QBallImage::Pointer image = mitk::QBallImage::New();
+ image->InitializeByItk( filter->GetOutput() );
+ image->SetVolume( filter->GetOutput()->GetBufferPointer() );
+ mitk::DataNode::Pointer node=mitk::DataNode::New();
+ node->SetData( image );
+ SetDefaultNodeProperties(node, nodename+"_SphericalHarmonics_MultiShell_Qball");
- GetDefaultDataStorage()->Add(node, dataNodePointer);
+ GetDefaultDataStorage()->Add(node, dataNodePointer);
- if(m_Controls->m_OutputCoeffsImage->isChecked())
- {
- mitk::Image::Pointer coeffsImage = mitk::Image::New();
- coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
- coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
- mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
- coeffsNode->SetData( coeffsImage );
- coeffsNode->SetProperty( "name", mitk::StringProperty::New(
- QString(nodename.c_str()).append("_SH-Coefficients").toStdString()) );
- coeffsNode->SetVisibility(false);
- GetDefaultDataStorage()->Add(coeffsNode, node);
- }
+ if(m_Controls->m_OutputCoeffsImage->isChecked())
+ {
+ mitk::Image::Pointer coeffsImage = mitk::Image::New();
+ coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
+ coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
+ mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
+ coeffsNode->SetData( coeffsImage );
+ coeffsNode->SetProperty( "name", mitk::StringProperty::New(
+ QString(nodename.c_str()).append("_SH-Coefficients").toStdString()) );
+ coeffsNode->SetVisibility(false);
+ GetDefaultDataStorage()->Add(coeffsNode, node);
+ }
}
void QmitkQBallReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
{
node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
node->SetProperty ("layer", mitk::IntProperty::New(100));
node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
node->SetProperty( "name", mitk::StringProperty::New(name) );
}
void QmitkQBallReconstructionView::GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set)
{
m_DiffusionImages = set;
std::map<const mitk::DataNode * , QbrShellSelection * > tempMap;
const mitk::DataStorage::SetOfObjects::iterator setEnd( set->end() );
mitk::DataStorage::SetOfObjects::iterator NodeIt( set->begin() );
while(NodeIt != setEnd)
{
if(m_ShellSelectorMap.find( (*NodeIt).GetPointer() ) != m_ShellSelectorMap.end())
{
tempMap[(*NodeIt).GetPointer()] = m_ShellSelectorMap[(*NodeIt).GetPointer()];
m_ShellSelectorMap.erase((*NodeIt).GetPointer());
}else
{
tempMap[(*NodeIt).GetPointer()] = new QbrShellSelection(this, (*NodeIt) );
tempMap[(*NodeIt).GetPointer()]->SetVisible(true);
}
NodeIt++;
}
for(std::map<const mitk::DataNode * , QbrShellSelection * >::iterator it = m_ShellSelectorMap.begin(); it != m_ShellSelectorMap.end();it ++)
{
delete it->second;
}
m_ShellSelectorMap.clear();
m_ShellSelectorMap = tempMap;
}
void QmitkQBallReconstructionView::PreviewThreshold(int threshold)
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_DiffusionImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_DiffusionImages->end() );
while ( itemiter != itemiterend ) // for all items
{
- mitk::DiffusionImage<DiffusionPixelType>* vols =
- static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
+ mitk::Image* vols =
+ static_cast<mitk::Image*>(
(*itemiter)->GetData());
// Extract b0 image
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
+
typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
FilterType::Pointer filterB0 = FilterType::New();
- filterB0->SetInput(vols->GetVectorImage());
- filterB0->SetDirections(vols->GetDirections());
+ filterB0->SetInput( itkVectorImagePointer );
+ filterB0->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
filterB0->Update();
mitk::Image::Pointer mitkImage = mitk::Image::New();
typedef itk::Image<short, 3> ImageType;
typedef itk::Image<short, 3> SegmentationType;
typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
// apply threshold
ThresholdFilterType::Pointer filterThreshold = ThresholdFilterType::New();
filterThreshold->SetInput(filterB0->GetOutput());
filterThreshold->SetLowerThreshold(threshold);
filterThreshold->SetInsideValue(0);
filterThreshold->SetOutsideValue(1); // mark cut off values red
filterThreshold->Update();
mitkImage->InitializeByItk( filterThreshold->GetOutput() );
mitkImage->SetVolume( filterThreshold->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node;
if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
{
node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
}
else
{
// create a new node, to show thresholded values
node = mitk::DataNode::New();
GetDefaultDataStorage()->Add( node, *itemiter );
node->SetProperty( "name", mitk::StringProperty::New("ThresholdOverlay"));
node->SetBoolProperty("helper object", true);
}
node->SetData( mitkImage );
itemiter++;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
index 3ac068f4f9..d6cc9382ce 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
@@ -1,131 +1,138 @@
/*===================================================================
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 _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
#define _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
#include <QmitkFunctionality.h>
#include <string>
#include "ui_QmitkQBallReconstructionViewControls.h"
-#include "mitkDiffusionImage.h"
-
#include <berryIPartListener.h>
#include <berryISelectionListener.h>
#include <berryIStructuredSelection.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <itkVectorImage.h>
+
typedef short DiffusionPixelType;
struct QbrSelListener;
struct QbrShellSelection;
/*!
* \ingroup org_mitk_gui_qt_qballreconstruction_internal
*
* \brief QmitkQBallReconstructionView
*
* Document your class here.
*
* \sa QmitkFunctionality
*/
class QmitkQBallReconstructionView : public QmitkFunctionality
{
friend struct QbrSelListener;
friend struct QbrShellSelection;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
+ typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMapType;
+ typedef itk::VectorImage< DiffusionPixelType, 3 > ITKDiffusionImageType;
+
// this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkQBallReconstructionView();
virtual ~QmitkQBallReconstructionView();
virtual void CreateQtPartControl(QWidget *parent);
/// \brief Creation of the connections of main and control widget
virtual void CreateConnections();
/// \brief Called when the functionality is activated
virtual void Activated();
virtual void Deactivated();
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
static const int nrconvkernels;
protected slots:
void ReconstructStandard();
void AdvancedCheckboxClicked();
void MethodChoosen(int method);
void Reconstruct(int method, int normalization);
void NumericalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
void AnalyticalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
void MultiQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
/**
* @brief PreviewThreshold Generates a preview of the values that are cut off by the thresholds
* @param threshold
*/
void PreviewThreshold(int threshold);
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkQBallReconstructionViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
template<int L>
void TemplatedAnalyticalQBallReconstruction(mitk::DataNode* dataNodePointer, float lambda, int normalization);
template<int L>
void TemplatedMultiQBallReconstruction(float lambda, mitk::DataNode*);
void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
//void Create
berry::ISelectionListener::Pointer m_SelListener;
berry::IStructuredSelection::ConstPointer m_CurrentSelection;
mitk::DataStorage::SetOfObjects::Pointer m_DiffusionImages;
private:
std::map< const mitk::DataNode *, QbrShellSelection * > m_ShellSelectorMap;
void GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set);
};
#endif // _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
index d2dd9a171d..a5ccce623d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
@@ -1,290 +1,295 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
#include <berryIStructuredSelection.h>
// Qmitk
#include "QmitkStochasticFiberTrackingView.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
// MITK
#include <mitkImageToItk.h>
#include <mitkFiberBundleX.h>
+#include <mitkImageCast.h>
// VTK
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkSmartPointer.h>
#include <vtkPolyLine.h>
#include <vtkCellData.h>
const std::string QmitkStochasticFiberTrackingView::VIEW_ID = "org.mitk.views.stochasticfibertracking";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace berry;
QmitkStochasticFiberTrackingView::QmitkStochasticFiberTrackingView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_SeedRoi( NULL )
, m_DiffusionImage( NULL )
{
}
// Destructor
QmitkStochasticFiberTrackingView::~QmitkStochasticFiberTrackingView()
{
}
void QmitkStochasticFiberTrackingView::CreateQtPartControl( QWidget *parent )
{
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkStochasticFiberTrackingViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
connect( m_Controls->m_MaxCacheSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxCacheSizeChanged(int)) );
connect( m_Controls->m_MaxTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxTractLengthChanged(int)) );
}
}
void QmitkStochasticFiberTrackingView::OnSeedsPerVoxelChanged(int value)
{
m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
}
void QmitkStochasticFiberTrackingView::OnMaxTractLengthChanged(int value)
{
m_Controls->m_MaxTractLengthLabel->setText(QString("Max. Tract Length: ")+QString::number(value));
}
void QmitkStochasticFiberTrackingView::OnMaxCacheSizeChanged(int value)
{
m_Controls->m_MaxCacheSizeLabel->setText(QString("Max. Cache Size: ")+QString::number(value)+"GB");
}
void QmitkStochasticFiberTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkStochasticFiberTrackingView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkStochasticFiberTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_DiffusionImageNode = NULL;
m_DiffusionImage = NULL;
m_SeedRoi = NULL;
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_RoiImageLabel->setText("<font color='red'>mandatory</font>");
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
- if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+ if ( isDiffusionImage )
{
m_DiffusionImageNode = node;
- m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData());
+ m_DiffusionImage = dynamic_cast<mitk::Image*>(node->GetData());
m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
}
else
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
}
}
}
}
if(m_DiffusionImage.IsNotNull() && m_SeedRoi.IsNotNull())
{
m_Controls->m_InputData->setTitle("Input Data");
m_Controls->commandLinkButton->setEnabled(true);
}
else
{
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->commandLinkButton->setEnabled(false);
}
}
void QmitkStochasticFiberTrackingView::DoFiberTracking()
{
typedef itk::VectorImage< short int, 3 > DWIVectorImageType;
typedef itk::Image< float, 3 > FloatImageType;
typedef itk::Image< unsigned int, 3 > CImageType;
typedef itk::StochasticTractographyFilter< DWIVectorImageType, FloatImageType, CImageType > TrackingFilterType;
typedef itk::DTITubeSpatialObject<3> DTITubeType;
typedef itk::DTITubeSpatialObjectPoint<3> DTITubePointType;
typedef itk::SceneSpatialObject<3> SceneSpatialObjectType;
/* get Gradients/Direction of dwi */
- itk::VectorContainer< unsigned int, vnl_vector_fixed<double,3> >::Pointer Pdir = m_DiffusionImage->GetDirections();
+ GradientDirectionContainerType::Pointer Pdir = static_cast<mitk::GradientDirectionsProperty*>( m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
/* bValueContainer, Container includes b-values according to corresponding gradient-direction*/
TrackingFilterType::bValueContainerType::Pointer vecCont = TrackingFilterType::bValueContainerType::New();
/* for each gradient set b-Value; for 0-gradient set b-value eq. 0 */
for ( int i=0; i<(int)Pdir->size(); ++i)
{
vnl_vector_fixed<double,3> valsGrad = Pdir->at(i);
if (valsGrad.get(0) == 0 && valsGrad.get(1) == 0 && valsGrad.get(2) == 0)
{ //set 0-Gradient to bValue 0
vecCont->InsertElement(i,0);
}else{
- vecCont->InsertElement(i,m_DiffusionImage->GetReferenceBValue());
+ vecCont->InsertElement(i, static_cast<mitk::FloatProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
}
}
/* define measurement frame (identity-matrix 3x3) */
- TrackingFilterType::MeasurementFrameType measurement_frame = m_DiffusionImage->GetMeasurementFrame();
+ TrackingFilterType::MeasurementFrameType measurement_frame = static_cast<mitk::MeasurementFrameProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
/* generate white matterImage (dummy?)*/
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(m_DiffusionImage, itkVectorImagePointer);
+
FloatImageType::Pointer wmImage = FloatImageType::New();
- wmImage->SetSpacing( m_DiffusionImage->GetVectorImage()->GetSpacing() );
- wmImage->SetOrigin( m_DiffusionImage->GetVectorImage()->GetOrigin() );
- wmImage->SetDirection( m_DiffusionImage->GetVectorImage()->GetDirection() );
- wmImage->SetLargestPossibleRegion( m_DiffusionImage->GetVectorImage()->GetLargestPossibleRegion() );
+ wmImage->SetSpacing( itkVectorImagePointer->GetSpacing() );
+ wmImage->SetOrigin( itkVectorImagePointer->GetOrigin() );
+ wmImage->SetDirection( itkVectorImagePointer->GetDirection() );
+ wmImage->SetLargestPossibleRegion( itkVectorImagePointer->GetLargestPossibleRegion() );
wmImage->SetBufferedRegion( wmImage->GetLargestPossibleRegion() );
wmImage->SetRequestedRegion( wmImage->GetLargestPossibleRegion() );
wmImage->Allocate();
itk::ImageRegionIterator<FloatImageType> ot(wmImage, wmImage->GetLargestPossibleRegion() );
while (!ot.IsAtEnd())
{
ot.Set(1);
++ot;
}
/* init TractographyFilter */
TrackingFilterType::Pointer trackingFilter = TrackingFilterType::New();
- trackingFilter->SetPrimaryInput(m_DiffusionImage->GetVectorImage().GetPointer());
+ trackingFilter->SetPrimaryInput(itkVectorImagePointer.GetPointer());
trackingFilter->SetbValues(vecCont);
trackingFilter->SetGradients(Pdir);
trackingFilter->SetMeasurementFrame(measurement_frame);
trackingFilter->SetWhiteMatterProbabilityImage(wmImage);
trackingFilter->SetTotalTracts(m_Controls->m_SeedsPerVoxelSlider->value());
trackingFilter->SetMaxLikelihoodCacheSize(m_Controls->m_MaxCacheSizeSlider->value()*1000);
trackingFilter->SetMaxTractLength(m_Controls->m_MaxTractLengthSlider->value());
//itk::Image< char, 3 >
mitk::ImageToItk< itk::Image< unsigned char, 3 > >::Pointer binaryImageToItk1 = mitk::ImageToItk< itk::Image< unsigned char, 3 > >::New();
binaryImageToItk1->SetInput( m_SeedRoi );
binaryImageToItk1->Update();
vtkSmartPointer<vtkPoints> vPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vCellArray = vtkSmartPointer<vtkCellArray>::New();
itk::ImageRegionConstIterator< BinaryImageType > it(binaryImageToItk1->GetOutput(), binaryImageToItk1->GetOutput()->GetRequestedRegion());
it.GoToBegin();
mitk::BaseGeometry* geom = m_DiffusionImage->GetGeometry();
while(!it.IsAtEnd())
{
itk::ImageConstIterator<BinaryImageType>::PixelType tmpPxValue = it.Get();
if(tmpPxValue != 0){
mitk::Point3D point;
itk::ImageRegionConstIterator< BinaryImageType >::IndexType seedIdx = it.GetIndex();
trackingFilter->SetSeedIndex(seedIdx);
trackingFilter->Update();
/* get results from Filter */
/* write each single tract into member container */
TrackingFilterType::TractContainerType::Pointer container_tmp = trackingFilter->GetOutputTractContainer();
TrackingFilterType::TractContainerType::Iterator elIt = container_tmp->Begin();
TrackingFilterType::TractContainerType::Iterator end = container_tmp->End();
bool addTract = true;
while( elIt != end ){
TrackingFilterType::TractContainerType::Element tract = elIt.Value();
TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::ConstPointer vertexlist = tract->GetVertexList();
vtkSmartPointer<vtkPolyLine> vPolyLine = vtkSmartPointer<vtkPolyLine>::New();
for( int j=0; j<(int)vertexlist->Size(); j++)
{
TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::Element vertex = vertexlist->GetElement(j);
mitk::Point3D index;
index[0] = (float)vertex[0];
index[1] = (float)vertex[1];
index[2] = (float)vertex[2];
if (geom->IsIndexInside(index))
{
geom->IndexToWorld(index, point);
vtkIdType id = vPoints->InsertNextPoint(point.GetDataPointer());
vPolyLine->GetPointIds()->InsertNextId(id);
}
else
{
addTract = false;
break;
}
}
if (addTract)
vCellArray->InsertNextCell(vPolyLine);
++elIt;
}
}
++it;
}
vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
fiberPolyData->SetPoints(vPoints);
fiberPolyData->SetLines(vCellArray);
mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberPolyData);
fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_DiffusionImageNode->GetData())->GetGeometry());
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(fib);
QString name("FiberBundle_");
name += m_DiffusionImageNode->GetName().c_str();
name += "_Probabilistic";
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode, m_DiffusionImageNode);
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
index 6134f6670f..26bff1e2af 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
@@ -1,83 +1,89 @@
/*===================================================================
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 QmitkStochasticFiberTrackingView_h
#define QmitkStochasticFiberTrackingView_h
#include <QmitkFunctionality.h>
#include "ui_QmitkStochasticFiberTrackingViewControls.h"
-#include <mitkDiffusionImage.h>
#include <mitkDataStorage.h>
#include <itkVectorImage.h>
#include <itkImage.h>
#include <itkDTITubeSpatialObject.h>
#include <itkDTITubeSpatialObjectPoint.h>
#include <itkSceneSpatialObject.h>
#include <itkStochasticTractographyFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
/*!
\brief View for probabilistic streamline fiber tracking
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkStochasticFiberTrackingView : public QmitkFunctionality
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
+ typedef short DiffusionPixelType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
+ typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMapType;
+ typedef itk::VectorImage< DiffusionPixelType, 3 > ITKDiffusionImageType;
+
typedef itk::Image< unsigned char, 3 > BinaryImageType;
static const std::string VIEW_ID;
QmitkStochasticFiberTrackingView();
virtual ~QmitkStochasticFiberTrackingView();
virtual void CreateQtPartControl(QWidget *parent);
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
protected slots:
void DoFiberTracking(); ///< start fiber tracking
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkStochasticFiberTrackingViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
protected slots:
/** update labels if parameters have changed */
void OnSeedsPerVoxelChanged(int value);
void OnMaxTractLengthChanged(int value);
void OnMaxCacheSizeChanged(int value);
private:
mitk::Image::Pointer m_SeedRoi; ///< binary image defining seed voxels for tracking process
- mitk::DiffusionImage<short>::Pointer m_DiffusionImage; ///< input image
+ mitk::Image::Pointer m_DiffusionImage; ///< input image
mitk::DataNode::Pointer m_DiffusionImageNode; ///< data node containing input image
};
#endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
index bc98ff91f9..f71eae8d1c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
@@ -1,1054 +1,1068 @@
/*===================================================================
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 "QmitkTensorReconstructionView.h"
#include "mitkDiffusionImagingConfigure.h"
// qt includes
#include <QMessageBox>
#include <QImage>
#include <QGraphicsScene>
#include <QGraphicsPixmapItem>
#include <QGraphicsLinearLayout>
// itk includes
#include "itkTimeProbe.h"
//#include "itkTensor.h"
// mitk includes
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkNodePredicateDataType.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkTeemDiffusionTensor3DReconstructionImageFilter.h"
#include "itkDiffusionTensor3DReconstructionImageFilter.h"
#include "itkTensorImageToDiffusionImageFilter.h"
#include "itkPointShell.h"
#include "itkVector.h"
#include "itkB0ImageExtractionImageFilter.h"
#include "itkTensorReconstructionWithEigenvalueCorrectionFilter.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include <itkBinaryThresholdImageFilter.h>
-
+#include <mitkImageVtkMapper2D.h>
#include "mitkProperties.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
-#include "mitkDiffusionImageMapper.h"
#include "mitkLookupTableProperty.h"
#include "mitkLookupTable.h"
#include "mitkImageStatisticsHolder.h"
+#include <mitkITKImageImport.h>
#include <itkTensorImageToQBallImageFilter.h>
#include <itkResidualImageFilter.h>
#include <berryIWorkbenchWindow.h>
#include <berryISelectionService.h>
+#include <mitkImageVtkMapper2D.h>
const std::string QmitkTensorReconstructionView::VIEW_ID = "org.mitk.views.tensorreconstruction";
typedef float TTensorPixelType;
typedef itk::DiffusionTensor3D< TTensorPixelType > TensorPixelType;
typedef itk::Image< TensorPixelType, 3 > TensorImageType;
using namespace berry;
QmitkTensorReconstructionView::QmitkTensorReconstructionView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL)
{
m_DiffusionImages = mitk::DataStorage::SetOfObjects::New();
m_TensorImages = mitk::DataStorage::SetOfObjects::New();
}
QmitkTensorReconstructionView::~QmitkTensorReconstructionView()
{
}
void QmitkTensorReconstructionView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkTensorReconstructionViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
Advanced1CheckboxClicked();
}
}
void QmitkTensorReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkTensorReconstructionView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkTensorReconstructionView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_StartReconstruction), SIGNAL(clicked()), this, SLOT(Reconstruct()) );
connect( (QObject*)(m_Controls->m_Advanced1), SIGNAL(clicked()), this, SLOT(Advanced1CheckboxClicked()) );
connect( (QObject*)(m_Controls->m_TensorsToDWIButton), SIGNAL(clicked()), this, SLOT(TensorsToDWI()) );
connect( (QObject*)(m_Controls->m_TensorsToQbiButton), SIGNAL(clicked()), this, SLOT(TensorsToQbi()) );
connect( (QObject*)(m_Controls->m_ResidualButton), SIGNAL(clicked()), this, SLOT(ResidualCalculation()) );
connect( (QObject*)(m_Controls->m_PerSliceView), SIGNAL(pointSelected(int, int)), this, SLOT(ResidualClicked(int, int)) );
connect( (QObject*)(m_Controls->m_TensorReconstructionThreshold), SIGNAL(valueChanged(int)), this, SLOT(PreviewThreshold(int)) );
}
}
void QmitkTensorReconstructionView::ResidualClicked(int slice, int volume)
{
// Use image coord to reset crosshair
// Find currently selected diffusion image
// Update Label
// to do: This position should be modified in order to skip B0 volumes that are not taken into account
// when calculating residuals
// Find the diffusion image
- mitk::DiffusionImage<DiffusionPixelType>* diffImage;
+ mitk::Image* diffImage;
mitk::DataNode::Pointer correctNode;
mitk::BaseGeometry* geometry;
+ bool isDiffusionImage(false);
+
if (m_DiffusionImage.IsNotNull())
{
- diffImage = static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(m_DiffusionImage->GetData());
+ isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_DiffusionImage->GetData())) ;
+ diffImage = static_cast<mitk::Image*>(m_DiffusionImage->GetData());
- geometry = diffImage->GetGeometry();
+ geometry = m_DiffusionImage->GetData()->GetGeometry();
// Remember the node whose display index must be updated
correctNode = mitk::DataNode::New();
correctNode = m_DiffusionImage;
}
- if(diffImage != NULL)
+ if( isDiffusionImage )
{
- typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
- typedef itk::VectorContainer< unsigned int,
- GradientDirectionType > GradientDirectionContainerType;
- GradientDirectionContainerType::Pointer dirs = diffImage->GetDirections();
+ GradientDirectionContainerType::Pointer dirs = static_cast<mitk::GradientDirectionsProperty*>( diffImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
for(unsigned int i=0; i<dirs->Size() && i<=volume; i++)
{
GradientDirectionType grad = dirs->ElementAt(i);
// check if image is b0 weighted
if(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001)
{
volume++;
}
}
QString pos = "Volume: ";
pos.append(QString::number(volume));
pos.append(", Slice: ");
pos.append(QString::number(slice));
m_Controls->m_PositionLabel->setText(pos);
if(correctNode)
{
int oldDisplayVal;
correctNode->GetIntProperty("DisplayChannel", oldDisplayVal);
std::string oldVal = QString::number(oldDisplayVal).toStdString();
std::string newVal = QString::number(volume).toStdString();
correctNode->SetIntProperty("DisplayChannel",volume);
correctNode->SetSelected(true);
this->FirePropertyChanged("DisplayChannel", oldVal, newVal);
correctNode->UpdateOutputInformation();
mitk::Point3D p3 = m_MultiWidget->GetCrossPosition();
itk::Index<3> ix;
geometry->WorldToIndex(p3, ix);
// ix[2] = slice;
mitk::Vector3D vec;
vec[0] = ix[0];
vec[1] = ix[1];
vec[2] = slice;
mitk::Vector3D v3New;
geometry->IndexToWorld(vec, v3New);
mitk::Point3D origin = geometry->GetOrigin();
mitk::Point3D p3New;
p3New[0] = v3New[0] + origin[0];
p3New[1] = v3New[1] + origin[1];
p3New[2] = v3New[2] + origin[2];
m_MultiWidget->MoveCrossToPosition(p3New);
m_MultiWidget->RequestUpdate();
}
}
}
void QmitkTensorReconstructionView::Advanced1CheckboxClicked()
{
bool check = m_Controls->
m_Advanced1->isChecked();
m_Controls->frame->setVisible(check);
}
void QmitkTensorReconstructionView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkTensorReconstructionView::Deactivated()
{
// Get all current nodes
mitk::DataStorage::SetOfObjects::ConstPointer objects = this->GetDefaultDataStorage()->GetAll();
mitk::DataStorage::SetOfObjects::const_iterator itemiter( objects->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( objects->end() );
while ( itemiter != itemiterend ) // for all items
{
mitk::DataNode::Pointer node = *itemiter;
if (node.IsNull())
continue;
// only look at interesting types
- if(dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()))
+ if( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(dynamic_cast<mitk::Image*>(node->GetData())))
{
if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
{
node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
this->GetDefaultDataStorage()->Remove(node);
}
}
itemiter++;
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Deactivated();
}
void QmitkTensorReconstructionView::ResidualCalculation()
{
// Extract dwi and dti from current selection
// In case of multiple selections, take the first one, since taking all combinations is not meaningful
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
- mitk::DiffusionImage<DiffusionPixelType>::Pointer diffImage
- = mitk::DiffusionImage<DiffusionPixelType>::New();
+ mitk::Image::Pointer diffImage
+ = mitk::Image::New();
TensorImageType::Pointer tensorImage;
std::string nodename;
if(m_DiffusionImage.IsNotNull())
{
- diffImage = static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(m_DiffusionImage->GetData());
+ diffImage = static_cast<mitk::Image*>(m_DiffusionImage->GetData());
}
else
return;
if(m_TensorImage.IsNotNull())
{
mitk::TensorImage* mitkVol;
mitkVol = static_cast<mitk::TensorImage*>(m_TensorImage->GetData());
mitk::CastToItkImage(mitkVol, tensorImage);
m_TensorImage->GetStringProperty("name", nodename);
}
else
return;
typedef itk::TensorImageToDiffusionImageFilter<
TTensorPixelType, DiffusionPixelType > FilterType;
- mitk::DiffusionImage<DiffusionPixelType>::GradientDirectionContainerType* gradients
- = diffImage->GetDirections();
+ GradientDirectionContainerType* gradients
+ = static_cast<mitk::GradientDirectionsProperty*>( diffImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
// Find the min and the max values from a baseline image
mitk::ImageStatisticsHolder *stats = diffImage->GetStatistics();
//Initialize filter that calculates the modeled diffusion weighted signals
FilterType::Pointer filter = FilterType::New();
filter->SetInput( tensorImage );
- filter->SetBValue(diffImage->GetReferenceBValue());
+ filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
filter->SetGradientList(gradients);
filter->SetMin(stats->GetScalarValueMin());
filter->SetMax(stats->GetScalarValueMax());
filter->Update();
// TENSORS TO DATATREE
- mitk::DiffusionImage<DiffusionPixelType>::Pointer image = mitk::DiffusionImage<DiffusionPixelType>::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue(diffImage->GetReferenceBValue());
- image->SetDirections(gradients);
- image->InitializeFromVectorImage();
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradients ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( image );
- mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
- node->SetName("Estimated DWI");
+ mitk::ImageVtkMapper2D::SetDefaultProperties(node);
QString newname;
newname = newname.append(nodename.c_str());
- newname = newname.append("_DWI");
+ newname = newname.append("_Estimated DWI");
node->SetName(newname.toLatin1());
GetDefaultDataStorage()->Add(node, m_TensorImage);
- mitk::DiffusionImage<DiffusionPixelType>::BValueMap map =image->GetBValueMap();
- mitk::DiffusionImage<DiffusionPixelType>::IndicesVector b0Indices = map[0];
+ BValueMapType map = static_cast<mitk::BValueMapProperty*>(image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();;
+ std::vector< unsigned int > b0Indices = map[0];
typedef itk::ResidualImageFilter<DiffusionPixelType, float> ResidualImageFilterType;
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(diffImage, itkVectorImagePointer);
+ ITKDiffusionImageType::Pointer itkSecondVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(image, itkSecondVectorImagePointer);
+
ResidualImageFilterType::Pointer residualFilter = ResidualImageFilterType::New();
- residualFilter->SetInput(diffImage->GetVectorImage());
- residualFilter->SetSecondDiffusionImage(image->GetVectorImage());
+ residualFilter->SetInput( itkVectorImagePointer );
+ residualFilter->SetSecondDiffusionImage( itkSecondVectorImagePointer );
residualFilter->SetGradients(gradients);
residualFilter->SetB0Index(b0Indices[0]);
residualFilter->SetB0Threshold(30);
residualFilter->Update();
itk::Image<float, 3>::Pointer residualImage = itk::Image<float, 3>::New();
residualImage = residualFilter->GetOutput();
mitk::Image::Pointer mitkResImg = mitk::Image::New();
mitk::CastToMitkImage(residualImage, mitkResImg);
stats = mitkResImg->GetStatistics();
float min = stats->GetScalarValueMin();
float max = stats->GetScalarValueMax();
mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
vtkSmartPointer<vtkLookupTable> lookupTable =
vtkSmartPointer<vtkLookupTable>::New();
lookupTable->SetTableRange(min, max);
// If you don't want to use the whole color range, you can use
// SetValueRange, SetHueRange, and SetSaturationRange
lookupTable->Build();
vtkSmartPointer<vtkLookupTable> reversedlookupTable =
vtkSmartPointer<vtkLookupTable>::New();
reversedlookupTable->SetTableRange(min+1, max);
reversedlookupTable->Build();
for(int i=0; i<256; i++)
{
double* rgba = reversedlookupTable->GetTableValue(255-i);
lookupTable->SetTableValue(i, rgba[0], rgba[1], rgba[2], rgba[3]);
}
lut->SetVtkLookupTable(lookupTable);
lutProp->SetLookupTable(lut);
// Create lookuptable
mitk::DataNode::Pointer resNode=mitk::DataNode::New();
resNode->SetData( mitkResImg );
resNode->SetName("Residuals");
resNode->SetProperty("LookupTable", lutProp);
bool b;
resNode->GetBoolProperty("use color", b);
resNode->SetBoolProperty("use color", false);
GetDefaultDataStorage()->Add(resNode, m_TensorImage);
m_MultiWidget->RequestUpdate();
// Draw Graph
std::vector<double> means = residualFilter->GetMeans();
std::vector<double> q1s = residualFilter->GetQ1();
std::vector<double> q3s = residualFilter->GetQ3();
std::vector<double> percentagesOfOUtliers = residualFilter->GetPercentagesOfOutliers();
m_Controls->m_ResidualAnalysis->SetMeans(means);
m_Controls->m_ResidualAnalysis->SetQ1(q1s);
m_Controls->m_ResidualAnalysis->SetQ3(q3s);
m_Controls->m_ResidualAnalysis->SetPercentagesOfOutliers(percentagesOfOUtliers);
if(m_Controls->m_PercentagesOfOutliers->isChecked())
{
m_Controls->m_ResidualAnalysis->DrawPercentagesOfOutliers();
}
else
{
m_Controls->m_ResidualAnalysis->DrawMeans();
}
// Draw Graph for volumes per slice in the QGraphicsView
std::vector< std::vector<double> > outliersPerSlice = residualFilter->GetOutliersPerSlice();
int xSize = outliersPerSlice.size();
if(xSize == 0)
{
return;
}
int ySize = outliersPerSlice[0].size();
// Find maximum in outliersPerSlice
double maxOutlier= 0.0;
for(int i=0; i<xSize; i++)
{
for(int j=0; j<ySize; j++)
{
if(outliersPerSlice[i][j]>maxOutlier)
{
maxOutlier = outliersPerSlice[i][j];
}
}
}
// Create some QImage
QImage qImage(xSize, ySize, QImage::Format_RGB32);
QImage legend(1, 256, QImage::Format_RGB32);
QRgb value;
vtkSmartPointer<vtkLookupTable> lookup =
vtkSmartPointer<vtkLookupTable>::New();
lookup->SetTableRange(0.0, maxOutlier);
lookup->Build();
reversedlookupTable->SetTableRange(0, maxOutlier);
reversedlookupTable->Build();
for(int i=0; i<256; i++)
{
double* rgba = reversedlookupTable->GetTableValue(255-i);
lookup->SetTableValue(i, rgba[0], rgba[1], rgba[2], rgba[3]);
}
// Fill qImage
for(int i=0; i<xSize; i++)
{
for(int j=0; j<ySize; j++)
{
double out = outliersPerSlice[i][j];
unsigned char *_rgba = lookup->MapValue(out);
int r, g, b;
r = _rgba[0];
g = _rgba[1];
b = _rgba[2];
value = qRgb(r, g, b);
qImage.setPixel(i,j,value);
}
}
for(int i=0; i<256; i++)
{
double* rgba = lookup->GetTableValue(i);
int r, g, b;
r = rgba[0]*255;
g = rgba[1]*255;
b = rgba[2]*255;
value = qRgb(r, g, b);
legend.setPixel(0,255-i,value);
}
QString upper = QString::number(maxOutlier, 'g', 3);
upper.append(" %");
QString lower = QString::number(0.0);
lower.append(" %");
m_Controls->m_UpperLabel->setText(upper);
m_Controls->m_LowerLabel->setText(lower);
QPixmap pixmap(QPixmap::fromImage(qImage));
QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
item->setTransform(QTransform::fromScale(10.0, 3.0), true);
QPixmap pixmap2(QPixmap::fromImage(legend));
QGraphicsPixmapItem *item2 = new QGraphicsPixmapItem(pixmap2);
item2->setTransform(QTransform::fromScale(20.0, 1.0), true);
m_Controls->m_PerSliceView->SetResidualPixmapItem(item);
QGraphicsScene* scene = new QGraphicsScene;
QGraphicsScene* scene2 = new QGraphicsScene;
scene->addItem(item);
scene2->addItem(item2);
m_Controls->m_PerSliceView->setScene(scene);
m_Controls->m_LegendView->setScene(scene2);
m_Controls->m_PerSliceView->show();
m_Controls->m_PerSliceView->repaint();
m_Controls->m_LegendView->setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
m_Controls->m_LegendView->setVerticalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
m_Controls->m_LegendView->show();
m_Controls->m_LegendView->repaint();
}
void QmitkTensorReconstructionView::Reconstruct()
{
int method = m_Controls->m_ReconctructionMethodBox->currentIndex();
switch (method)
{
case 0:
ItkTensorReconstruction(m_DiffusionImages);
break;
case 1:
TensorReconstructionWithCorr(m_DiffusionImages);
break;
default:
ItkTensorReconstruction(m_DiffusionImages);
}
}
void QmitkTensorReconstructionView::TensorReconstructionWithCorr
(mitk::DataStorage::SetOfObjects::Pointer inImages)
{
try
{
int nrFiles = inImages->size();
if (!nrFiles) return;
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
while ( itemiter != itemiterend ) // for all items
{
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef DiffusionImageType::GradientDirectionContainerType GradientDirectionContainerType;
-
- DiffusionImageType* vols = static_cast<DiffusionImageType*>((*itemiter)->GetData());
+ mitk::Image* vols = static_cast<mitk::Image*>((*itemiter)->GetData());
std::string nodename;
(*itemiter)->GetStringProperty("name", nodename);
// TENSOR RECONSTRUCTION
MITK_INFO << "Tensor reconstruction with correction for negative eigenvalues";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Tensor reconstruction for %s", nodename.c_str()).toLatin1());
typedef itk::TensorReconstructionWithEigenvalueCorrectionFilter< DiffusionPixelType, TTensorPixelType > ReconstructionFilter;
float b0Threshold = m_Controls->m_TensorReconstructionThreshold->value();
GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
- for(GradientDirectionContainerType::ConstIterator it = vols->GetDirections()->Begin();
- it != vols->GetDirections()->End(); it++)
+ for(GradientDirectionContainerType::ConstIterator it = static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Begin();
+ it != static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->End(); it++)
{
gradientContainerCopy->push_back(it.Value());
}
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
+
ReconstructionFilter::Pointer reconFilter = ReconstructionFilter::New();
- reconFilter->SetGradientImage( gradientContainerCopy, vols->GetVectorImage() );
- reconFilter->SetBValue(vols->GetReferenceBValue());
+ reconFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer);
+ reconFilter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
reconFilter->SetB0Threshold(b0Threshold);
reconFilter->Update();
typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
TensorImageType::Pointer outputTensorImg = reconFilter->GetOutput();
typedef itk::ImageRegionIterator<TensorImageType> TensorImageIteratorType;
TensorImageIteratorType tensorIt(outputTensorImg, outputTensorImg->GetRequestedRegion());
tensorIt.GoToBegin();
int negatives = 0;
while(!tensorIt.IsAtEnd())
{
typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
TensorType tensor = tensorIt.Get();
TensorType::EigenValuesArrayType ev;
tensor.ComputeEigenValues(ev);
for(unsigned int i=0; i<ev.Size(); i++)
{
if(ev[i] < 0.0)
{
tensor.Fill(0.0);
tensorIt.Set(tensor);
negatives++;
break;
}
}
++tensorIt;
}
MITK_INFO << negatives << " tensors with negative eigenvalues" << std::endl;
mitk::TensorImage::Pointer image = mitk::TensorImage::New();
image->InitializeByItk( outputTensorImg.GetPointer() );
image->SetVolume( outputTensorImg->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
SetDefaultNodeProperties(node, nodename+"_EigenvalueCorrected_DT");
GetDefaultDataStorage()->Add(node, *itemiter);
mitk::ProgressBar::GetInstance()->Progress();
++itemiter;
}
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
m_MultiWidget->RequestUpdate();
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
}
}
void QmitkTensorReconstructionView::ItkTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
while ( itemiter != itemiterend ) // for all items
{
- mitk::DiffusionImage<DiffusionPixelType>* vols =
- static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
+ mitk::Image* vols =
+ static_cast<mitk::Image*>(
(*itemiter)->GetData());
std::string nodename;
(*itemiter)->GetStringProperty("name", nodename);
// TENSOR RECONSTRUCTION
clock.Start();
MITK_DEBUG << "Tensor reconstruction ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Tensor reconstruction for %s", nodename.c_str()).toLatin1());
typedef itk::DiffusionTensor3DReconstructionImageFilter<
DiffusionPixelType, DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter =
TensorReconstructionImageFilterType::New();
- typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
- typedef DiffusionImageType::GradientDirectionContainerType GradientDirectionContainerType;
-
GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
- for(GradientDirectionContainerType::ConstIterator it = vols->GetDirections()->Begin();
- it != vols->GetDirections()->End(); it++)
+ for(GradientDirectionContainerType::ConstIterator it = static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Begin();
+ it != static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->End(); it++)
{
gradientContainerCopy->push_back(it.Value());
}
- tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, vols->GetVectorImage() );
- tensorReconstructionFilter->SetBValue(vols->GetReferenceBValue());
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
+
+ tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer );
+ tensorReconstructionFilter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
tensorReconstructionFilter->SetThreshold( m_Controls->m_TensorReconstructionThreshold->value() );
tensorReconstructionFilter->Update();
clock.Stop();
MITK_DEBUG << "took " << clock.GetMean() << "s.";
// TENSORS TO DATATREE
mitk::TensorImage::Pointer image = mitk::TensorImage::New();
typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
TensorImageType::Pointer tensorImage;
tensorImage = tensorReconstructionFilter->GetOutput();
// Check the tensor for negative eigenvalues
if(m_Controls->m_CheckNegativeEigenvalues->isChecked())
{
typedef itk::ImageRegionIterator<TensorImageType> TensorImageIteratorType;
TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetRequestedRegion());
tensorIt.GoToBegin();
while(!tensorIt.IsAtEnd())
{
typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
//typedef itk::Tensor<TTensorPixelType, 3> TensorType2;
TensorType tensor = tensorIt.Get();
TensorType::EigenValuesArrayType ev;
tensor.ComputeEigenValues(ev);
for(unsigned int i=0; i<ev.Size(); i++)
{
if(ev[i] < 0.0)
{
tensor.Fill(0.0);
tensorIt.Set(tensor);
break;
}
}
++tensorIt;
}
}
- tensorImage->SetDirection( vols->GetVectorImage()->GetDirection() );
+ tensorImage->SetDirection( itkVectorImagePointer->GetDirection() );
image->InitializeByItk( tensorImage.GetPointer() );
image->SetVolume( tensorReconstructionFilter->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
SetDefaultNodeProperties(node, nodename+"_LinearLeastSquares_DT");
GetDefaultDataStorage()->Add(node, *itemiter);
mitk::ProgressBar::GetInstance()->Progress();
++itemiter;
}
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
m_MultiWidget->RequestUpdate();
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
return;
}
}
void QmitkTensorReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
{
node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
node->SetProperty ("layer", mitk::IntProperty::New(100));
node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
node->SetProperty( "name", mitk::StringProperty::New(name) );
}
void QmitkTensorReconstructionView::TensorsToDWI()
{
DoTensorsToDWI(m_TensorImages);
}
void QmitkTensorReconstructionView::TensorsToQbi()
{
for (unsigned int i=0; i<m_TensorImages->size(); i++)
{
mitk::DataNode::Pointer tensorImageNode = m_TensorImages->at(i);
MITK_INFO << "starting Q-Ball estimation";
typedef float TTensorPixelType;
typedef itk::DiffusionTensor3D< TTensorPixelType > TensorPixelType;
typedef itk::Image< TensorPixelType, 3 > TensorImageType;
TensorImageType::Pointer itkvol = TensorImageType::New();
mitk::CastToItkImage(dynamic_cast<mitk::TensorImage*>(tensorImageNode->GetData()), itkvol);
typedef itk::TensorImageToQBallImageFilter< TTensorPixelType, TTensorPixelType > FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetInput( itkvol );
filter->Update();
typedef itk::Vector<TTensorPixelType,QBALL_ODFSIZE> OutputPixelType;
typedef itk::Image<OutputPixelType,3> OutputImageType;
mitk::QBallImage::Pointer image = mitk::QBallImage::New();
OutputImageType::Pointer outimg = filter->GetOutput();
image->InitializeByItk( outimg.GetPointer() );
image->SetVolume( outimg->GetBufferPointer() );
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( image );
node->SetName(tensorImageNode->GetName()+"_Qball");
GetDefaultDataStorage()->Add(node, tensorImageNode);
}
}
void QmitkTensorReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_DiffusionImages = mitk::DataStorage::SetOfObjects::New();
m_TensorImages = mitk::DataStorage::SetOfObjects::New();
bool foundDwiVolume = false;
bool foundTensorVolume = false;
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_DiffusionImage = NULL;
m_TensorImage = NULL;
m_Controls->m_InputData->setTitle("Please Select Input Data");
// iterate selection
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if (node.IsNull())
continue;
// only look at interesting types
- if(dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(node->GetData()))
+ bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+ if ( isDiffusionImage )
{
- foundDwiVolume = true;
- m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
- m_DiffusionImages->push_back(node);
- m_DiffusionImage = node;
+ foundDwiVolume = true;
+ m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
+ m_DiffusionImages->push_back(node);
+ m_DiffusionImage = node;
}
else if(dynamic_cast<mitk::TensorImage*>(node->GetData()))
{
foundTensorVolume = true;
m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
m_TensorImages->push_back(node);
m_TensorImage = node;
}
}
m_Controls->m_StartReconstruction->setEnabled(foundDwiVolume);
m_Controls->m_TensorsToDWIButton->setEnabled(foundTensorVolume);
m_Controls->m_TensorsToQbiButton->setEnabled(foundTensorVolume);
if (foundDwiVolume || foundTensorVolume)
m_Controls->m_InputData->setTitle("Input Data");
m_Controls->m_ResidualButton->setEnabled(foundDwiVolume && foundTensorVolume);
m_Controls->m_PercentagesOfOutliers->setEnabled(foundDwiVolume && foundTensorVolume);
m_Controls->m_PerSliceView->setEnabled(foundDwiVolume && foundTensorVolume);
}
template<int ndirs>
itk::VectorContainer<unsigned int, vnl_vector_fixed<double, 3> >::Pointer
QmitkTensorReconstructionView::MakeGradientList()
{
itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::Pointer retval =
itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::New();
vnl_matrix_fixed<double, 3, ndirs>* U =
itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
for(int i=0; i<ndirs;i++)
{
vnl_vector_fixed<double,3> v;
v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
retval->push_back(v);
}
// Add 0 vector for B0
vnl_vector_fixed<double,3> v;
v.fill(0.0);
retval->push_back(v);
return retval;
}
void QmitkTensorReconstructionView::DoTensorsToDWI(mitk::DataStorage::SetOfObjects::Pointer inImages)
{
try
{
itk::TimeProbe clock;
int nrFiles = inImages->size();
if (!nrFiles) return;
QString status;
mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
while ( itemiter != itemiterend ) // for all items
{
std::string nodename;
(*itemiter)->GetStringProperty("name", nodename);
mitk::TensorImage* vol =
static_cast<mitk::TensorImage*>((*itemiter)->GetData());
typedef float TTensorPixelType;
typedef itk::DiffusionTensor3D< TTensorPixelType > TensorPixelType;
typedef itk::Image< TensorPixelType, 3 > TensorImageType;
TensorImageType::Pointer itkvol = TensorImageType::New();
mitk::CastToItkImage(vol, itkvol);
typedef itk::TensorImageToDiffusionImageFilter<
TTensorPixelType, DiffusionPixelType > FilterType;
FilterType::GradientListPointerType gradientList = FilterType::GradientListType::New();
switch(m_Controls->m_TensorsToDWINumDirsSelect->currentIndex())
{
case 0:
gradientList = MakeGradientList<12>();
break;
case 1:
gradientList = MakeGradientList<42>();
break;
case 2:
gradientList = MakeGradientList<92>();
break;
case 3:
gradientList = MakeGradientList<162>();
break;
case 4:
gradientList = MakeGradientList<252>();
break;
case 5:
gradientList = MakeGradientList<362>();
break;
case 6:
gradientList = MakeGradientList<492>();
break;
case 7:
gradientList = MakeGradientList<642>();
break;
case 8:
gradientList = MakeGradientList<812>();
break;
case 9:
gradientList = MakeGradientList<1002>();
break;
default:
gradientList = MakeGradientList<92>();
}
double bVal = m_Controls->m_TensorsToDWIBValueEdit->text().toDouble();
// DWI ESTIMATION
clock.Start();
MBI_INFO << "DWI Estimation ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
"DWI Estimation for %s", nodename.c_str()).toLatin1());
FilterType::Pointer filter = FilterType::New();
filter->SetInput( itkvol );
filter->SetBValue(bVal);
filter->SetGradientList(gradientList);
//filter->SetNumberOfThreads(1);
filter->Update();
clock.Stop();
MBI_DEBUG << "took " << clock.GetMean() << "s.";
// TENSORS TO DATATREE
- mitk::DiffusionImage<DiffusionPixelType>::Pointer image = mitk::DiffusionImage<DiffusionPixelType>::New();
- image->SetVectorImage( filter->GetOutput() );
- image->SetReferenceBValue(bVal);
- image->SetDirections(gradientList);
- image->InitializeFromVectorImage();
+ mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+
+ image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientList ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( bVal ) );
+ image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New() );
+ mitk::DiffusionPropertyHelper propertyHelper( image );
+ propertyHelper.InitializeImage();
+
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
- mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
+ mitk::ImageVtkMapper2D::SetDefaultProperties(node);
node->SetName(nodename+"_DWI");
GetDefaultDataStorage()->Add(node, *itemiter);
mitk::ProgressBar::GetInstance()->Progress();
++itemiter;
}
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
m_MultiWidget->RequestUpdate();
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
QMessageBox::information(0, "DWI estimation failed:", ex.GetDescription());
return ;
}
}
void QmitkTensorReconstructionView::PreviewThreshold(int threshold)
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_DiffusionImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_DiffusionImages->end() );
while ( itemiter != itemiterend ) // for all items
{
- mitk::DiffusionImage<DiffusionPixelType>* vols =
- static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
- (*itemiter)->GetData());
+ mitk::Image* vols =
+ static_cast<mitk::Image*>(
+ (*itemiter)->GetData());
+
+ ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+ mitk::CastToItkImage(vols, itkVectorImagePointer);
// Extract b0 image
typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
FilterType::Pointer filterB0 = FilterType::New();
- filterB0->SetInput(vols->GetVectorImage());
- filterB0->SetDirections(vols->GetDirections());
+ filterB0->SetInput(itkVectorImagePointer);
+ filterB0->SetDirections(mitk::DiffusionPropertyHelper::GetGradientContainer(vols));
filterB0->Update();
mitk::Image::Pointer mitkImage = mitk::Image::New();
typedef itk::Image<short, 3> ImageType;
typedef itk::Image<short, 3> SegmentationType;
typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
// apply threshold
ThresholdFilterType::Pointer filterThreshold = ThresholdFilterType::New();
filterThreshold->SetInput(filterB0->GetOutput());
filterThreshold->SetLowerThreshold(threshold);
filterThreshold->SetInsideValue(0);
filterThreshold->SetOutsideValue(1); // mark cut off values red
filterThreshold->Update();
mitkImage->InitializeByItk( filterThreshold->GetOutput() );
mitkImage->SetVolume( filterThreshold->GetOutput()->GetBufferPointer() );
mitk::DataNode::Pointer node;
if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
{
node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
}
else
{
// create a new node, to show thresholded values
node = mitk::DataNode::New();
GetDefaultDataStorage()->Add( node, *itemiter );
node->SetProperty( "name", mitk::StringProperty::New("ThresholdOverlay"));
node->SetBoolProperty("helper object", true);
}
node->SetData( mitkImage );
itemiter++;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
index 4fc685b48c..b9879dce2d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
@@ -1,117 +1,124 @@
/*===================================================================
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 _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
#define _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
#include <QmitkFunctionality.h>
#include <string>
#include "ui_QmitkTensorReconstructionViewControls.h"
-#include <mitkDiffusionImage.h>
#include <mitkTensorImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <itkVectorImage.h>
typedef short DiffusionPixelType;
struct TrSelListener;
/*!
* \ingroup org_mitk_gui_qt_tensorreconstruction_internal
*
* \brief QmitkTensorReconstructionView
*
* Document your class here.
*
* \sa QmitkFunctionality
*/
class QmitkTensorReconstructionView : public QmitkFunctionality
{
friend struct TrSelListener;
// this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+ typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType GradientDirectionContainerType;
+ typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMapType;
+ typedef itk::VectorImage< DiffusionPixelType, 3 > ITKDiffusionImageType;
+
static const std::string VIEW_ID;
QmitkTensorReconstructionView();
virtual ~QmitkTensorReconstructionView();
virtual void CreateQtPartControl(QWidget *parent);
/// \brief Creation of the connections of main and control widget
virtual void CreateConnections();
/// \brief Called when the functionality is activated
virtual void Activated();
virtual void Deactivated();
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
static const int nrconvkernels;
protected slots:
void TensorsToQbi();
void TensorsToDWI();
void DoTensorsToDWI(mitk::DataStorage::SetOfObjects::Pointer inImages);
void Advanced1CheckboxClicked();
void Reconstruct();
void ResidualCalculation();
void ResidualClicked(int slice, int volume);
/**
* @brief PreviewThreshold Generates a preview of the values that are cut off by the thresholds
* @param threshold
*/
void PreviewThreshold(int threshold);
protected:
void ItkTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
void TeemTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
void TensorReconstructionWithCorr(mitk::DataStorage::SetOfObjects::Pointer inImages);
void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkTensorReconstructionViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
template<int ndirs> itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::Pointer MakeGradientList();
template<int L>
- void TemplatedAnalyticalTensorReconstruction(mitk::DiffusionImage<DiffusionPixelType>* vols,
+ void TemplatedAnalyticalTensorReconstruction(mitk::Image* vols,
float lambda, std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes, int normalization);
void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
mitk::DataNode::Pointer m_DiffusionImage;
mitk::DataNode::Pointer m_TensorImage;
mitk::DataStorage::SetOfObjects::Pointer m_DiffusionImages;
mitk::DataStorage::SetOfObjects::Pointer m_TensorImages;
};
#endif // _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp
index 90fc60313c..cc4ab8735d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp
@@ -1,138 +1,137 @@
/*===================================================================
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 "QmitkNavigationButtonsView.h"
#include "mitkNodePredicateDataType.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkResliceMethodProperty.h"
#include "mitkRenderingManager.h"
-#include "mitkDiffusionImage.h"
#include "mitkPlanarFigure.h"
#include "mitkFiberBundle.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFiberBundleInteractor.h"
#include "mitkPlanarFigureInteractor.h"
#include "mitkGlobalInteraction.h"
#include "mitkGeometry2D.h"
#include "berryIWorkbenchWindow.h"
#include "berryIWorkbenchPage.h"
#include "berryISelectionService.h"
#include "berryConstants.h"
#include "berryPlatformUI.h"
#include "itkRGBAPixel.h"
#include "itkTractsToProbabilityImageFilter.h"
#include "qwidgetaction.h"
#include "qcolordialog.h"
const std::string QmitkNavigationButtonsView::VIEW_ID = "org.mitk.views.NavigationButtonsview";
using namespace berry;
QmitkNavigationButtonsView::QmitkNavigationButtonsView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL),
{
}
QmitkNavigationButtonsView::QmitkNavigationButtonsView(const QmitkNavigationButtonsView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkNavigationButtonsView::~QmitkNavigationButtonsView()
{
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
}
void QmitkNavigationButtonsView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationButtonsViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkNavigationButtonsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkNavigationButtonsView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkNavigationButtonsView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
}
}
void QmitkNavigationButtonsView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkNavigationButtonsView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
int QmitkNavigationButtonsView::GetSizeFlags(bool width)
{
if(!width)
{
return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
}
else
{
return 0;
}
}
int QmitkNavigationButtonsView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
{
if(width==false)
{
return m_FoundSingleOdfImage ? 120 : 80;
}
else
{
return preferredResult;
}
}
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
index 269a1d88b4..d6a7202954 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
@@ -1,950 +1,949 @@
/*===================================================================
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 "QmitkNavigationButtonsView.h"
#include "mitkNodePredicateDataType.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkResliceMethodProperty.h"
#include "mitkRenderingManager.h"
#include "mitkModuleRegistry.h"
-#include "mitkDiffusionImage.h"
#include "mitkPlanarFigure.h"
#include "mitkFiberBundle.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFiberBundleInteractor.h"
#include "mitkPlanarFigureInteractor.h"
#include "mitkGlobalInteraction.h"
#include "mitkGeometry2D.h"
#include "berryIWorkbenchWindow.h"
#include "berryIWorkbenchPage.h"
#include "berryISelectionService.h"
#include "berryConstants.h"
#include "berryPlatformUI.h"
#include "itkRGBAPixel.h"
#include "itkTractsToProbabilityImageFilter.h"
#include "qwidgetaction.h"
#include "qcolordialog.h"
const std::string QmitkNavigationButtonsView::VIEW_ID = "org.mitk.views.NavigationButtonsview";
using namespace berry;
QmitkNavigationButtonsView::QmitkNavigationButtonsView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL),
{
}
QmitkNavigationButtonsView::QmitkNavigationButtonsView(const QmitkNavigationButtonsView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkNavigationButtonsView::~QmitkNavigationButtonsView()
{
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
}
void QmitkNavigationButtonsView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationButtonsViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkNavigationButtonsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkNavigationButtonsView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkNavigationButtonsView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
}
}
void QmitkNavigationButtonsView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkNavigationButtonsView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
int QmitkNavigationButtonsView::GetSizeFlags(bool width)
{
if(!width)
{
return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
}
else
{
return 0;
}
}
int QmitkNavigationButtonsView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
{
if(width==false)
{
return m_FoundSingleOdfImage ? 120 : 80;
}
else
{
return preferredResult;
}
}
mitk::DataStorage::SetOfObjects::Pointer
QmitkNavigationButtonsView::ActiveSet(std::string classname)
{
if (m_CurrentSelection)
{
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
i != m_CurrentSelection->End();
++i)
{
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
if(QString(classname.c_str()).compare(node->GetData()->GetNameOfClass())==0)
{
set->InsertElement(at++, node);
}
}
}
return set;
}
return 0;
}
void QmitkNavigationButtonsView::SetBoolProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, bool value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetBoolProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetIntProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, int value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetFloatProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, float value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetFloatProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetLevelWindowProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::LevelWindow value)
{
if(set.IsNotNull())
{
mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), prop);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetEnumProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::EnumerationProperty::Pointer value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::DisplayIndexChanged(int dispIndex)
{
QString label = "Channel %1";
label = label.arg(dispIndex);
m_Controls->label_channel->setText(label);
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("DiffusionImage");
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
++itemiter;
}
//m_MultiWidget->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkNavigationButtonsView::Reinit()
{
if (m_CurrentSelection)
{
mitk::DataNodeObject::Pointer nodeObj =
m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkNavigationButtonsView::TextIntON()
{
if(m_TexIsOn)
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
}
else
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("DiffusionImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("TensorImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("QBallImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("Image");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
m_TexIsOn = !m_TexIsOn;
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::VisibleOdfsON_S()
{
if(m_GlyIsOn_S)
{
m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyOFF_S);
}
else
{
m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyON_S);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
set = ActiveSet("TensorImage");
SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
m_GlyIsOn_S = !m_GlyIsOn_S;
VisibleOdfsON(0);
}
void QmitkNavigationButtonsView::VisibleOdfsON_T()
{
if(m_GlyIsOn_T)
{
m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyOFF_T);
}
else
{
m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyON_T);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
set = ActiveSet("TensorImage");
SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
m_GlyIsOn_T = !m_GlyIsOn_T;
VisibleOdfsON(1);
}
void QmitkNavigationButtonsView::VisibleOdfsON_C()
{
if(m_GlyIsOn_C)
{
m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyOFF_C);
}
else
{
m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyON_C);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
set = ActiveSet("TensorImage");
SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
m_GlyIsOn_C = !m_GlyIsOn_C;
VisibleOdfsON(2);
}
void QmitkNavigationButtonsView::VisibleOdfsON(int view)
{
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::ShowMaxNumberChanged()
{
int maxNr = m_Controls->m_ShowMaxNumber->value();
if ( maxNr < 1 )
{
m_Controls->m_ShowMaxNumber->setValue( 1 );
maxNr = 1;
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
set = ActiveSet("TensorImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::NormalizationDropdownChanged(int normDropdown)
{
typedef mitk::OdfNormalizationMethodProperty PropType;
PropType::Pointer normMeth = PropType::New();
switch(normDropdown)
{
case 0:
normMeth->SetNormalizationToMinMax();
break;
case 1:
normMeth->SetNormalizationToMax();
break;
case 2:
normMeth->SetNormalizationToNone();
break;
case 3:
normMeth->SetNormalizationToGlobalMax();
break;
default:
normMeth->SetNormalizationToMinMax();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::ScalingFactorChanged(double scalingFactor)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"Scaling", scalingFactor);
set = ActiveSet("TensorImage");
SetFloatProp(set,"Scaling", scalingFactor);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::AdditionalScaling(int additionalScaling)
{
typedef mitk::OdfScaleByProperty PropType;
PropType::Pointer scaleBy = PropType::New();
switch(additionalScaling)
{
case 0:
scaleBy->SetScaleByNothing();
break;
case 1:
scaleBy->SetScaleByGFA();
//m_Controls->params_frame->setVisible(true);
break;
#ifdef DIFFUSION_IMAGING_EXTENDED
case 2:
scaleBy->SetScaleByPrincipalCurvature();
// commented in for SPIE paper, Principle curvature scaling
//m_Controls->params_frame->setVisible(true);
break;
#endif
default:
scaleBy->SetScaleByNothing();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::IndexParam1Changed(double param1)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam1", param1);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam1", param1);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::IndexParam2Changed(double param2)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam2", param2);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam2", param2);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::OpacityChanged(double l, double u)
{
mitk::LevelWindow olw;
olw.SetRangeMinMax(l*255, u*255);
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("TensorImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("Image");
SetLevelWindowProp(set,"opaclevelwindow", olw);
m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::ScalingCheckbox()
{
m_Controls->m_ScalingFrame->setVisible(
m_Controls->m_ScalingCheckbox->isChecked());
}
void QmitkNavigationButtonsView::BundleRepresentationWire()
{
if(m_SelectedNode)
{
int width = m_Controls->m_LineWidth->value();
m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkNavigationButtonsView::BundleRepresentationTube()
{
if(m_SelectedNode)
{
float radius = m_Controls->m_TubeRadius->value() / 100.0;
m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkNavigationButtonsView::BundleRepresentationColor()
{
if(m_SelectedNode)
{
QColor color = QColorDialog::getColor();
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(14));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkNavigationButtonsView::PlanarFigureFocus()
{
if(m_SelectedNode)
{
mitk::PlanarFigure* _PlanarFigure = 0;
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
if (_PlanarFigure)
{
QmitkRenderWindow* selectedRenderWindow = 0;
bool PlanarFigureInitializedWindow = false;
QmitkRenderWindow* RenderWindow1 =
this->GetActiveStdMultiWidget()->GetRenderWindow1();
if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
{
selectedRenderWindow = RenderWindow1;
}
QmitkRenderWindow* RenderWindow2 =
this->GetActiveStdMultiWidget()->GetRenderWindow2();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow2->GetRenderer()))
{
selectedRenderWindow = RenderWindow2;
}
QmitkRenderWindow* RenderWindow3 =
this->GetActiveStdMultiWidget()->GetRenderWindow3();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow3->GetRenderer()))
{
selectedRenderWindow = RenderWindow3;
}
QmitkRenderWindow* RenderWindow4 =
this->GetActiveStdMultiWidget()->GetRenderWindow4();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow4->GetRenderer()))
{
selectedRenderWindow = RenderWindow4;
}
const mitk::PlaneGeometry
* _PlaneGeometry =
dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry1 =
RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane1 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry2 =
RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane2 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry3 =
RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane3 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
normal[0] = fabs(normal[0]); normal[1] = fabs(normal[1]); normal[2] = fabs(normal[2]);
normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
double ang1 = angle(normal, normal1);
double ang2 = angle(normal, normal2);
double ang3 = angle(normal, normal3);
if(ang1 < ang2 && ang1 < ang3)
{
selectedRenderWindow = RenderWindow1;
}
else
{
if(ang2 < ang3)
{
selectedRenderWindow = RenderWindow2;
}
else
{
selectedRenderWindow = RenderWindow3;
}
}
// make node visible
if (selectedRenderWindow)
{
mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
centerP, _PlaneGeometry->GetNormal());
selectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
centerP);
}
}
// set interactor for new node (if not already set)
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New();
mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "MitkPlanarFigure" );
figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
figureInteractor->SetDataNode( m_SelectedNode );
}
m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
}
}
void QmitkNavigationButtonsView::SetInteractor()
{
typedef std::vector<mitk::DataNode*> Container;
Container _NodeSet = this->GetDataManagerSelection();
mitk::DataNode* node = 0;
mitk::FiberBundle* bundle = 0;
mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
// finally add all nodes to the model
for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
; it++)
{
node = const_cast<mitk::DataNode*>(*it);
bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
if(bundle)
{
bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
if(bundleInteractor.IsNotNull())
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
if(!m_Controls->m_Crosshair->isChecked())
{
m_Controls->m_Crosshair->setChecked(false);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
m_CurrentPickingNode = 0;
}
else
{
m_Controls->m_Crosshair->setChecked(true);
bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
m_CurrentPickingNode = node;
}
}
}
}
void QmitkNavigationButtonsView::PFWidth(int w)
{
double width = w/10.0;
m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QString label = "Width %1";
label = label.arg(width);
m_Controls->label_pfwidth->setText(label);
}
void QmitkNavigationButtonsView::PFColor()
{
QColor color = QColorDialog::getColor();
m_Controls->m_PFColor->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_PFColor->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
// m_SelectedNode->SetProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkNavigationButtonsView::PFColor3D()
{
QColor color = QColorDialog::getColor();
m_Controls->m_PFColor3D->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_PFColor3D->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkNavigationButtonsView::Heatmap()
{
if(m_SelectedNode)
{
mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
if(!bundle)
return;
///////////////////////////////
// Generate unsigned char Image
typedef unsigned char OutPixType2;
// run generator
typedef itk::Image< float, 3 > WMPImageType;
typedef itk::TractsToProbabilityImageFilter<WMPImageType,
OutPixType2> ImageGeneratorType2;
ImageGeneratorType2::Pointer generator = ImageGeneratorType2::New();
//generator->SetInput(NULL);
generator->SetFiberBundle(bundle);
generator->SetInvertImage(false);
generator->SetUpsamplingFactor(2);
generator->SetBinaryEnvelope(false);
generator->Update();
// get result
typedef itk::Image<OutPixType2,3> OutType2;
OutType2::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img2 = mitk::Image::New();
img2->InitializeByItk(outImg.GetPointer());
img2->SetVolume(outImg->GetBufferPointer());
// to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img2);
QString name(m_SelectedNode->GetName().c_str());
name += "_heatmap";
node->SetName(name.toStdString());
node->SetVisibility(true);
GetDataStorage()->Add(node);
}
}
void QmitkNavigationButtonsView::LineWidthChanged(int w)
{
m_SelectedNode->SetIntProperty("LineWidth", w);
QString label = "Width %1";
label = label.arg(w);
m_Controls->label_linewidth->setText(label);
}
void QmitkNavigationButtonsView::TubeRadiusChanged(int r)
{
m_SelectedNode->SetFloatProperty("TubeRadius", (float) r / 100.0);
QString label = "Radius %1";
label = label.arg(r / 100.0);
m_Controls->label_tuberadius->setText(label);
}
void QmitkNavigationButtonsView::Welcome()
{
berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
GetSite()->GetWorkbenchWindow(), false);
}