diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
index 43e32282a7..f437cccdf5 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
@@ -1,864 +1,864 @@
/*===================================================================
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 "mitkConnectomicsNetworkCreator.h"
#include <sstream>
#include <vector>
#include "mitkConnectomicsConstantsManager.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkImageCast.h"
#include "itkImageRegionIteratorWithIndex.h"
// VTK
#include <vtkPolyData.h>
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator()
: m_FiberBundle()
, m_Segmentation()
, m_ConNetwork( mitk::ConnectomicsNetwork::New() )
, idCounter(0)
, m_LabelToVertexMap()
, m_LabelToNodePropertyMap()
, allowLoops( false )
, m_UseCoMCoordinates( false )
, m_LabelsToCoordinatesMap()
, m_MappingStrategy( EndElementPositionAvoidingWhiteMatter )
, m_EndPointSearchRadius( 10.0 )
, m_ZeroLabelInvalid( true )
, m_AbortConnection( false )
{
}
-mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundleX::Pointer fiberBundle )
+mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundle::Pointer fiberBundle )
: m_FiberBundle(fiberBundle)
, m_Segmentation(segmentation)
, m_ConNetwork( mitk::ConnectomicsNetwork::New() )
, idCounter(0)
, m_LabelToVertexMap()
, m_LabelToNodePropertyMap()
, allowLoops( false )
, m_LabelsToCoordinatesMap()
, m_MappingStrategy( EndElementPositionAvoidingWhiteMatter )
, m_EndPointSearchRadius( 10.0 )
, m_ZeroLabelInvalid( true )
, m_AbortConnection( false )
{
mitk::CastToItkImage( segmentation, m_SegmentationItk );
}
mitk::ConnectomicsNetworkCreator::~ConnectomicsNetworkCreator()
{
}
-void mitk::ConnectomicsNetworkCreator::SetFiberBundle(mitk::FiberBundleX::Pointer fiberBundle)
+void mitk::ConnectomicsNetworkCreator::SetFiberBundle(mitk::FiberBundle::Pointer fiberBundle)
{
m_FiberBundle = fiberBundle;
}
void mitk::ConnectomicsNetworkCreator::SetSegmentation(mitk::Image::Pointer segmentation)
{
m_Segmentation = segmentation;
mitk::CastToItkImage( segmentation, m_SegmentationItk );
}
itk::Point<float, 3> mitk::ConnectomicsNetworkCreator::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
void mitk::ConnectomicsNetworkCreator::CreateNetworkFromFibersAndSegmentation()
{
//empty graph
m_ConNetwork = mitk::ConnectomicsNetwork::New();
m_LabelToVertexMap.clear();
m_LabelToNodePropertyMap.clear();
idCounter = 0;
vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int numFibers = m_FiberBundle->GetNumFibers();
for( int fiberID( 0 ); fiberID < numFibers; fiberID++ )
{
vtkIdType numPointsInCell(0);
vtkIdType* pointsInCell(NULL);
vLines->GetNextCell ( numPointsInCell, pointsInCell );
TractType::Pointer singleTract = TractType::New();
for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
{
// push back point
PointType point = GetItkPoint( fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] ) );
singleTract->InsertElement( singleTract->Size(), point );
}
if ( singleTract && ( singleTract->Size() > 0 ) )
{
AddConnectionToNetwork(
ReturnAssociatedVertexPairForLabelPair(
ReturnLabelForFiberTract( singleTract, m_MappingStrategy )
)
);
m_AbortConnection = false;
}
}
// Prune unconnected nodes
//m_ConNetwork->PruneUnconnectedSingleNodes();
// provide network with geometry
m_ConNetwork->SetGeometry( dynamic_cast<mitk::BaseGeometry*>(m_Segmentation->GetGeometry()->Clone().GetPointer()) );
m_ConNetwork->UpdateBounds();
m_ConNetwork->SetIsModified( true );
MBI_INFO << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_INFO_NETWORK_CREATED;
}
void mitk::ConnectomicsNetworkCreator::AddConnectionToNetwork(ConnectionType newConnection)
{
if( m_AbortConnection )
{
MITK_DEBUG << "Connection aborted";
return;
}
VertexType vertexA = newConnection.first;
VertexType vertexB = newConnection.second;
// check for loops (if they are not allowed)
if( allowLoops || !( vertexA == vertexB ) )
{
// If the connection already exists, increment weight, else create connection
if ( m_ConNetwork->EdgeExists( vertexA, vertexB ) )
{
m_ConNetwork->IncreaseEdgeWeight( vertexA, vertexB );
}
else
{
m_ConNetwork->AddEdge( vertexA, vertexB );
}
}
}
mitk::ConnectomicsNetworkCreator::VertexType mitk::ConnectomicsNetworkCreator::ReturnAssociatedVertexForLabel( ImageLabelType label )
{
if( m_ZeroLabelInvalid && ( label == 0 ) )
{
m_AbortConnection = true;
return ULONG_MAX;
}
// if label is not known, create entry
if( ! ( m_LabelToVertexMap.count( label ) > 0 ) )
{
VertexType newVertex = m_ConNetwork->AddVertex( idCounter );
idCounter++;
SupplyVertexWithInformation(label, newVertex);
m_LabelToVertexMap.insert( std::pair< ImageLabelType, VertexType >( label, newVertex ) );
}
//return associated vertex
return m_LabelToVertexMap.find( label )->second;
}
mitk::ConnectomicsNetworkCreator::ConnectionType mitk::ConnectomicsNetworkCreator::ReturnAssociatedVertexPairForLabelPair( ImageLabelPairType labelpair )
{
//hand both labels through to the single label function
ConnectionType connection( ReturnAssociatedVertexForLabel(labelpair.first), ReturnAssociatedVertexForLabel(labelpair.second) );
return connection;
}
mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::ReturnLabelForFiberTract( TractType::Pointer singleTract, mitk::ConnectomicsNetworkCreator::MappingStrategy strategy)
{
switch( strategy )
{
case EndElementPosition:
{
return EndElementPositionLabel( singleTract );
}
case JustEndPointVerticesNoLabel:
{
return JustEndPointVerticesNoLabelTest( singleTract );
}
case EndElementPositionAvoidingWhiteMatter:
{
return EndElementPositionLabelAvoidingWhiteMatter( singleTract );
}
case PrecomputeAndDistance:
{
return PrecomputeVertexLocationsBySegmentation( singleTract );
}
}
// To remove warnings, this code should never be reached
MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_MAPPING;
ImageLabelPairType nullPair( 0,0 );
return nullPair;
}
mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::EndElementPositionLabel( TractType::Pointer singleTract )
{
ImageLabelPairType labelpair;
{// Note: .fib image tracts are safed using index coordinates
mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
mitk::Point3D firstElementSegCoord, lastElementSegCoord;
itk::Index<3> firstElementSegIndex, lastElementSegIndex;
if( singleTract->front().Size() != 3 )
{
MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
}
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
}
// convert from fiber index coordinates to segmentation index coordinates
FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
for( int index = 0; index < 3; index++ )
{
firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
}
int firstLabel = m_SegmentationItk->GetPixel(firstElementSegIndex);
int lastLabel = m_SegmentationItk->GetPixel(lastElementSegIndex );
labelpair.first = firstLabel;
labelpair.second = lastLabel;
// Add property to property map
CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
}
return labelpair;
}
mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::PrecomputeVertexLocationsBySegmentation( TractType::Pointer /*singleTract*/ )
{
ImageLabelPairType labelpair;
return labelpair;
}
mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::EndElementPositionLabelAvoidingWhiteMatter( TractType::Pointer singleTract )
{
ImageLabelPairType labelpair;
{// Note: .fib image tracts are safed using index coordinates
mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
mitk::Point3D firstElementSegCoord, lastElementSegCoord;
itk::Index<3> firstElementSegIndex, lastElementSegIndex;
if( singleTract->front().Size() != 3 )
{
MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
}
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
}
// convert from fiber index coordinates to segmentation index coordinates
FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
for( int index = 0; index < 3; index++ )
{
firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
}
int firstLabel = m_SegmentationItk->GetPixel(firstElementSegIndex);
int lastLabel = m_SegmentationItk->GetPixel(lastElementSegIndex );
// Check whether the labels belong to the white matter (which means, that the fibers ended early)
bool extendFront(false), extendEnd(false), retractFront(false), retractEnd(false);
extendFront = !IsNonWhiteMatterLabel( firstLabel );
extendEnd = !IsNonWhiteMatterLabel( lastLabel );
retractFront = IsBackgroundLabel( firstLabel );
retractEnd = IsBackgroundLabel( lastLabel );
//if( extendFront || extendEnd )
//{
//MBI_INFO << "Before Start: " << firstLabel << " at " << firstElementSegIndex[ 0 ] << " " << firstElementSegIndex[ 1 ] << " " << firstElementSegIndex[ 2 ] << " End: " << lastLabel << " at " << lastElementSegIndex[ 0 ] << " " << lastElementSegIndex[ 1 ] << " " << lastElementSegIndex[ 2 ];
//}
if ( extendFront )
{
std::vector< int > indexVectorOfPointsToUse;
//Use first two points for direction
indexVectorOfPointsToUse.push_back( 1 );
indexVectorOfPointsToUse.push_back( 0 );
// label and coordinate temp storage
int tempLabel( firstLabel );
itk::Index<3> tempIndex = firstElementSegIndex;
LinearExtensionUntilGreyMatter( indexVectorOfPointsToUse, singleTract, tempLabel, tempIndex );
firstLabel = tempLabel;
firstElementSegIndex = tempIndex;
}
if ( extendEnd )
{
std::vector< int > indexVectorOfPointsToUse;
//Use last two points for direction
indexVectorOfPointsToUse.push_back( singleTract->Size() - 2 );
indexVectorOfPointsToUse.push_back( singleTract->Size() - 1 );
// label and coordinate temp storage
int tempLabel( lastLabel );
itk::Index<3> tempIndex = lastElementSegIndex;
LinearExtensionUntilGreyMatter( indexVectorOfPointsToUse, singleTract, tempLabel, tempIndex );
lastLabel = tempLabel;
lastElementSegIndex = tempIndex;
}
if ( retractFront )
{
// label and coordinate temp storage
int tempLabel( firstLabel );
itk::Index<3> tempIndex = firstElementSegIndex;
RetractionUntilBrainMatter( true, singleTract, tempLabel, tempIndex );
firstLabel = tempLabel;
firstElementSegIndex = tempIndex;
}
if ( retractEnd )
{
// label and coordinate temp storage
int tempLabel( lastLabel );
itk::Index<3> tempIndex = lastElementSegIndex;
RetractionUntilBrainMatter( false, singleTract, tempLabel, tempIndex );
lastLabel = tempLabel;
lastElementSegIndex = tempIndex;
}
//if( extendFront || extendEnd )
//{
// MBI_INFO << "After Start: " << firstLabel << " at " << firstElementSegIndex[ 0 ] << " " << firstElementSegIndex[ 1 ] << " " << firstElementSegIndex[ 2 ] << " End: " << lastLabel << " at " << lastElementSegIndex[ 0 ] << " " << lastElementSegIndex[ 1 ] << " " << lastElementSegIndex[ 2 ];
//}
labelpair.first = firstLabel;
labelpair.second = lastLabel;
// Add property to property map
CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
}
return labelpair;
}
mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::JustEndPointVerticesNoLabelTest( TractType::Pointer singleTract )
{
ImageLabelPairType labelpair;
{// Note: .fib image tracts are safed using index coordinates
mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
mitk::Point3D firstElementSegCoord, lastElementSegCoord;
itk::Index<3> firstElementSegIndex, lastElementSegIndex;
if( singleTract->front().Size() != 3 )
{
MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
}
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
}
// convert from fiber index coordinates to segmentation index coordinates
FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
for( int index = 0; index < 3; index++ )
{
firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
}
int firstLabel = 1 * firstElementSegIndex[ 0 ] + 1000 * firstElementSegIndex[ 1 ] + 1000000 * firstElementSegIndex[ 2 ];
int lastLabel = 1 * firstElementSegIndex[ 0 ] + 1000 * firstElementSegIndex[ 1 ] + 1000000 * firstElementSegIndex[ 2 ];
labelpair.first = firstLabel;
labelpair.second = lastLabel;
// Add property to property map
CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
}
return labelpair;
}
void mitk::ConnectomicsNetworkCreator::SupplyVertexWithInformation( ImageLabelType& label, VertexType& vertex )
{ // supply a vertex with the additional information belonging to the label
// TODO: Implement additional information acquisition
m_ConNetwork->SetLabel( vertex, m_LabelToNodePropertyMap.find( label )->second.label );
m_ConNetwork->SetCoordinates( vertex, m_LabelToNodePropertyMap.find( label )->second.coordinates );
}
std::string mitk::ConnectomicsNetworkCreator::LabelToString( ImageLabelType& label )
{
int tempInt = (int) label;
std::stringstream ss;//create a stringstream
std::string tempString;
ss << tempInt;//add number to the stream
tempString = ss.str();
return tempString;//return a string with the contents of the stream
}
mitk::ConnectomicsNetwork::Pointer mitk::ConnectomicsNetworkCreator::GetNetwork()
{
return m_ConNetwork;
}
void mitk::ConnectomicsNetworkCreator::FiberToSegmentationCoords( mitk::Point3D& fiberCoord, mitk::Point3D& segCoord )
{
mitk::Point3D tempPoint;
// convert from fiber index coordinates to segmentation index coordinates
m_FiberBundle->GetGeometry()->IndexToWorld( fiberCoord, tempPoint );
m_Segmentation->GetGeometry()->WorldToIndex( tempPoint, segCoord );
}
void mitk::ConnectomicsNetworkCreator::SegmentationToFiberCoords( mitk::Point3D& segCoord, mitk::Point3D& fiberCoord )
{
mitk::Point3D tempPoint;
// convert from fiber index coordinates to segmentation index coordinates
m_Segmentation->GetGeometry()->IndexToWorld( segCoord, tempPoint );
m_FiberBundle->GetGeometry()->WorldToIndex( tempPoint, fiberCoord );
}
bool mitk::ConnectomicsNetworkCreator::IsNonWhiteMatterLabel( int labelInQuestion )
{
bool isWhite( false );
isWhite = (
( labelInQuestion == freesurfer_Left_Cerebral_White_Matter ) ||
( labelInQuestion == freesurfer_Left_Cerebellum_White_Matter ) ||
( labelInQuestion == freesurfer_Right_Cerebral_White_Matter ) ||
( labelInQuestion == freesurfer_Right_Cerebellum_White_Matter )||
( labelInQuestion == freesurfer_Left_Cerebellum_Cortex ) ||
( labelInQuestion == freesurfer_Right_Cerebellum_Cortex ) ||
( labelInQuestion == freesurfer_Brain_Stem )
);
return !isWhite;
}
bool mitk::ConnectomicsNetworkCreator::IsBackgroundLabel( int labelInQuestion )
{
bool isBackground( false );
isBackground = ( labelInQuestion == 0 );
return isBackground;
}
void mitk::ConnectomicsNetworkCreator::LinearExtensionUntilGreyMatter(
std::vector<int> & indexVectorOfPointsToUse,
TractType::Pointer singleTract,
int & label,
itk::Index<3> & mitkIndex )
{
if( indexVectorOfPointsToUse.size() > singleTract->Size() )
{
MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_MORE_POINTS_THAN_PRESENT;
return;
}
if( indexVectorOfPointsToUse.size() < 2 )
{
MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_LESS_THAN_2;
return;
}
for( unsigned int index( 0 ); index < indexVectorOfPointsToUse.size(); index++ )
{
if( indexVectorOfPointsToUse[ index ] < 0 )
{
MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_START;
return;
}
if( (unsigned int)indexVectorOfPointsToUse[ index ] > singleTract->Size() )
{
MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_END;
return;
}
}
mitk::Point3D startPoint, endPoint;
std::vector< double > differenceVector;
differenceVector.resize( singleTract->front().Size() );
{
// which points to use, currently only last two //TODO correct using all points
int endPointIndex = indexVectorOfPointsToUse.size() - 1;
int startPointIndex = indexVectorOfPointsToUse.size() - 2;
// convert to segmentation coords
mitk::Point3D startFiber, endFiber;
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
endFiber.SetElement( index, singleTract->GetElement( indexVectorOfPointsToUse[ endPointIndex ] ).GetElement( index ) );
startFiber.SetElement( index, singleTract->GetElement( indexVectorOfPointsToUse[ startPointIndex ] ).GetElement( index ) );
}
FiberToSegmentationCoords( endFiber, endPoint );
FiberToSegmentationCoords( startFiber, startPoint );
// calculate straight line
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
differenceVector[ index ] = endPoint.GetElement( index ) - startPoint.GetElement( index );
}
// normalizing direction vector
double length( 0.0 );
double sum( 0.0 );
for( unsigned int index = 0; index < differenceVector.size() ; index++ )
{
sum = sum + differenceVector[ index ] * differenceVector[ index ];
}
length = std::sqrt( sum );
for( unsigned int index = 0; index < differenceVector.size() ; index++ )
{
differenceVector[ index ] = differenceVector[ index ] / length;
}
// follow line until first non white matter label
itk::Index<3> tempIndex;
int tempLabel( label );
bool keepOn( true );
itk::ImageRegion<3> itkRegion = m_SegmentationItk->GetLargestPossibleRegion();
for( int parameter( 0 ) ; keepOn ; parameter++ )
{
if( parameter > 1000 )
{
MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_DID_NOT_FIND_WHITE;
break;
}
for( int index( 0 ); index < 3; index++ )
{
tempIndex.SetElement( index, endPoint.GetElement( index ) + parameter * differenceVector[ index ] );
}
if( itkRegion.IsInside( tempIndex ) )
{
tempLabel = m_SegmentationItk->GetPixel( tempIndex );
}
else
{
tempLabel = -1;
}
if( IsNonWhiteMatterLabel( tempLabel ) )
{
if( tempLabel < 1 )
{
keepOn = false;
//MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_NOT_EXTEND_TO_WHITE;
}
else
{
label = tempLabel;
mitkIndex = tempIndex;
keepOn = false;
}
}
}
}
}
void mitk::ConnectomicsNetworkCreator::RetractionUntilBrainMatter( bool retractFront, TractType::Pointer singleTract,
int & label, itk::Index<3> & mitkIndex )
{
int retractionStartIndex( singleTract->Size() - 1 );
int retractionStepIndexSize( -1 );
int retractionTerminationIndex( 0 );
if( retractFront )
{
retractionStartIndex = 0;
retractionStepIndexSize = 1;
retractionTerminationIndex = singleTract->Size() - 1;
}
int currentRetractionIndex = retractionStartIndex;
bool keepRetracting( true );
mitk::Point3D currentPoint, nextPoint;
std::vector< double > differenceVector;
differenceVector.resize( singleTract->front().Size() );
while( keepRetracting && ( currentRetractionIndex != retractionTerminationIndex ) )
{
// convert to segmentation coords
mitk::Point3D currentPointFiberCoord, nextPointFiberCoord;
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
currentPointFiberCoord.SetElement( index, singleTract->GetElement( currentRetractionIndex ).GetElement( index ) );
nextPointFiberCoord.SetElement( index, singleTract->GetElement( currentRetractionIndex + retractionStepIndexSize ).GetElement( index ) );
}
FiberToSegmentationCoords( currentPointFiberCoord, currentPoint );
FiberToSegmentationCoords( nextPointFiberCoord, nextPoint );
// calculate straight line
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
differenceVector[ index ] = nextPoint.GetElement( index ) - currentPoint.GetElement( index );
}
// calculate length of direction vector
double length( 0.0 );
double sum( 0.0 );
for( unsigned int index = 0; index < differenceVector.size() ; index++ )
{
sum = sum + differenceVector[ index ] * differenceVector[ index ];
}
length = std::sqrt( sum );
// retract
itk::Index<3> tempIndex;
int tempLabel( label );
for( int parameter( 0 ) ; parameter < length ; parameter++ )
{
for( int index( 0 ); index < 3; index++ )
{
tempIndex.SetElement( index,
currentPoint.GetElement( index ) + ( 1.0 + parameter ) / ( 1.0 + length ) * differenceVector[ index ] );
}
tempLabel = m_SegmentationItk->GetPixel( tempIndex );
if( !IsBackgroundLabel( tempLabel ) )
{
// check whether result is within the search space
{
mitk::Point3D endPoint, foundPointSegmentation, foundPointFiber;
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
// this is in fiber (world) coordinates
endPoint.SetElement( index, singleTract->GetElement( retractionStartIndex ).GetElement( index ) );
}
for( int index( 0 ); index < 3; index++ )
{
foundPointSegmentation.SetElement( index,
currentPoint.GetElement( index ) + ( 1.0 + parameter ) / ( 1.0 + length ) * differenceVector[ index ] );
}
SegmentationToFiberCoords( foundPointSegmentation, foundPointFiber );
std::vector< double > finalDistance;
finalDistance.resize( singleTract->front().Size() );
for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
{
finalDistance[ index ] = foundPointFiber.GetElement( index ) - endPoint.GetElement( index );
}
// calculate length of direction vector
double finalLength( 0.0 );
double finalSum( 0.0 );
for( unsigned int index = 0; index < finalDistance.size() ; index++ )
{
finalSum = finalSum + finalDistance[ index ] * finalDistance[ index ];
}
finalLength = std::sqrt( finalSum );
if( finalLength > m_EndPointSearchRadius )
{
// the found point was not within the search space
return;
}
}
label = tempLabel;
mitkIndex = tempIndex;
return;
}
// hit next point without finding brain matter
currentRetractionIndex = currentRetractionIndex + retractionStepIndexSize;
if( ( currentRetractionIndex < 1 ) || ( (unsigned int)currentRetractionIndex > ( singleTract->Size() - 2 ) ) )
{
keepRetracting = false;
}
}
}
}
void mitk::ConnectomicsNetworkCreator::CalculateCenterOfMass()
{
const int dimensions = 3;
int max = m_Segmentation->GetStatistics()->GetScalarValueMax();
int min = m_Segmentation->GetStatistics()->GetScalarValueMin();
int range = max - min +1;
// each label owns a vector of coordinates
std::vector< std::vector< std::vector< double> > > coordinatesPerLabelVector;
coordinatesPerLabelVector.resize( range );
itk::ImageRegionIteratorWithIndex<ITKImageType> it_itkImage( m_SegmentationItk, m_SegmentationItk->GetLargestPossibleRegion() );
for( it_itkImage.GoToBegin(); !it_itkImage.IsAtEnd(); ++it_itkImage )
{
std::vector< double > coordinates;
coordinates.resize(dimensions);
itk::Index< dimensions > index = it_itkImage.GetIndex();
for( int loop(0); loop < dimensions; loop++)
{
coordinates.at( loop ) = index.GetElement( loop );
}
// add the coordinates to the corresponding label vector
coordinatesPerLabelVector.at( it_itkImage.Value() - min ).push_back( coordinates );
}
for(int currentIndex(0), currentLabel( min ); currentIndex < range; currentIndex++, currentLabel++ )
{
std::vector< double > currentCoordinates;
currentCoordinates.resize(dimensions);
int numberOfPoints = coordinatesPerLabelVector.at( currentIndex ).size();
std::vector< double > sumCoords;
sumCoords.resize( dimensions );
for( int loop(0); loop < numberOfPoints; loop++ )
{
for( int loopDimension( 0 ); loopDimension < dimensions; loopDimension++ )
{
sumCoords.at( loopDimension ) += coordinatesPerLabelVector.at( currentIndex ).at( loop ).at( loopDimension );
}
}
for( int loopDimension( 0 ); loopDimension < dimensions; loopDimension++ )
{
currentCoordinates.at( loopDimension ) = sumCoords.at( loopDimension ) / numberOfPoints;
}
m_LabelsToCoordinatesMap.insert( std::pair< int, std::vector<double> >( currentLabel, currentCoordinates ) );
}
//can now use center of mass coordinates
m_UseCoMCoordinates = true;
}
std::vector< double > mitk::ConnectomicsNetworkCreator::GetCenterOfMass( int label )
{
// if label is not known, warn
if( ! ( m_LabelsToCoordinatesMap.count( label ) > 0 ) )
{
MITK_ERROR << "Label " << label << " not found. Could not return coordinates.";
std::vector< double > nullVector;
nullVector.resize(3);
return nullVector;
}
//return associated coordinates
return m_LabelsToCoordinatesMap.find( label )->second;
}
void mitk::ConnectomicsNetworkCreator::CreateNewNode( int label, itk::Index<3> index, bool useCoM )
{
// Only create node if it does not exist yet
if( ! ( m_LabelToNodePropertyMap.count( label ) > 0 ) )
{
NetworkNode newNode;
newNode.coordinates.resize( 3 );
if( !useCoM )
{
for( unsigned int loop = 0; loop < newNode.coordinates.size() ; loop++ )
{
newNode.coordinates[ loop ] = index[ loop ] ;
}
}
else
{
std::vector<double> labelCoords = GetCenterOfMass( label );
for( unsigned int loop = 0; loop < newNode.coordinates.size() ; loop++ )
{
newNode.coordinates[ loop ] = labelCoords.at( loop ) ;
}
}
newNode.label = LabelToString( label );
m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( label, newNode ) );
}
}
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
index 8a956f4c8b..4856ee80f1 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
@@ -1,249 +1,249 @@
/*===================================================================
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 mitkConnectomicsNetworkCreator_h
#define mitkConnectomicsNetworkCreator_h
#include <itkObject.h>
#include <itkObjectFactory.h>
#include <itkMacro.h>
#include "mitkCommon.h"
#include "mitkImage.h"
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
#include "mitkConnectomicsNetwork.h"
#include <MitkConnectomicsExports.h>
namespace mitk
{
/**
* \brief Creates connectomics networks from fibers and parcellation
*
* This class needs a parcellation image and a fiber image to be set. Then you can create
* a connectomics network from the two, using different strategies.
*/
class MitkConnectomics_EXPORT ConnectomicsNetworkCreator : public itk::Object
{
public:
/** Enum for different ways to create the mapping from fibers to network */
enum MappingStrategy
{
EndElementPosition,
EndElementPositionAvoidingWhiteMatter,
JustEndPointVerticesNoLabel,
PrecomputeAndDistance
};
/** Standard class typedefs. */
/** Method for creation through the object factory. */
mitkClassMacro(ConnectomicsNetworkCreator, itk::Object);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Type for Images **/
typedef itk::Image<int, 3 > ITKImageType;
/** Types for the standardized Tract **/
typedef itk::Point<float,3> PointType;
typedef itk::VectorContainer<unsigned int, PointType> TractType;
typedef itk::VectorContainer< unsigned int, TractType::Pointer > TractContainerType; //init via smartpointer
/** Types for Network **/
typedef mitk::ConnectomicsNetwork::VertexDescriptorType VertexType;
typedef mitk::ConnectomicsNetwork::EdgeDescriptorType EdgeType;
typedef mitk::ConnectomicsNetwork::NetworkNode NetworkNode;
typedef std::pair< VertexType, VertexType > ConnectionType;
/** Types for labels **/
typedef int ImageLabelType;
typedef std::pair< ImageLabelType, ImageLabelType > ImageLabelPairType;
/** Given a fiber bundle and a parcellation are set, this will create a network from both */
void CreateNetworkFromFibersAndSegmentation();
- void SetFiberBundle(mitk::FiberBundleX::Pointer fiberBundle);
+ void SetFiberBundle(mitk::FiberBundle::Pointer fiberBundle);
void SetSegmentation(mitk::Image::Pointer segmentation);
mitk::ConnectomicsNetwork::Pointer GetNetwork();
itkSetMacro(MappingStrategy, MappingStrategy);
itkSetMacro(EndPointSearchRadius, double);
itkSetMacro(ZeroLabelInvalid, bool);
/** \brief Calculate the locations of vertices
*
* Calculate the center of mass for each label and store the information. This will need a set parcellation image.
* Unless this function is called the first location where a label is encountered will be used. After calling this function
* the center of mass will be used instead.
*/
void CalculateCenterOfMass();
protected:
//////////////////// Functions ///////////////////////
ConnectomicsNetworkCreator();
- ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundleX::Pointer fiberBundle );
+ ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundle::Pointer fiberBundle );
~ConnectomicsNetworkCreator();
/** Add a connection to the network */
void AddConnectionToNetwork(ConnectionType newConnection);
/** Determine if a label is already identified with a vertex, otherwise create a new one */
VertexType ReturnAssociatedVertexForLabel( ImageLabelType label );
/** Return the vertexes associated with a pair of labels */
ConnectionType ReturnAssociatedVertexPairForLabelPair( ImageLabelPairType labelpair );
/** Return the pair of labels which identify the areas connected by a single fiber */
ImageLabelPairType ReturnLabelForFiberTract( TractType::Pointer singleTract, MappingStrategy strategy );
/** Assign the additional information which should be part of the vertex */
void SupplyVertexWithInformation( ImageLabelType& label, VertexType& vertex );
/** Create a string from the label */
std::string LabelToString( ImageLabelType& label );
/** Check whether the label in question belongs to white matter according to the freesurfer table */
bool IsNonWhiteMatterLabel( int labelInQuestion );
/** Check whether the label in question belongs to background according to the freesurfer table */
bool IsBackgroundLabel( int labelInQuestion );
/** Extend a straight line through the given points and look for the first non white matter label
It will try extend in the direction of the points in the vector so a vector {B,C} will result in
extending from C in the direction C-B */
void LinearExtensionUntilGreyMatter( std::vector<int> & indexVectorOfPointsToUse, TractType::Pointer singleTract,
int & label, itk::Index<3> & mitkIndex );
/** Retract fiber until the first brain matter label is hit
The bool parameter controls whether the front or the end is retracted */
void RetractionUntilBrainMatter( bool retractFront, TractType::Pointer singleTract,
int & label, itk::Index<3> & mitkIndex );
/** \brief Get the location of the center of mass for a specific label
* This can throw an exception if the label is not found.
*/
std::vector< double > GetCenterOfMass( int label );
/** Convert point to itk point */
itk::Point<float, 3> GetItkPoint(double point[3]);
/** \brief Creates a new node
*
* A new node will be created, using the label and either the supplied coordinates
* or the center of mass coordinates, depending on the supplied bool.
*/
void CreateNewNode( int label, itk::Index<3>, bool useIndex );
///////// Mapping strategies //////////
/** Use the position of the end and starting element only to map to labels
Map a fiber to a vertex by taking the value of the parcellation image at the same world coordinates as the last
and first element of the tract.*/
ImageLabelPairType EndElementPositionLabel( TractType::Pointer singleTract );
/** Map by distance between elements and vertices depending on their volume
First go through the parcellation and compute the coordinates of the future vertices. Assign a radius according on their volume.
Then map an edge to a label by considering the nearest vertices and comparing the distance to them to their radii. */
ImageLabelPairType PrecomputeVertexLocationsBySegmentation( TractType::Pointer singleTract );
/** Use the position of the end and starting element only to map to labels
Just take first and last position, no labelling, nothing */
ImageLabelPairType JustEndPointVerticesNoLabelTest( TractType::Pointer singleTract );
/** Use the position of the end and starting element unless it is in white matter, then search for nearby parcellation to map to labels
Map a fiber to a vertex by taking the value of the parcellation image at the same world coordinates as the last
and first element of the tract. If this happens to be white matter, then try to extend the fiber in a line and
take the first non-white matter parcel, that is intersected. */
ImageLabelPairType EndElementPositionLabelAvoidingWhiteMatter( TractType::Pointer singleTract );
///////// Conversions //////////
/** Convert fiber index to segmentation index coordinates */
void FiberToSegmentationCoords( mitk::Point3D& fiberCoord, mitk::Point3D& segCoord );
/** Convert segmentation index to fiber index coordinates */
void SegmentationToFiberCoords( mitk::Point3D& segCoord, mitk::Point3D& fiberCoord );
/////////////////////// Variables ////////////////////////
- mitk::FiberBundleX::Pointer m_FiberBundle;
+ mitk::FiberBundle::Pointer m_FiberBundle;
mitk::Image::Pointer m_Segmentation;
ITKImageType::Pointer m_SegmentationItk;
// the graph itself
mitk::ConnectomicsNetwork::Pointer m_ConNetwork;
// the id counter
int idCounter;
// the map mapping labels to vertices
std::map< ImageLabelType, VertexType > m_LabelToVertexMap;
// mapping labels to additional information
std::map< ImageLabelType, NetworkNode > m_LabelToNodePropertyMap;
// toggles whether edges between a node and itself can exist
bool allowLoops;
// toggles whether to use the center of mass coordinates
bool m_UseCoMCoordinates;
// stores the coordinates of labels
std::map< int, std::vector< double> > m_LabelsToCoordinatesMap;
// the straty to use for mapping
MappingStrategy m_MappingStrategy;
// search radius for finding a non white matter/background area. Should be in mm
double m_EndPointSearchRadius;
// toggles whether a node with the label 0 may be present
bool m_ZeroLabelInvalid;
// used internally to communicate a connection should not be added if the a problem
// is encountered while adding it
bool m_AbortConnection;
//////////////////////// IDs ////////////////////////////
// These IDs are the freesurfer ids used in parcellation
static const int freesurfer_Left_Cerebral_White_Matter = 2;
static const int freesurfer_Left_Cerebellum_White_Matter = 7;
static const int freesurfer_Left_Cerebellum_Cortex = 8;
static const int freesurfer_Brain_Stem = 16;
static const int freesurfer_Right_Cerebral_White_Matter = 41;
static const int freesurfer_Right_Cerebellum_White_Matter = 46;
static const int freesurfer_Right_Cerebellum_Cortex = 47;
};
}// end namespace mitk
#endif // _mitkConnectomicsNetworkCreator_H_INCLUDED
diff --git a/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp b/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp
index 010261f01e..1af41ca778 100644
--- a/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp
@@ -1,113 +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.
===================================================================*/
// Testing
#include "mitkTestingMacros.h"
#include "mitkTestFixture.h"
// std includes
#include <string>
// MITK includes
#include "mitkConnectomicsNetworkCreator.h"
#include "mitkIOUtil.h"
// VTK includes
#include <vtkDebugLeaks.h>
class mitkConnectomicsNetworkCreationTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkConnectomicsNetworkCreationTestSuite);
/// \todo Fix VTK memory leaks. Bug 18097.
vtkDebugLeaks::SetExitError(0);
MITK_TEST(CreateNetworkFromFibersAndParcellation);
CPPUNIT_TEST_SUITE_END();
private:
std::string m_ParcellationPath;
std::string m_FiberPath;
std::string m_ReferenceNetworkPath;
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()
{
m_ReferenceNetworkPath = GetTestDataFilePath("DiffusionImaging/Connectomics/reference.cnf");
m_ParcellationPath = GetTestDataFilePath("DiffusionImaging/Connectomics/parcellation.nrrd");
m_FiberPath = GetTestDataFilePath("DiffusionImaging/Connectomics/fiberBundle.fib");
}
void tearDown()
{
m_ReferenceNetworkPath = "";
m_ParcellationPath = "";
m_FiberPath = "";
}
void CreateNetworkFromFibersAndParcellation()
{
// load fiber image
std::vector<mitk::BaseData::Pointer> fiberInfile = mitk::IOUtil::Load( m_FiberPath );
if( fiberInfile.empty() )
{
std::string errorMessage = "Fiber Image at " + m_FiberPath + " could not be read. Aborting.";
CPPUNIT_ASSERT_MESSAGE( errorMessage, false );
}
mitk::BaseData* fiberBaseData = fiberInfile.at(0);
- mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( fiberBaseData );
+ mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( fiberBaseData );
// load parcellation
std::vector<mitk::BaseData::Pointer> parcellationInFile = mitk::IOUtil::Load( m_ParcellationPath );
if( parcellationInFile.empty() )
{
std::string errorMessage = "Parcellation at " + m_ParcellationPath + " could not be read. Aborting.";
CPPUNIT_ASSERT_MESSAGE( errorMessage, false );
}
mitk::BaseData* parcellationBaseData = parcellationInFile.at(0);
mitk::Image* parcellationImage = dynamic_cast<mitk::Image*>( parcellationBaseData );
// do creation
mitk::ConnectomicsNetworkCreator::Pointer connectomicsNetworkCreator = mitk::ConnectomicsNetworkCreator::New();
connectomicsNetworkCreator->SetSegmentation( parcellationImage );
connectomicsNetworkCreator->SetFiberBundle( fiberBundle );
connectomicsNetworkCreator->CalculateCenterOfMass();
connectomicsNetworkCreator->SetEndPointSearchRadius( 15 );
connectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
// load network
std::vector<mitk::BaseData::Pointer> referenceFile = mitk::IOUtil::Load( m_ReferenceNetworkPath );
if( referenceFile.empty() )
{
std::string errorMessage = "Reference Network at " + m_ReferenceNetworkPath + " could not be read. Aborting.";
CPPUNIT_ASSERT_MESSAGE( errorMessage, false );
}
mitk::BaseData* referenceBaseData = referenceFile.at(0);
mitk::ConnectomicsNetwork* referenceNetwork = dynamic_cast<mitk::ConnectomicsNetwork*>( referenceBaseData );
mitk::ConnectomicsNetwork::Pointer network = connectomicsNetworkCreator->GetNetwork();
CPPUNIT_ASSERT_MESSAGE( "Comparing created and reference network.", mitk::Equal( network.GetPointer(), referenceNetwork, mitk::eps, true) );
}
};
MITK_TEST_SUITE_REGISTRATION(mitkConnectomicsNetworkCreation)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
index c619d12ab4..0641de02ce 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
@@ -1,102 +1,102 @@
/*===================================================================
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 __itkDiffusionTensorPrincipalDirectionImageFilter_h_
#define __itkDiffusionTensorPrincipalDirectionImageFilter_h_
#include <MitkDiffusionCoreExports.h>
#include <itkImageToImageFilter.h>
#include <vnl/vnl_vector_fixed.h>
#include <vnl/vnl_matrix.h>
#include <vnl/algo/vnl_svd.h>
#include <itkVectorContainer.h>
#include <itkVectorImage.h>
#include <itkDiffusionTensor3D.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
namespace itk{
/** \brief Extracts principal eigenvectors of the input tensors
*/
template< class TTensorPixelType, class TPDPixelType=float>
class DiffusionTensorPrincipalDirectionImageFilter :
public ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > >
{
public:
typedef DiffusionTensorPrincipalDirectionImageFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > >
Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(DiffusionTensorPrincipalDirectionImageFilter, ImageToImageFilter)
typedef TTensorPixelType TensorComponentType;
typedef TPDPixelType DirectionPixelType;
typedef typename Superclass::InputImageType InputImageType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef vnl_vector_fixed< double, 3 > DirectionType;
void SetImage( const InputImageType *image );
// input
itkSetMacro( MaskImage, ItkUcharImgType::Pointer)
itkSetMacro( NormalizeVectors, bool)
// output
- itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)
+ itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)
protected:
DiffusionTensorPrincipalDirectionImageFilter();
~DiffusionTensorPrincipalDirectionImageFilter() {}
void PrintSelf(std::ostream& os, Indent indent) const;
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType );
void AfterThreadedGenerateData();
private:
bool m_NormalizeVectors; ///< Normalizes the output vector to length 1
- mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< Vector field representation of the output vectors
+ mitk::FiberBundle::Pointer m_OutputFiberBundle; ///< Vector field representation of the output vectors
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< Image containing the number of fiber directions per voxel
ItkUcharImgType::Pointer m_MaskImage; ///< Extraction is only performed inside of the binary mask
float m_MaxEigenvalue;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDiffusionTensorPrincipalDirectionImageFilter.txx"
#endif
#endif //__itkDiffusionTensorPrincipalDirectionImageFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
index ff06a24936..e7abe7c63a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
@@ -1,235 +1,235 @@
/*===================================================================
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 __itkDiffusionTensorPrincipalDirectionImageFilter_txx
#define __itkDiffusionTensorPrincipalDirectionImageFilter_txx
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkDiffusionTensorPrincipalDirectionImageFilter.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkImageRegionIterator.h"
#include "itkArray.h"
#include "vnl/vnl_vector.h"
#include <boost/progress.hpp>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#define _USE_MATH_DEFINES
#include <math.h>
namespace itk {
//#define QBALL_RECON_PI M_PI
template< class TTensorPixelType, class TPDPixelType>
DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::DiffusionTensorPrincipalDirectionImageFilter()
: m_NormalizeVectors(true)
, m_MaxEigenvalue(0.0)
{
this->SetNumberOfRequiredInputs( 1 );
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::BeforeThreadedGenerateData()
{
typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
Vector<double,3> spacing = inputImagePointer->GetSpacing();
mitk::Point3D origin = inputImagePointer->GetOrigin();
itk::Matrix<double, 3, 3> direction = inputImagePointer->GetDirection();
ImageRegion<3> imageRegion = inputImagePointer->GetLargestPossibleRegion();
if (m_MaskImage.IsNull())
{
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
itk::Vector< TPDPixelType, 3 > nullVec; nullVec.Fill(0.0);
typename OutputImageType::Pointer outputImage = OutputImageType::New();
outputImage->SetSpacing( spacing );
outputImage->SetOrigin( origin );
outputImage->SetDirection( direction );
outputImage->SetRegions( imageRegion );
outputImage->Allocate();
outputImage->FillBuffer(nullVec);
this->SetNthOutput(0, outputImage);
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::AfterThreadedGenerateData()
{
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
typename OutputImageType::Pointer directionImage = static_cast< OutputImageType* >( this->ProcessObject::GetPrimaryOutput() );
ImageRegionConstIterator< OutputImageType > it(directionImage, directionImage->GetLargestPossibleRegion() );
mitk::Vector3D spacing = directionImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
while( !it.IsAtEnd() )
{
typename OutputImageType::IndexType index = it.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++it;
continue;
}
itk::Vector< float, 3 > pixel = directionImage->GetPixel(index);
DirectionType dir; dir[0] = pixel[0]; dir[1] = pixel[1]; dir[2] = pixel[2];
if (!m_NormalizeVectors && m_MaxEigenvalue>0)
dir /= m_MaxEigenvalue;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
directionImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
++it;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
- m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+ m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType )
{
typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
ImageRegionIterator< OutputImageType > outIt(outputImage, outputRegionForThread);
InputIteratorType inIt(inputImagePointer, outputRegionForThread );
ImageRegionIterator< ItkUcharImgType > nIt(m_NumDirectionsImage, outputRegionForThread );
while( !inIt.IsAtEnd() )
{
typename InputImageType::IndexType index = inIt.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++inIt;
++nIt;
++outIt;
continue;
}
typename InputImageType::PixelType b = inIt.Get();
TensorType tensor = b.GetDataPointer();
typename OutputImageType::PixelType dir;
typename TensorType::EigenValuesArrayType eigenvalues;
typename TensorType::EigenVectorsMatrixType eigenvectors;
if(tensor.GetTrace()!=0)
{
tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
vnl_vector_fixed<double,3> vec;
vec[0] = eigenvectors(2,0);
vec[1] = eigenvectors(2,1);
vec[2] = eigenvectors(2,2);
if (!m_NormalizeVectors)
vec *= eigenvalues[2];
if (eigenvalues[2]>m_MaxEigenvalue)
m_MaxEigenvalue = eigenvalues[2];
dir[0] = (TPDPixelType)vec[0];
dir[1] = (TPDPixelType)vec[1];
dir[2] = (TPDPixelType)vec[2];
outIt.Set( dir );
m_NumDirectionsImage->SetPixel(index, 1);
}
++outIt;
++inIt;
++nIt;
}
std::cout << "One Thread finished extraction" << std::endl;
}
template< class TTensorPixelType,
class TPDPixelType>
void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
TPDPixelType>
::PrintSelf(std::ostream& os, Indent indent) const
{
}
}
#endif // __itkDiffusionQballPrincipleDirectionsImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
index 65e1842d1e..82ec7eb936 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
@@ -1,388 +1,388 @@
/*===================================================================
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 __itkDwiPhantomGenerationFilter_cpp
#define __itkDwiPhantomGenerationFilter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkDwiPhantomGenerationFilter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <itkOrientationDistributionFunction.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <boost/progress.hpp>
namespace itk {
//#define QBALL_RECON_PI 3.14159265358979323846
template< class TOutputScalarType >
DwiPhantomGenerationFilter< TOutputScalarType >
::DwiPhantomGenerationFilter()
: m_BValue(1000)
, m_SignalScale(1000)
, m_BaselineImages(0)
, m_MaxBaseline(0)
, m_MeanBaseline(0)
, m_NoiseVariance(0.004)
, m_GreyMatterAdc(0.01)
, m_SimulateBaseline(true)
, m_DefaultBaseline(1000)
{
this->SetNumberOfRequiredOutputs (1);
m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
m_DirectionMatrix.SetIdentity();
m_ImageRegion.SetSize(0, 10);
m_ImageRegion.SetSize(1, 10);
m_ImageRegion.SetSize(2, 10);
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing ); // Set the image spacing
outImage->SetOrigin( m_Origin ); // Set the image origin
outImage->SetDirection( m_DirectionMatrix ); // Set the image direction
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->SetVectorLength(QBALL_ODFSIZE);
outImage->Allocate();
// ITKv4 migration fix : removing OutputImageType::PixelType(0.0)
// the conversion is handled internally by the itk::Image
typename OutputImageType::PixelType fillValue(0.0);
outImage->FillBuffer( fillValue );
this->SetNthOutput (0, outImage);
}
template< class TOutputScalarType >
void DwiPhantomGenerationFilter< TOutputScalarType >
::GenerateTensors()
{
MITK_INFO << "Generating tensors";
for (int i=0; i<m_SignalRegions.size(); i++)
{
float ADC = m_TensorADC.at(i);
float FA = m_TensorFA.at(i);
itk::DiffusionTensor3D<float> kernel;
kernel.Fill(0);
float e1=ADC*(1+2*FA/sqrt(3-2*FA*FA));
float e2=ADC*(1-FA/sqrt(3-2*FA*FA));
float e3=e2;
kernel.SetElement(0,e1);
kernel.SetElement(3,e2);
kernel.SetElement(5,e3);
if (m_SimulateBaseline)
{
double l2 = GetTensorL2Norm(kernel);
if (l2>m_MaxBaseline)
m_MaxBaseline = l2;
}
MITK_INFO << "Kernel FA: " << kernel.GetFractionalAnisotropy();
vnl_vector_fixed<double, 3> kernelDir; kernelDir[0]=1; kernelDir[1]=0; kernelDir[2]=0;
itk::DiffusionTensor3D<float> tensor;
vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
MITK_INFO << "Tensor direction: " << dir;
dir.normalize();
vnl_vector_fixed<double, 3> axis = vnl_cross_3d(kernelDir, dir); axis.normalize();
vnl_quaternion<double> rotation(axis, acos(dot_product(kernelDir, dir)));
rotation.normalize();
vnl_matrix_fixed<double, 3, 3> matrix = rotation.rotation_matrix_transpose();
vnl_matrix_fixed<double, 3, 3> tensorMatrix;
tensorMatrix[0][0] = kernel[0]; tensorMatrix[0][1] = kernel[1]; tensorMatrix[0][2] = kernel[2];
tensorMatrix[1][0] = kernel[1]; tensorMatrix[1][1] = kernel[3]; tensorMatrix[1][2] = kernel[4];
tensorMatrix[2][0] = kernel[2]; tensorMatrix[2][1] = kernel[4]; tensorMatrix[2][2] = kernel[5];
tensorMatrix = matrix.transpose()*tensorMatrix*matrix;
tensor[0] = tensorMatrix[0][0]; tensor[1] = tensorMatrix[0][1]; tensor[2] = tensorMatrix[0][2];
tensor[3] = tensorMatrix[1][1]; tensor[4] = tensorMatrix[1][2]; tensor[5] = tensorMatrix[2][2];
m_TensorList.push_back(tensor);
}
}
template< class TOutputScalarType >
void DwiPhantomGenerationFilter< TOutputScalarType >::AddNoise(typename OutputImageType::PixelType& pix)
{
for( unsigned int i=0; i<m_GradientList.size(); i++)
{
float signal = pix[i];
float val = sqrt(pow(signal + m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance), 2) + pow(m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance),2));
pix[i] += val;
}
}
template< class TOutputScalarType >
typename DwiPhantomGenerationFilter< TOutputScalarType >::OutputImageType::PixelType
DwiPhantomGenerationFilter< TOutputScalarType >::SimulateMeasurement(itk::DiffusionTensor3D<float>& T, float weight)
{
typename OutputImageType::PixelType out;
out.SetSize(m_GradientList.size());
out.Fill(0);
TOutputScalarType s0 = m_DefaultBaseline;
if (m_SimulateBaseline)
s0 = (GetTensorL2Norm(T)/m_MaxBaseline)*m_SignalScale;
for( unsigned int i=0; i<m_GradientList.size(); i++)
{
GradientType g = m_GradientList[i];
if (g.GetNorm()>0.0001)
{
itk::DiffusionTensor3D<float> S;
S[0] = g[0]*g[0];
S[1] = g[1]*g[0];
S[2] = g[2]*g[0];
S[3] = g[1]*g[1];
S[4] = g[2]*g[1];
S[5] = g[2]*g[2];
double D = T[0]*S[0] + T[1]*S[1] + T[2]*S[2] +
T[1]*S[1] + T[3]*S[3] + T[4]*S[4] +
T[2]*S[2] + T[4]*S[4] + T[5]*S[5];
// check for corrupted tensor and generate signal
if (D>=0)
{
D = weight*s0*exp ( -m_BValue * D );
out[i] = static_cast<TOutputScalarType>( D );
}
}
else
out[i] = s0;
}
return out;
}
template< class TOutputScalarType >
void DwiPhantomGenerationFilter< TOutputScalarType >
::GenerateData()
{
if (m_NoiseVariance < 0)
m_NoiseVariance = 0.001;
if (!m_SimulateBaseline)
{
MITK_INFO << "Baseline image values are set to default. Noise variance value is treated as SNR!";
if (m_NoiseVariance <= 0)
m_NoiseVariance = 0.0001;
if (m_NoiseVariance>99)
m_NoiseVariance = 0;
else
{
m_NoiseVariance = m_DefaultBaseline/(m_NoiseVariance*m_SignalScale);
m_NoiseVariance *= m_NoiseVariance;
}
}
m_RandGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
m_RandGen->SetSeed();
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing );
outImage->SetOrigin( m_Origin );
outImage->SetDirection( m_DirectionMatrix );
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->SetVectorLength(m_GradientList.size());
outImage->Allocate();
typename OutputImageType::PixelType pix;
pix.SetSize(m_GradientList.size());
pix.Fill(0.0);
outImage->FillBuffer(pix);
this->SetNthOutput (0, outImage);
double minSpacing = m_Spacing[0];
if (m_Spacing[1]<minSpacing)
minSpacing = m_Spacing[1];
if (m_Spacing[2]<minSpacing)
minSpacing = m_Spacing[2];
m_DirectionImageContainer = ItkDirectionImageContainer::New();
for (int i=0; i<m_SignalRegions.size(); i++)
{
itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
ItkDirectionImage::Pointer img = ItkDirectionImage::New();
img->SetSpacing( m_Spacing );
img->SetOrigin( m_Origin );
img->SetDirection( m_DirectionMatrix );
img->SetRegions( m_ImageRegion );
img->Allocate();
img->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
}
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( m_Spacing );
m_NumDirectionsImage->SetOrigin( m_Origin );
m_NumDirectionsImage->SetDirection( m_DirectionMatrix );
m_NumDirectionsImage->SetRegions( m_ImageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
m_SNRImage = ItkFloatImgType::New();
m_SNRImage->SetSpacing( m_Spacing );
m_SNRImage->SetOrigin( m_Origin );
m_SNRImage->SetDirection( m_DirectionMatrix );
m_SNRImage->SetRegions( m_ImageRegion );
m_SNRImage->Allocate();
m_SNRImage->FillBuffer(0);
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
m_BaselineImages = 0;
for( unsigned int i=0; i<m_GradientList.size(); i++)
if (m_GradientList[i].GetNorm()<=0.0001)
m_BaselineImages++;
typedef ImageRegionIterator<OutputImageType> IteratorOutputType;
IteratorOutputType it (outImage, m_ImageRegion);
// isotropic tensor
itk::DiffusionTensor3D<float> isoTensor;
isoTensor.Fill(0);
float e1 = m_GreyMatterAdc;
float e2 = m_GreyMatterAdc;
float e3 = m_GreyMatterAdc;
isoTensor.SetElement(0,e1);
isoTensor.SetElement(3,e2);
isoTensor.SetElement(5,e3);
m_MaxBaseline = GetTensorL2Norm(isoTensor);
GenerateTensors();
// simulate measurement
m_MeanBaseline = 0;
double noiseStdev = sqrt(m_NoiseVariance);
while(!it.IsAtEnd())
{
pix = it.Get();
typename OutputImageType::IndexType index = it.GetIndex();
int numDirs = 0;
for (int i=0; i<m_SignalRegions.size(); i++)
{
ItkUcharImgType::Pointer region = m_SignalRegions.at(i);
if (region->GetPixel(index)!=0)
{
numDirs++;
pix += SimulateMeasurement(m_TensorList[i], m_TensorWeight[i]);
// set direction image pixel
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
itk::Vector< float, 3 > pixel = img->GetPixel(index);
vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
dir.normalize();
dir *= m_TensorWeight.at(i);
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
img->SetPixel(index, pixel);
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
outImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
}
if (numDirs>1)
{
for (int i=0; i<m_GradientList.size(); i++)
pix[i] /= numDirs;
}
else if (numDirs==0)
{
if (m_SimulateBaseline)
pix = SimulateMeasurement(isoTensor, 1.0);
else
pix.Fill(0.0);
}
m_MeanBaseline += pix[0];
it.Set(pix);
m_NumDirectionsImage->SetPixel(index, numDirs);
if (m_NoiseVariance>0)
m_SNRImage->SetPixel(index, pix[0]/(noiseStdev*m_SignalScale));
++it;
}
m_MeanBaseline /= m_ImageRegion.GetNumberOfPixels();
if (m_NoiseVariance>0)
MITK_INFO << "Mean SNR: " << m_MeanBaseline/(noiseStdev*m_SignalScale);
else
MITK_INFO << "No noise added";
// add rician noise
it.GoToBegin();
while(!it.IsAtEnd())
{
pix = it.Get();
AddNoise(pix);
it.Set(pix);
++it;
}
// generate fiber bundle
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
- m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+ m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
}
template< class TOutputScalarType >
double DwiPhantomGenerationFilter< TOutputScalarType >::GetTensorL2Norm(itk::DiffusionTensor3D<float>& T)
{
return sqrt(T[0]*T[0] + T[3]*T[3] + T[5]*T[5] + T[1]*T[2]*2.0 + T[2]*T[4]*2.0 + T[1]*T[4]*2.0);
}
}
#endif // __itkDwiPhantomGenerationFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
index ced3a05ce8..67788a323a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
@@ -1,152 +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.
===================================================================*/
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-27 17:01:06 $
Version: $Revision: 1.12 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkDwiPhantomGenerationFilter_h_
#define __itkDwiPhantomGenerationFilter_h_
#include <itkImageSource.h>
#include <itkVectorImage.h>
#include <itkDiffusionTensor3D.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
namespace itk{
/**
* \brief Generation of synthetic diffusion weighted images using a second rank tensor model. */
template< class TOutputScalarType >
class DwiPhantomGenerationFilter : public ImageSource< itk::VectorImage<TOutputScalarType,3> >
{
public:
typedef DwiPhantomGenerationFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageSource< itk::VectorImage<TOutputScalarType,3> > Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(DwiPhantomGenerationFilter, ImageSource)
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef itk::VectorContainer< int, double > AnglesContainerType;
typedef Vector<double,3> GradientType;
typedef std::vector<GradientType> GradientListType;
typedef itk::Matrix<double, 3, 3> MatrixType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image<float, 3> ItkFloatImgType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImage;
typedef VectorContainer< unsigned int, ItkDirectionImage::Pointer > ItkDirectionImageContainer;
void SetGradientList(GradientListType gradientList){m_GradientList = gradientList;}
void SetSignalRegions(std::vector< ItkUcharImgType::Pointer > signalRegions){m_SignalRegions = signalRegions;}
void SetTensorFA(std::vector< float > faList){m_TensorFA = faList;}
void SetTensorADC(std::vector< float > adcList){m_TensorADC = adcList;}
void SetTensorWeight(std::vector< float > weightList){m_TensorWeight = weightList;}
void SetTensorDirection(std::vector< vnl_vector_fixed<double, 3> > directionList){m_TensorDirection = directionList;}
// input parameters
itkSetMacro( BValue, float ) ///< signal parameter
itkSetMacro( SignalScale, float ) ///< scaling factor for signal
itkSetMacro( NoiseVariance, double ) ///< variance of rician noise
itkSetMacro( GreyMatterAdc, float ) ///< ADC of isotropic diffusion tensor
itkSetMacro( Spacing, mitk::Vector3D ) ///< parameter of output image
itkSetMacro( Origin, mitk::Point3D ) ///< parameter of output image
itkSetMacro( DirectionMatrix, MatrixType ) ///< parameter of output image
itkSetMacro( ImageRegion, ImageRegion<3> ) ///< parameter of output image
itkSetMacro( SimulateBaseline, bool ) ///< generate baseline image values as the l2 norm of the corresponding tensor used for the diffusion signal generation
// output
itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer) ///< contains one vectorimage for each input ROI
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< contains number of directions per voxel
itkGetMacro( SNRImage, ItkFloatImgType::Pointer) ///< contains local SNR values
- itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer) ///< output vector field
+ itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer) ///< output vector field
protected:
DwiPhantomGenerationFilter();
~DwiPhantomGenerationFilter(){}
void GenerateData();
private:
// image variables
itk::Vector<double> m_Spacing;
mitk::Point3D m_Origin;
itk::Matrix<double, 3, 3> m_DirectionMatrix;
ImageRegion<3> m_ImageRegion;
ItkDirectionImageContainer::Pointer m_DirectionImageContainer; ///< contains one vectorimage for each input ROI
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< contains number of directions per voxel
ItkFloatImgType::Pointer m_SNRImage; ///< contains local SNR values
- mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< output vector field
+ mitk::FiberBundle::Pointer m_OutputFiberBundle; ///< output vector field
// signal regions
std::vector< ItkUcharImgType::Pointer > m_SignalRegions; ///< binary images defining the regions for the signal generation
std::vector< float > m_TensorFA; ///< kernel tensor parameter
std::vector< float > m_TensorADC; ///< kernel tensor parameter
std::vector< float > m_TensorWeight; ///< weight factor of the signal
std::vector< vnl_vector_fixed<double, 3> > m_TensorDirection; ///< principal direction of the kernel tensor in the different ROIs
// signal related variable
GradientListType m_GradientList; ///< list of used diffusion gradient directions
std::vector< itk::DiffusionTensor3D<float> > m_TensorList; ///< kernel tensor rotated in the different directions
float m_BValue; ///< signal parameter
float m_SignalScale; ///< scaling factor for signal
Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
int m_BaselineImages; ///< number of simulated baseline images
double m_MaxBaseline; ///< maximum value of the baseline image
double m_MeanBaseline; ///< mean value of the baseline image
double m_NoiseVariance; ///< variance of rician noise
float m_GreyMatterAdc; ///< ADC of isotropic diffusion tensor
bool m_SimulateBaseline; ///< generate baseline image values as the l2 norm of the corresponding tensor used for the diffusion signal generation
TOutputScalarType m_DefaultBaseline; ///< default value for baseline image
double GetTensorL2Norm(itk::DiffusionTensor3D<float>& T);
void GenerateTensors(); ///< rotates kernel tensor in the direction of the input direction vectors
typename OutputImageType::PixelType SimulateMeasurement(itk::DiffusionTensor3D<float>& tensor, float weight);
void AddNoise(typename OutputImageType::PixelType& pix); ///< Adds rician noise to the input pixel
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkDwiPhantomGenerationFilter.cpp"
#endif
#endif //__itkDwiPhantomGenerationFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
index 5d6d751d14..b2f8429ad2 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
@@ -1,520 +1,520 @@
/*===================================================================
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 __itkFiniteDiffOdfMaximaExtractionFilter_cpp
#define __itkFiniteDiffOdfMaximaExtractionFilter_cpp
#include "itkFiniteDiffOdfMaximaExtractionFilter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <vnl/vnl_vector.h>
#include <itkOrientationDistributionFunction.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <boost/math/special_functions.hpp>
#include <boost/progress.hpp>
using namespace boost::math;
namespace itk {
static bool CompareVectors(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
{
return (v1.magnitude()>v2.magnitude());
}
template< class PixelType, int ShOrder, int NrOdfDirections >
FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::FiniteDiffOdfMaximaExtractionFilter()
: m_NormalizationMethod(MAX_VEC_NORM)
, m_MaxNumPeaks(2)
, m_PeakThreshold(0.4)
, m_AbsolutePeakThreshold(0)
, m_ClusteringThreshold(0.9)
, m_AngularThreshold(0.7)
, m_NumCoeffs((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder)
, m_Toolkit(FSL)
{
this->SetNumberOfRequiredInputs(1);
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::FindCandidatePeaks(OdfType& odf, double thr, std::vector< DirectionType >& container)
{
double gfa = odf.GetGeneralizedFractionalAnisotropy();
//Find the peaks using a finite difference method
bool flag = true;
vnl_vector_fixed< bool, NrOdfDirections > used; used.fill(false);
//Find the peaks
for (int i=0; i<NrOdfDirections; i++)
{
if (used[i])
continue;
double val = odf.GetElement(i);
if (val>thr && val*gfa>m_AbsolutePeakThreshold) // limit to one hemisphere ???
{
flag = true;
std::vector< int > neighbours = odf.GetNeighbors(i);
for (unsigned int j=0; j<neighbours.size(); j++)
if (val<=odf.GetElement(neighbours.at(j)))
{
flag = false;
break;
}
if (flag) // point is a peak
{
container.push_back(odf.GetDirection(i).normalize());
used[i] = true;
for (unsigned int j=0; j<neighbours.size(); j++)
used[neighbours.at(j)] = true;
}
}
}
}
template< class PixelType, int ShOrder, int NrOdfDirections >
std::vector< vnl_vector_fixed< double, 3 > > FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>::MeanShiftClustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
{
std::vector< DirectionType > outDirs;
if (inDirs.empty())
return inDirs;
DirectionType oldMean, currentMean, workingMean;
std::vector< int > touched;
// initialize
touched.resize(inDirs.size(), 0);
bool free = true;
currentMean = inDirs[0]; // initialize first seed
while (free)
{
oldMean.fill(0.0);
// start mean-shift clustering
float angle = 0.0;
int counter = 0;
while ((currentMean-oldMean).magnitude()>0.0001)
{
counter = 0;
oldMean = currentMean;
workingMean = oldMean;
workingMean.normalize();
currentMean.fill(0.0);
for (unsigned int i=0; i<inDirs.size(); i++)
{
angle = dot_product(workingMean, inDirs[i]);
if (angle>=m_ClusteringThreshold)
{
currentMean += inDirs[i];
touched[i] = 1;
counter++;
}
else if (-angle>=m_ClusteringThreshold)
{
currentMean -= inDirs[i];
touched[i] = 1;
counter++;
}
}
}
// found stable mean
if (counter>0)
{
float mag = currentMean.magnitude();
if (mag>0)
{
currentMean /= mag;
outDirs.push_back(currentMean);
}
}
// find next unused seed
free = false;
for (unsigned int i=0; i<touched.size(); i++)
if (touched[i]==0)
{
currentMean = inDirs[i];
free = true;
}
}
if (inDirs.size()==outDirs.size())
{
return outDirs;
}
else
return MeanShiftClustering(outDirs);
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::BeforeThreadedGenerateData()
{
typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
itk::Vector<double,3> spacing = ShCoeffImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
mitk::Point3D origin = ShCoeffImage->GetOrigin();
itk::Matrix<double, 3, 3> direction = ShCoeffImage->GetDirection();
ImageRegion<3> imageRegion = ShCoeffImage->GetLargestPossibleRegion();
if (m_MaskImage.IsNotNull())
{
origin = m_MaskImage->GetOrigin();
direction = m_MaskImage->GetDirection();
imageRegion = m_MaskImage->GetLargestPossibleRegion();
}
m_DirectionImageContainer = ItkDirectionImageContainer::New();
for (unsigned int i=0; i<m_MaxNumPeaks; i++)
{
itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
ItkDirectionImage::Pointer img = ItkDirectionImage::New();
img->SetSpacing( spacing );
img->SetOrigin( origin );
img->SetDirection( direction );
img->SetRegions( imageRegion );
img->Allocate();
img->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
}
if (m_MaskImage.IsNull())
{
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
this->SetNumberOfIndexedOutputs(m_MaxNumPeaks);
// calculate SH basis
OdfType odf;
vnl_matrix_fixed<double, 3, NrOdfDirections>* directions = odf.GetDirections();
vnl_matrix< double > sphCoords;
std::vector< DirectionType > dirs;
for (int i=0; i<NrOdfDirections; i++)
dirs.push_back(directions->get_column(i));
Cart2Sph(dirs, sphCoords); // convert candidate peaks to spherical angles
m_ShBasis = CalcShBasis(sphCoords); // evaluate spherical harmonics at each peak
MITK_INFO << "Starting finite differences maximum extraction";
MITK_INFO << "ODF sampling points: " << NrOdfDirections;
MITK_INFO << "SH order: " << ShOrder;
MITK_INFO << "Maximum peaks: " << m_MaxNumPeaks;
MITK_INFO << "Relative threshold: " << m_PeakThreshold;
MITK_INFO << "Absolute threshold: " << m_AbsolutePeakThreshold;
MITK_INFO << "Clustering threshold: " << m_ClusteringThreshold;
MITK_INFO << "Angular threshold: " << m_AngularThreshold;
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::AfterThreadedGenerateData()
{
MITK_INFO << "Generating vector field";
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, ShCoeffImage->GetLargestPossibleRegion() );
mitk::Vector3D spacing = ShCoeffImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
int maxProgress = ShCoeffImage->GetLargestPossibleRegion().GetSize()[0]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[1]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[2];
boost::progress_display disp(maxProgress);
while( !cit.IsAtEnd() )
{
++disp;
typename CoefficientImageType::IndexType index = cit.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++cit;
continue;
}
for (unsigned int i=0; i<m_DirectionImageContainer->Size(); i++)
{
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
itk::Vector< float, 3 > pixel = img->GetPixel(index);
DirectionType dir; dir[0] = pixel[0]; dir[1] = pixel[1]; dir[2] = pixel[2];
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
++cit;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
- m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+ m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
for (unsigned int i=0; i<m_DirectionImageContainer->Size(); i++)
{
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
this->SetNthOutput(i, img);
}
}
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, ThreadIdType threadID )
{
typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, outputRegionForThread );
OdfType odf;
while( !cit.IsAtEnd() )
{
typename CoefficientImageType::IndexType index = cit.GetIndex();
if (m_MaskImage->GetPixel(index)==0)
{
++cit;
continue;
}
CoefficientPixelType c = cit.Get();
// calculate ODF
double max = 0;
odf.Fill(0.0);
for (int i=0; i<NrOdfDirections; i++)
{
for (int j=0; j<m_NumCoeffs; j++)
odf[i] += c[j]*m_ShBasis(i,j);
if (odf[i]>max)
max = odf[i];
}
if (max<0.0001)
{
++cit;
continue;
}
std::vector< DirectionType > candidates, peaks, temp;
peaks.clear();
max *= m_PeakThreshold; // relative threshold
FindCandidatePeaks(odf, max, candidates); // find all local maxima
candidates = MeanShiftClustering(candidates); // cluster maxima
vnl_matrix< double > shBasis, sphCoords;
Cart2Sph(candidates, sphCoords); // convert candidate peaks to spherical angles
shBasis = CalcShBasis(sphCoords); // evaluate spherical harmonics at each peak
max = 0.0;
for (unsigned int i=0; i<candidates.size(); i++) // scale peaks according to ODF value
{
double val = 0;
for (int j=0; j<m_NumCoeffs; j++)
val += c[j]*shBasis(i,j);
if (val>max)
max = val;
peaks.push_back(candidates[i]*val);
}
std::sort( peaks.begin(), peaks.end(), CompareVectors ); // sort peaks
// kick out directions to close to a larger direction (too far away to cluster but too close to keep)
unsigned int m = peaks.size();
if ( m>m_DirectionImageContainer->Size() )
m = m_DirectionImageContainer->Size();
for (unsigned int i=0; i<m; i++)
{
DirectionType v1 = peaks.at(i);
double val = v1.magnitude();
if (val<max*m_PeakThreshold || val<m_AbsolutePeakThreshold)
break;
bool flag = true;
for (unsigned int j=0; j<peaks.size(); j++)
if (i!=j)
{
DirectionType v2 = peaks.at(j);
double val2 = v2.magnitude();
double angle = fabs(dot_product(v1,v2)/(val*val2));
if (angle>m_AngularThreshold && val<val2)
{
flag = false;
break;
}
}
if (flag)
temp.push_back(v1);
}
peaks = temp;
// fill output image
unsigned int num = peaks.size();
if ( num>m_DirectionImageContainer->Size() )
num = m_DirectionImageContainer->Size();
for (unsigned int i=0; i<num; i++)
{
vnl_vector<double> dir = peaks.at(i);
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dir.normalize();
break;
case MAX_VEC_NORM:
dir /= max;
break;
}
dir = m_MaskImage->GetDirection()*dir;
itk::Vector< float, 3 > pixel;
pixel.SetElement(0, -dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
img->SetPixel(index, pixel);
}
m_NumDirectionsImage->SetPixel(index, num);
++cit;
}
MITK_INFO << "Thread " << threadID << " finished extraction";
}
// convert cartesian to spherical coordinates
template< class PixelType, int ShOrder, int NrOdfDirections >
void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::Cart2Sph(const std::vector< DirectionType >& dir, vnl_matrix<double>& sphCoords)
{
sphCoords.set_size(dir.size(), 2);
for (unsigned int i=0; i<dir.size(); i++)
{
double mag = dir[i].magnitude();
if( mag<0.0001 )
{
sphCoords(i,0) = M_PI/2; // theta
sphCoords(i,1) = M_PI/2; // phi
}
else
{
sphCoords(i,0) = acos(dir[i](2)/mag); // theta
sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
}
}
}
// generate spherical harmonic values of the desired order for each input direction
template< class PixelType, int ShOrder, int NrOdfDirections >
vnl_matrix<double> FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
::CalcShBasis(vnl_matrix<double>& sphCoords)
{
int M = sphCoords.rows();
int j, m; double mag, plm;
vnl_matrix<double> shBasis;
shBasis.set_size(M, m_NumCoeffs);
for (int p=0; p<M; p++)
{
j=0;
for (int l=0; l<=ShOrder; l=l+2)
for (m=-l; m<=l; m++)
{
switch (m_Toolkit)
{
case FSL:
plm = legendre_p<double>(l,abs(m),cos(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)*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*sphCoords(p,1));
break;
case MRTRIX:
plm = legendre_p<double>(l,abs(m),-cos(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) = mag*cos(m*sphCoords(p,1));
else if (m==0)
shBasis(p,j) = mag;
else
shBasis(p,j) = mag*sin(-m*sphCoords(p,1));
break;
}
j++;
}
}
return shBasis;
}
}
#endif // __itkFiniteDiffOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
index d5b274a4c0..85e715b5e6 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
@@ -1,145 +1,145 @@
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-27 17:01:06 $
Version: $Revision: 1.12 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkFiniteDiffOdfMaximaExtractionFilter_h_
#define __itkFiniteDiffOdfMaximaExtractionFilter_h_
#include "itkImageToImageFilter.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_svd.h"
#include "itkVectorContainer.h"
#include "itkVectorImage.h"
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkOrientationDistributionFunction.h>
namespace itk{
/**
* \brief Extract ODF peaks by searching all local maxima on a densely sampled ODF und clustering these maxima to get the underlying fiber direction.
* NrOdfDirections: number of sampling points on the ODF surface (about 20000 is a good value)
*/
template< class PixelType, int ShOrder, int NrOdfDirections >
class FiniteDiffOdfMaximaExtractionFilter :
public ImageToImageFilter< Image< Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder >, 3 >,
Image< Vector< PixelType, 3 >, 3 > >
{
public:
enum Toolkit { ///< SH coefficient convention (depends on toolkit)
FSL,
MRTRIX
};
enum NormalizationMethods {
NO_NORM, ///< no length normalization of the output peaks
SINGLE_VEC_NORM, ///< normalize the single peaks to length 1
MAX_VEC_NORM ///< normalize all peaks according to their length in comparison to the largest peak (0-1)
};
typedef FiniteDiffOdfMaximaExtractionFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageToImageFilter< Image< Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder >, 3 >,
Image< Vector< PixelType, 3 >, 3 > > Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(FiniteDiffOdfMaximaExtractionFilter, ImageToImageFilter)
typedef typename Superclass::InputImageType CoefficientImageType;
typedef typename CoefficientImageType::RegionType CoefficientImageRegionType;
typedef typename CoefficientImageType::PixelType CoefficientPixelType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef OrientationDistributionFunction<PixelType, NrOdfDirections> OdfType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef vnl_vector_fixed< double, 3 > DirectionType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImage;
typedef VectorContainer< unsigned int, ItkDirectionImage::Pointer > ItkDirectionImageContainer;
// input
itkSetMacro( MaxNumPeaks, unsigned int) ///< maximum number of peaks per voxel. if more peaks are detected, only the largest are kept.
itkSetMacro( PeakThreshold, double) ///< threshold on the peak length relative to the largest peak inside the current voxel
itkSetMacro( AbsolutePeakThreshold, double) ///< hard threshold on the peak length of all local maxima
itkSetMacro( ClusteringThreshold, double) ///< directions closer together than the specified angular threshold will be clustered (in rad)
itkSetMacro( AngularThreshold, double) ///< directions closer together than the specified threshold that remain after clustering are discarded (largest is kept) (in rad)
itkSetMacro( MaskImage, ItkUcharImgType::Pointer) ///< only voxels inside the binary mask are processed
itkSetMacro( NormalizationMethod, NormalizationMethods) ///< normalization method of ODF peaks
// output
- itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
+ itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer) ///< container for output peaks
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< number of peaks per voxel
itkSetMacro( Toolkit, Toolkit) ///< define SH coefficient convention (depends on toolkit)
itkGetMacro( Toolkit, Toolkit) ///< SH coefficient convention (depends on toolkit)
protected:
FiniteDiffOdfMaximaExtractionFilter();
~FiniteDiffOdfMaximaExtractionFilter(){}
void BeforeThreadedGenerateData();
void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadID );
void AfterThreadedGenerateData();
/** Extract all local maxima from the densely sampled ODF surface. Thresholding possible. **/
void FindCandidatePeaks(OdfType& odf, double odfMax, std::vector< DirectionType >& inDirs);
/** Cluster input directions within a certain angular threshold **/
std::vector< DirectionType > MeanShiftClustering(std::vector< DirectionType >& inDirs);
/** Convert cartesian to spherical coordinates **/
void Cart2Sph(const std::vector< DirectionType >& dir, vnl_matrix<double>& sphCoords);
/** Calculate spherical harmonic basis of the defined order **/
vnl_matrix<double> CalcShBasis(vnl_matrix<double>& sphCoords);
private:
NormalizationMethods m_NormalizationMethod; ///< normalization method of ODF peaks
unsigned int m_MaxNumPeaks; ///< maximum number of peaks per voxel. if more peaks are detected, only the largest are kept.
double m_PeakThreshold; ///< threshold on the peak length relative to the largest peak inside the current voxel
double m_AbsolutePeakThreshold;///< hard threshold on the peak length of all local maxima
vnl_matrix< double > m_ShBasis; ///< container for evaluated SH base functions
double m_ClusteringThreshold; ///< directions closer together than the specified angular threshold will be clustered (in rad)
double m_AngularThreshold; ///< directions closer together than the specified threshold that remain after clustering are discarded (largest is kept) (in rad)
const int m_NumCoeffs; ///< number of spherical harmonics coefficients
- mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
+ mitk::FiberBundle::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
ItkDirectionImageContainer::Pointer m_DirectionImageContainer;///< container for output peaks
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< number of peaks per voxel
ItkUcharImgType::Pointer m_MaskImage; ///< only voxels inside the binary mask are processed
Toolkit m_Toolkit;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFiniteDiffOdfMaximaExtractionFilter.cpp"
#endif
#endif //__itkFiniteDiffOdfMaximaExtractionFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
index 357ed381e4..e582ffefc5 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
@@ -1,171 +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.
===================================================================*/
#ifndef __itkFslPeakImageConverter_cpp
#define __itkFslPeakImageConverter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkFslPeakImageConverter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
namespace itk {
template< class PixelType >
FslPeakImageConverter< PixelType >::FslPeakImageConverter():
m_NormalizationMethod(NO_NORM)
{
}
template< class PixelType >
void FslPeakImageConverter< PixelType >
::GenerateData()
{
// output vector field
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
Vector<float, 4> spacing4 = m_InputImages->GetElement(0)->GetSpacing();
Point<float, 4> origin4 = m_InputImages->GetElement(0)->GetOrigin();
Matrix<double, 4, 4> direction4 = m_InputImages->GetElement(0)->GetDirection();
ImageRegion<4> imageRegion4 = m_InputImages->GetElement(0)->GetLargestPossibleRegion();
itk::Vector<double,3> spacing3;
Point<float, 3> origin3;
Matrix<double, 3, 3> direction3;
ImageRegion<3> imageRegion3;
spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
for (int r=0; r<3; r++)
for (int c=0; c<3; c++)
direction3[r][c] = direction4[r][c];
imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
double minSpacing = spacing3[0];
if (spacing3[1]<minSpacing)
minSpacing = spacing3[1];
if (spacing3[2]<minSpacing)
minSpacing = spacing3[2];
m_DirectionImageContainer = DirectionImageContainerType::New();
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
for (int i=0; i<m_InputImages->Size(); i++)
{
InputImageType::Pointer img = m_InputImages->GetElement(i);
int x = img->GetLargestPossibleRegion().GetSize(0);
int y = img->GetLargestPossibleRegion().GetSize(1);
int z = img->GetLargestPossibleRegion().GetSize(2);
ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
directionImage->SetSpacing( spacing3 );
directionImage->SetOrigin( origin3 );
directionImage->SetDirection( direction3 );
directionImage->SetRegions( imageRegion3 );
directionImage->Allocate();
Vector< PixelType, 3 > nullVec; nullVec.Fill(0.0);
directionImage->FillBuffer(nullVec);
for (int a=0; a<x; a++)
for (int b=0; b<y; b++)
for (int c=0; c<z; c++)
{
// generate vector field
typename InputImageType::IndexType index;
index.SetElement(0,a);
index.SetElement(1,b);
index.SetElement(2,c);
vnl_vector<double> dirVec; dirVec.set_size(4);
for (int k=0; k<3; k++)
{
index.SetElement(3,k);
dirVec[k] = img->GetPixel(index);
}
dirVec[3] = 0;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 4> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
center[3] = 0;
itk::Point<double, 4> worldCenter;
img->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dirVec.normalize();
break;
}
dirVec.normalize();
dirVec = img->GetDirection()*dirVec;
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dirVec[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dirVec[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dirVec[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dirVec[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dirVec[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dirVec[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
// generate direction image
typename ItkDirectionImageType::IndexType index2;
index2[0] = index[0]; index2[1] = index[1]; index2[2] = index[2];
Vector< PixelType, 3 > pixel;
pixel.SetElement(0, dirVec[0]);
pixel.SetElement(1, dirVec[1]);
pixel.SetElement(2, dirVec[2]);
directionImage->SetPixel(index2, pixel);
}
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), directionImage);
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
- m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+ m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
}
}
#endif // __itkFslPeakImageConverter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h
index a118e35021..9639353f6d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h
@@ -1,89 +1,89 @@
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-27 17:01:06 $
Version: $Revision: 1.12 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkFslPeakImageConverter_h_
#define __itkFslPeakImageConverter_h_
#include <itkImageToImageFilter.h>
#include <itkVectorContainer.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkOrientationDistributionFunction.h>
namespace itk{
/** \class FslPeakImageConverter
- Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundleX.
+ Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundle.
These 4D files are for example generated by the FSL qboot command.
*/
template< class PixelType >
class FslPeakImageConverter : public ProcessObject
{
public:
enum NormalizationMethods {
NO_NORM, ///< don't normalize peaks
SINGLE_VEC_NORM ///< normalize peaks to length 1
};
typedef FslPeakImageConverter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ProcessObject Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(FslPeakImageConverter, ImageToImageFilter)
typedef vnl_vector_fixed< double, 3 > DirectionType;
typedef VectorContainer< int, DirectionType > DirectionContainerType;
typedef VectorContainer< int, DirectionContainerType::Pointer > ContainerType;
typedef Image< float, 4 > InputImageType;
typedef VectorContainer< int, InputImageType::Pointer > InputType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImageType;
typedef VectorContainer< int, ItkDirectionImageType::Pointer > DirectionImageContainerType;
itkSetMacro( NormalizationMethod, NormalizationMethods) ///< normalization method of ODF peaks
itkSetMacro( InputImages, InputType::Pointer) ///< MRtrix peak image of type itk::Image< float, 4 >
- itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
+ itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer) ///< container for output peaks
void GenerateData();
protected:
FslPeakImageConverter();
~FslPeakImageConverter(){}
NormalizationMethods m_NormalizationMethod; ///< normalization method of ODF peaks
- mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
+ mitk::FiberBundle::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
InputType::Pointer m_InputImages; ///< MRtrix peak image of type itk::Image< float, 4 >
DirectionImageContainerType::Pointer m_DirectionImageContainer; ///< container for output peaks
private:
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFslPeakImageConverter.cpp"
#endif
#endif //__itkFslPeakImageConverter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
index 49a5fc6b7e..9dc2978402 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
@@ -1,211 +1,211 @@
/*===================================================================
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 __itkMrtrixPeakImageConverter_cpp
#define __itkMrtrixPeakImageConverter_cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "itkMrtrixPeakImageConverter.h"
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionConstIteratorWithIndex.h>
#include <itkImageRegionIterator.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
namespace itk {
template< class PixelType >
MrtrixPeakImageConverter< PixelType >::MrtrixPeakImageConverter():
m_NormalizationMethod(NO_NORM)
{
}
template< class PixelType >
void MrtrixPeakImageConverter< PixelType >
::GenerateData()
{
// output vector field
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
Vector<float, 4> spacing4 = m_InputImage->GetSpacing();
Point<float, 4> origin4 = m_InputImage->GetOrigin();
Matrix<double, 4, 4> direction4 = m_InputImage->GetDirection();
ImageRegion<4> imageRegion4 = m_InputImage->GetLargestPossibleRegion();
Vector<double, 3> spacing3;
Point<float, 3> origin3;
Matrix<double, 3, 3> direction3;
ImageRegion<3> imageRegion3;
spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
for (int r=0; r<3; r++)
for (int c=0; c<3; c++)
direction3[r][c] = direction4[r][c];
imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
double minSpacing = spacing3[0];
if (spacing3[1]<minSpacing)
minSpacing = spacing3[1];
if (spacing3[2]<minSpacing)
minSpacing = spacing3[2];
m_DirectionImageContainer = DirectionImageContainerType::New();
typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
int x = m_InputImage->GetLargestPossibleRegion().GetSize(0);
int y = m_InputImage->GetLargestPossibleRegion().GetSize(1);
int z = m_InputImage->GetLargestPossibleRegion().GetSize(2);
int numDirs = m_InputImage->GetLargestPossibleRegion().GetSize(3)/3;
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing3 );
m_NumDirectionsImage->SetOrigin( origin3 );
m_NumDirectionsImage->SetDirection( direction3 );
m_NumDirectionsImage->SetRegions( imageRegion3 );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
for (int i=0; i<numDirs; i++)
{
ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
directionImage->SetSpacing( spacing3 );
directionImage->SetOrigin( origin3 );
directionImage->SetDirection( direction3 );
directionImage->SetRegions( imageRegion3 );
directionImage->Allocate();
Vector< PixelType, 3 > nullVec; nullVec.Fill(0.0);
directionImage->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), directionImage);
}
double minangle = 0;
for (int i=0; i<numDirs; i++)
{
for (int a=0; a<x; a++)
for (int b=0; b<y; b++)
for (int c=0; c<z; c++)
{
// generate vector field
typename InputImageType::IndexType index;
index.SetElement(0,a);
index.SetElement(1,b);
index.SetElement(2,c);
vnl_vector<double> dirVec; dirVec.set_size(4);
for (int k=0; k<3; k++)
{
index.SetElement(3,k+i*3);
dirVec[k] = m_InputImage->GetPixel(index);
}
dirVec[3] = 0;
if (dirVec.magnitude()<0.0001)
continue;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 4> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
center[3] = 0;
itk::Point<double, 4> worldCenter;
m_InputImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dirVec.normalize();
break;
}
dirVec.normalize();
dirVec = m_InputImage->GetDirection()*dirVec;
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dirVec[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dirVec[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dirVec[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dirVec[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dirVec[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dirVec[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
// generate direction image
typename ItkDirectionImageType::IndexType index2;
index2[0] = a; index2[1] = b; index2[2] = c;
// workaround *********************************************
dirVec = m_InputImage->GetDirection()*dirVec;
dirVec.normalize();
// workaround *********************************************
Vector< PixelType, 3 > pixel;
pixel.SetElement(0, dirVec[0]);
pixel.SetElement(1, dirVec[1]);
pixel.SetElement(2, dirVec[2]);
for (int j=0; j<numDirs; j++)
{
ItkDirectionImageType::Pointer directionImage = m_DirectionImageContainer->ElementAt(j);
Vector< PixelType, 3 > tempPix = directionImage->GetPixel(index2);
if (tempPix.GetNorm()<0.01)
{
directionImage->SetPixel(index2, pixel);
break;
}
else
{
if ( fabs(dot_product(tempPix.GetVnlVector(), pixel.GetVnlVector()))>minangle )
{
minangle = fabs(dot_product(tempPix.GetVnlVector(), pixel.GetVnlVector()));
MITK_INFO << "Minimum angle: " << acos(minangle)*180.0/M_PI;
}
}
}
m_NumDirectionsImage->SetPixel(index2, m_NumDirectionsImage->GetPixel(index2)+1);
}
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
- m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+ m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
}
}
#endif // __itkMrtrixPeakImageConverter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h
index ef134afc8f..34ad3f0e95 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h
@@ -1,91 +1,91 @@
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-27 17:01:06 $
Version: $Revision: 1.12 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkMrtrixPeakImageConverter_h_
#define __itkMrtrixPeakImageConverter_h_
#include <itkImageToImageFilter.h>
#include <itkVectorContainer.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkOrientationDistributionFunction.h>
namespace itk{
/** \class MrtrixPeakImageConverter
- Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundleX.
+ Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundle.
These 4D files are for example generated by the FSL qboot command.
*/
template< class PixelType >
class MrtrixPeakImageConverter : public ProcessObject
{
public:
enum NormalizationMethods {
NO_NORM, ///< don't normalize peaks
SINGLE_VEC_NORM ///< normalize peaks to length 1
};
typedef MrtrixPeakImageConverter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ProcessObject Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(MrtrixPeakImageConverter, ImageToImageFilter)
typedef vnl_vector_fixed< double, 3 > DirectionType;
typedef VectorContainer< int, DirectionType > DirectionContainerType;
typedef VectorContainer< int, DirectionContainerType::Pointer > ContainerType;
typedef Image< float, 4 > InputImageType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImageType;
typedef VectorContainer< int, ItkDirectionImageType::Pointer > DirectionImageContainerType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
itkSetMacro( NormalizationMethod, NormalizationMethods) ///< normalization method of ODF peaks
itkSetMacro( InputImage, InputImageType::Pointer) ///< MRtrix direction image of type itk::Image< float, 4 >
- itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
+ itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer) ///< container for output peaks
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< number of peaks per voxel
void GenerateData();
protected:
MrtrixPeakImageConverter();
~MrtrixPeakImageConverter(){}
NormalizationMethods m_NormalizationMethod; ///< normalization method of ODF peaks
- mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
+ mitk::FiberBundle::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
InputImageType::Pointer m_InputImage; ///< MRtrix direction image of type itk::Image< float, 4 >
DirectionImageContainerType::Pointer m_DirectionImageContainer; ///< container for output peaks
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< number of peaks per voxel
private:
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMrtrixPeakImageConverter.cpp"
#endif
#endif //__itkMrtrixPeakImageConverter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
index 23a79eb8cf..c7acd3de0f 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
@@ -1,629 +1,629 @@
/*===================================================================
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 __itkOdfMaximaExtractionFilter_cpp
#define __itkOdfMaximaExtractionFilter_cpp
#include "itkOdfMaximaExtractionFilter.h"
#include <itkImageRegionIterator.h>
#include <itkContinuousIndex.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <boost/progress.hpp>
#include <boost/math/special_functions.hpp>
#include <vnl/vnl_det.h>
#include <vnl/vnl_trace.h>
using namespace boost::math;
using namespace std;
namespace itk {
template< class TOdfPixelType >
OdfMaximaExtractionFilter< TOdfPixelType >::OdfMaximaExtractionFilter():
m_NormalizationMethod(MAX_VEC_NORM),
m_PeakThreshold(0.2),
m_MaxNumPeaks(10),
m_ShCoeffImage(NULL),
m_OutputFiberBundle(NULL),
m_NumDirectionsImage(NULL),
m_DirectionImageContainer(NULL)
{
}
// solve ax? + bx? + cx + d = 0 using cardanos method
template< class TOdfPixelType >
bool OdfMaximaExtractionFilter<TOdfPixelType>::ReconstructQballImage()
{
if (m_ShCoeffImage.IsNotNull())
{
cout << "Using preset coefficient image\n";
return true;
}
cout << "Starting qball reconstruction\n";
try {
QballReconstructionFilterType::Pointer filter = QballReconstructionFilterType::New();
filter->SetGradientImage( m_DiffusionGradients, m_DiffusionImage );
filter->SetBValue(m_Bvalue);
filter->SetLambda(0.006);
filter->SetNormalizationMethod(QballReconstructionFilterType::QBAR_SOLID_ANGLE);
filter->Update();
m_ShCoeffImage = filter->GetCoefficientImage();
if (m_ShCoeffImage.IsNull())
return false;
return true;
}
catch (...)
{
return false;
}
}
// solve ax³ + bx² + cx + d = 0 using cardanos method
template< class TOdfPixelType >
std::vector<double> OdfMaximaExtractionFilter< TOdfPixelType >
::SolveCubic(const double& a, const double& b, const double& c, const double& d)
{
double A, B, p, q, r, D, offset, ee, tmp, root;
vector<double> roots;
double inv3 = 1.0/3.0;
if (a!=0) // solve ax³ + bx² + cx + d = 0
{
p = b/a; q = c/a; r = d/a; // x³ + px² + qx + r = 0
A = q-p*p*inv3;
B = (2.0*p*p*p-9.0*p*q+27.0*r)/27.0;
A = A*inv3;
B = B*0.5;
D = B*B+A*A*A;
offset = p*inv3;
if (D>0.0) // one real root
{
ee = sqrt(D);
tmp = -B+ee; root = cbrt(tmp);
tmp = -B-ee; root += cbrt(tmp);
root -= offset; roots.push_back(root);
}
else if (D<0.0) // three real roots
{
ee = sqrt(-D);
double tmp2 = -B;
double angle = 2.0*inv3*atan(ee/(sqrt(tmp2*tmp2+ee*ee)+tmp2));
double sqrt3 = sqrt(3.0);
tmp = cos(angle);
tmp2 = sin(angle);
ee = sqrt(-A);
root = 2*ee*tmp-offset; roots.push_back(root);
root = -ee*(tmp+sqrt3*tmp2)-offset; roots.push_back(root);
root = -ee*(tmp-sqrt3*tmp2)-offset; roots.push_back(root);
}
else // one or two real roots
{
tmp=-B;
tmp=cbrt(tmp);
root=2*tmp-offset; roots.push_back(root);
if (A!=0 || B!=0)
root=-tmp-offset; roots.push_back(root);
}
}
else if (b!=0) // solve bx² + cx + d = 0
{
D = c*c-4*b*d;
if (D>0)
{
tmp = sqrt(D);
root = (-c+tmp)/(2.0*b); roots.push_back(root);
root = (-c-tmp)/(2.0*b); roots.push_back(root);
}
else if (D==0)
root = -c/(2.0*b); roots.push_back(root);
}
else if (c!=0) // solve cx + d = 0
root = -d/c; roots.push_back(root);
return roots;
}
template< class TOdfPixelType >
double OdfMaximaExtractionFilter< TOdfPixelType >
::ODF_dtheta(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
{
double dtheta=(G-7*E)*sn*sn + (7*F-35*D-H)*sn*cs + (H+C-F-3*A-5*D)*sn + (0.5*E+B+0.5*G)*cs -0.5*G+3.5*E;
return dtheta;
}
template< class TOdfPixelType >
double OdfMaximaExtractionFilter< TOdfPixelType >
::ODF_dtheta2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
{
double dtheta2=4*(G-7*E)*sn*cs + 2*(7*F-35*D-H)*(2*cs*cs-1) + 2*(H+C-F-3*A-5*D)*cs -(E+2*B+G)*sn;
return dtheta2;
}
template< class TOdfPixelType >
double OdfMaximaExtractionFilter< TOdfPixelType >
::ODF_dphi2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
{
double dphi2=35*D*((1+cs)*(1+cs)/4)+(3*A-30*D)*(1+cs)/2.0+3*D-A + 0.5*(7*E*(1+cs)/2.0-3*E+B)*sn + (7*F*(1+cs)/2+C-F)*(1-cs)/2.0 + G*sn*(1-cs)/4.0 + H*((1-cs)*(1-cs)/4);
return dphi2;
}
template< class TOdfPixelType >
void OdfMaximaExtractionFilter< TOdfPixelType >
::FindCandidatePeaks(const CoefficientPixelType& SHcoeff)
{
const double thr = 0.03; // threshold on the derivative of the ODF with respect to theta
const double phi_step = 0.005; // step size for 1D exhaustive search on phi
bool highRes; // when close to maxima increase resolution
double mag, Y, Yp, sn, cs;
double phi, dPhi;
double A, B, C, D, E, F, G, H, Bp, Cp, Ep, Fp, Gp, Hp, Bs, Cs, Es, Fs, Gs, Hs;
CoefficientPixelType a, ap;
a = SHcoeff; ap = SHcoeff;
m_CandidatePeaks.clear(); // clear peaks of last voxel
for (int adaptiveStepwidth=0; adaptiveStepwidth<=1; adaptiveStepwidth++)
{
phi=0;
while (phi<(2*M_PI)) // phi exhaustive search 0..pi
{
// calculate 4th order SH representtaion of ODF and according derivative
for (int l=0; l<=4; l=l+2)
{
for (int m=-l; m<=l; m++)
{
int j=l*(l+1)/2+m;
if (m<0)
{
mag = sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l+m)/factorial<double>(l-m));
Y = mag*cos(m*phi);
Yp = -m*mag*sin(m*phi);
}
else if (m==0)
{
Y = sqrt((2*l+1)/(4*M_PI));
Yp = 0;
}
else
{
mag = pow(-1.0,m)*sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l-m)/factorial<double>(l+m));
Y = mag*sin(m*phi);
Yp = m*mag*cos(m*phi);
}
a[j] = SHcoeff[j]*Y;
ap[j] = SHcoeff[j]*Yp;
}
}
// ODF
A=0.5*a[3]; B=-3*(a[2]+a[4]); C=3*(a[1]+a[5]); D=0.125*a[10]; E=-2.5*(a[9]+a[11]);
F=7.5*(a[8]+a[12]); G=-105*(a[7]+a[13]); H=105*(a[6]+a[14]);
// phi derivative
Bp=-3*(ap[2]+ap[4]); Cp=3*(ap[1]+ap[5]); Ep=-2.5*(ap[9]+ap[11]);
Fp=7.5*(ap[8]+ap[12]); Gp=-105*(ap[7]+ap[13]); Hp=105*(ap[6]+ap[14]);
// 2phi derivative
Bs=-B; Cs=-4*C; Es=-E;
Fs=-4*F; Gs=-9*G; Hs=-16*H;
// solve cubic for tan(theta)
std::vector<double> tanTheta = SolveCubic(Hp+Cp-Fp, Gp+Bp-3*Ep, 6*Fp+Cp, Bp+4*Ep);
highRes = false;
dPhi = phi_step;
//for each real cubic solution for tan(theta)
for (int n=0; n<tanTheta.size(); n++)
{
double tmp = atan(tanTheta[n]); // arcus tangens of root (theta -pi/2..pi/2)
double theta = floor(tmp/M_PI); // project theta to 0..pi ...
theta = tmp - theta*M_PI; // ... as the modulo of the division atan(tth[n])/M_PI
sn = sin(2*theta); cs = cos(2*theta);
tmp = ODF_dtheta(sn, cs, A, B, C, D, E, F, G, H);
if (fabs(tmp) < thr) // second condition for maximum is true (theta derivative < eps)
{
//Compute the Hessian
vnl_matrix_fixed< double, 2, 2 > hessian;
hessian(0,0) = ODF_dtheta2(sn, cs, A, B, C, D, E, F, G, H);
hessian(0,1) = ODF_dtheta(sn, cs, 0, Bp, Cp, 0, Ep, Fp, Gp, Hp);
hessian(1,0) = hessian(0,1);
hessian(1,1) = ODF_dphi2(sn, cs, 0, Bs, Cs, 0, Es, Fs, Gs, Hs);
double det = vnl_det(hessian); // determinant
double tr = vnl_trace(hessian); // trace
highRes = true; // we are close to a maximum, so turn on high resolution 1D exhaustive search
if (det>=0 && tr<=0) // check if we really have a local maximum
{
vnl_vector_fixed< double, 2 > peak;
peak[0] = theta;
peak[1] = phi;
m_CandidatePeaks.push_back(peak);
}
}
if (adaptiveStepwidth) // calculate adaptive step width
{
double t2=tanTheta[n]*tanTheta[n]; double t3=t2*tanTheta[n]; double t4=t3*tanTheta[n];
double const_step=phi_step*(1+t2)/sqrt(t2+t4+pow((((Hs+Cs-Fs)*t3+(Gs+Bs-3*Es)*t2+(6*Fs+Cs)*tanTheta[n]+(Bs+4*Es))/(3*(Hp+Cp-Fp)*t2+2*(Gp+Bp-3*Ep)*tanTheta[n]+(6*Fp+Cp))),2.0));
if (const_step<dPhi)
dPhi=const_step;
}
}
// update phi
if (highRes)
phi=phi+dPhi*0.5;
else
phi=phi+dPhi;
}
}
}
template< class TOdfPixelType >
std::vector< vnl_vector_fixed< double, 3 > > OdfMaximaExtractionFilter< TOdfPixelType >
::ClusterPeaks(const CoefficientPixelType& shCoeff)
{
const double distThres = 0.4;
int npeaks = 0, nMin = 0;
double dMin, dPos, dNeg, d;
Vector3D u;
vector< Vector3D > v;
// initialize container for vector clusters
std::vector < std::vector< Vector3D > > clusters;
clusters.resize(m_CandidatePeaks.size());
for (int i=0; i<m_CandidatePeaks.size(); i++)
{
// calculate cartesian representation of peak
u[0] = sin(m_CandidatePeaks[i](0))*cos(m_CandidatePeaks[i](1));
u[1] = sin(m_CandidatePeaks[i](0))*sin(m_CandidatePeaks[i](1));
u[2] = cos(m_CandidatePeaks[i](0));
dMin = itk::NumericTraits<double>::max();
for (int n=0; n<npeaks; n++) //for each other maximum v already visited
{
// euclidean distance from u/-u to other clusters
dPos = vnl_vector_ssd(v[n],u);
dNeg = vnl_vector_ssd(v[n],-u);
d = std::min(dPos,dNeg);
if ( d<dMin )
{
dMin = d; // adjust minimum
nMin = n; // store its index
if ( dNeg<dPos ) // flip u if neccesary
u=-u;
}
}
if ( dMin<distThres ) // if u is very close to any other maximum v
{
clusters[nMin].push_back(u); //store it with all other vectors that are close to v vector (with index nMin)
}
else // otherwise store u as output peak
{
v.push_back(u);
npeaks++;
}
}
// calculate mean vector of each cluster
for (int i=0; i<m_CandidatePeaks.size(); i++)
if ( !clusters[i].empty() )
{
v[i].fill(0.0);
for (int vc=0; vc<clusters[i].size(); vc++)
v[i]=v[i]+clusters[i][vc];
v[i].normalize();
}
if (npeaks!=0)
{
// check the ODF amplitudes at each candidate peak
vnl_matrix< double > shBasis, sphCoords;
Cart2Sph(v, sphCoords); // convert candidate peaks to spherical angles
shBasis = CalcShBasis(sphCoords, 4); // evaluate spherical harmonics at each peak
vnl_vector<double> odfVals(npeaks);
odfVals.fill(0.0);
double maxVal = itk::NumericTraits<double>::NonpositiveMin();
int maxPos;
for (int i=0; i<npeaks; i++) //compute the ODF value at each peak
{
for (int j=0; j<15; j++)
odfVals(i) += shCoeff[j]*shBasis(i,j);
if ( odfVals(i)>maxVal )
{
maxVal = odfVals(i);
maxPos = i;
}
}
v.clear();
vector< double > restVals;
for (int i=0; i<npeaks; i++) // keep only peaks with high enough amplitude and convert back to cartesian coordinates
if ( odfVals(i)>=m_PeakThreshold*maxVal )
{
u[0] = odfVals(i)*cos(sphCoords(i,1))*sin(sphCoords(i,0));
u[1] = odfVals(i)*sin(sphCoords(i,1))*sin(sphCoords(i,0));
u[2] = odfVals(i)*cos(sphCoords(i,0));
restVals.push_back(odfVals(i));
v.push_back(u);
}
npeaks = v.size();
if (npeaks>m_MaxNumPeaks) // if still too many peaks, keep only the m_MaxNumPeaks with maximum value
{
vector< Vector3D > v2;
for (int i=0; i<m_MaxNumPeaks; i++)
{
maxVal = itk::NumericTraits<double>::NonpositiveMin(); //Get the maximum ODF peak value and the corresponding peak index
for (int i=0; i<npeaks; i++)
if ( restVals[i]>maxVal )
{
maxVal = restVals[i];
maxPos = i;
}
v2.push_back(v[maxPos]);
restVals[maxPos] = 0; //zero that entry in order to find the next maximum
}
return v2;
}
}
return v;
}
// convert cartesian to spherical coordinates
template< class TOdfPixelType >
void OdfMaximaExtractionFilter< TOdfPixelType >
::Cart2Sph(const std::vector< Vector3D >& dir, vnl_matrix<double>& sphCoords)
{
sphCoords.set_size(dir.size(), 2);
for (int i=0; i<dir.size(); i++)
{
double mag = dir[i].magnitude();
if( mag<mitk::eps )
{
sphCoords(i,0) = M_PI/2; // theta
sphCoords(i,1) = M_PI/2; // phi
}
else
{
sphCoords(i,0) = acos(dir[i](2)/mag); // theta
sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
}
}
}
// generate spherical harmonic values of the desired order for each input direction
template< class TOdfPixelType >
vnl_matrix<double> OdfMaximaExtractionFilter< TOdfPixelType >
::CalcShBasis(vnl_matrix<double>& sphCoords, const int& shOrder)
{
int R = (shOrder+1)*(shOrder+2)/2;
int M = sphCoords.rows();
int j, m; double mag, plm;
vnl_matrix<double> shBasis;
shBasis.set_size(M,R);
for (int p=0; p<M; p++)
{
j=0;
for (int l=0; l<=shOrder; l=l+2)
for (m=-l; m<=l; m++)
{
plm = legendre_p<double>(l,abs(m),cos(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)*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*sphCoords(p,1));
j++;
}
}
return shBasis;
}
template< class TOdfPixelType >
void OdfMaximaExtractionFilter< TOdfPixelType >
::GenerateData()
{
if (!ReconstructQballImage())
return;
std::cout << "Starting maxima extraction\n";
switch (m_NormalizationMethod)
{
case NO_NORM:
std::cout << "NO_NORM\n";
break;
case SINGLE_VEC_NORM:
std::cout << "SINGLE_VEC_NORM\n";
break;
case MAX_VEC_NORM:
std::cout << "MAX_VEC_NORM\n";
break;
}
typedef ImageRegionConstIterator< CoefficientImageType > InputIteratorType;
InputIteratorType git(m_ShCoeffImage, m_ShCoeffImage->GetLargestPossibleRegion() );
itk::Vector<double,3> spacing = m_ShCoeffImage->GetSpacing();
double minSpacing = spacing[0];
if (spacing[1]<minSpacing)
minSpacing = spacing[1];
if (spacing[2]<minSpacing)
minSpacing = spacing[2];
mitk::Point3D origin = m_ShCoeffImage->GetOrigin();
itk::Matrix<double, 3, 3> direction = m_ShCoeffImage->GetDirection();
ImageRegion<3> imageRegion = m_ShCoeffImage->GetLargestPossibleRegion();
// initialize num directions image
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
m_DirectionImageContainer = ItkDirectionImageContainer::New();
for (int i=0; i<m_MaxNumPeaks; i++)
{
itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
ItkDirectionImage::Pointer img = ItkDirectionImage::New();
img->SetSpacing( spacing );
img->SetOrigin( origin );
img->SetDirection( direction );
img->SetRegions( imageRegion );
img->Allocate();
img->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
}
if (m_MaskImage.IsNull())
{
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
itk::ImageRegionIterator<ItkUcharImgType> maskIt(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
int maxProgress = m_MaskImage->GetLargestPossibleRegion().GetSize()[0]*m_MaskImage->GetLargestPossibleRegion().GetSize()[1]*m_MaskImage->GetLargestPossibleRegion().GetSize()[2];
boost::progress_display disp(maxProgress);
git.GoToBegin();
while( !git.IsAtEnd() )
{
++disp;
if (maskIt.Value()<=0)
{
++git;
++dirIt;
++maskIt;
continue;
}
CoefficientPixelType c = git.Get();
FindCandidatePeaks(c);
std::vector< Vector3D > directions = ClusterPeaks(c);
typename CoefficientImageType::IndexType index = git.GetIndex();
float max = 0.0;
for (int i=0; i<directions.size(); i++)
if (directions.at(i).magnitude()>max)
max = directions.at(i).magnitude();
if (max<0.0001)
max = 1.0;
for (int i=0; i<directions.size(); i++)
{
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
itk::Vector< float, 3 > pixel;
vnl_vector<double> dir = directions.at(i);
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
m_ShCoeffImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
switch (m_NormalizationMethod)
{
case NO_NORM:
break;
case SINGLE_VEC_NORM:
dir.normalize();
break;
case MAX_VEC_NORM:
dir /= max;
break;
}
dir = m_MaskImage->GetDirection()*dir;
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
img->SetPixel(index, pixel);
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
dirIt.Set(directions.size());
++git;
++dirIt;
++maskIt;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
- m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+ m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
std::cout << "Maxima extraction finished\n";
}
}
#endif // __itkOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h
index 179fccb036..5ec120bca7 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h
@@ -1,145 +1,145 @@
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-27 17:01:06 $
Version: $Revision: 1.12 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkOdfMaximaExtractionFilter_h_
#define __itkOdfMaximaExtractionFilter_h_
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkImageToImageFilter.h>
#include <itkVectorContainer.h>
#include <itkOrientationDistributionFunction.h>
#include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
namespace itk{
/** \class OdfMaximaExtractionFilter
Class that estimates the maxima of the 4th order SH representation of an ODF using analytic calculations (according to Aganj et al, MICCAI, 2010)
*/
template< class TOdfPixelType >
class OdfMaximaExtractionFilter : public ProcessObject
{
public:
enum NormalizationMethods {
NO_NORM, ///< don't normalize peaks
SINGLE_VEC_NORM, ///< normalize peaks to length 1
MAX_VEC_NORM ///< largest peak is normalized to length 1, other peaks relative to it
};
typedef OdfMaximaExtractionFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ProcessObject Superclass;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(OdfMaximaExtractionFilter, ImageToImageFilter)
typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> QballReconstructionFilterType;
typedef QballReconstructionFilterType::CoefficientImageType CoefficientImageType;
typedef CoefficientImageType::PixelType CoefficientPixelType;
typedef itk::VectorImage< short, 3 > DiffusionImageType;
typedef vnl_vector_fixed< double, 3 > Vector3D;
typedef VectorContainer< unsigned int, Vector3D > DirectionContainerType;
typedef VectorContainer< unsigned int, DirectionContainerType::Pointer > ContainerType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image< itk::Vector< float, 3 >, 3> ItkDirectionImage;
typedef itk::VectorContainer< unsigned int, ItkDirectionImage::Pointer > ItkDirectionImageContainer;
// output
- itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
+ itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer) ///< vector field (peak sizes rescaled for visualization purposes)
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< number of peaks per voxel
itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer) ///< container for output peaks
// input
itkSetMacro( MaskImage, ItkUcharImgType::Pointer) ///< only voxels inside the binary mask are processed
itkSetMacro( NormalizationMethod, NormalizationMethods) ///< normalization method of ODF peaks
itkSetMacro( DiffusionGradients, DirectionContainerType::Pointer) ///< input for qball reconstruction
itkSetMacro( DiffusionImage, DiffusionImageType::Pointer) ///< input for qball reconstruction
itkSetMacro( Bvalue, float) ///< input for qball reconstruction
itkSetMacro( ShCoeffImage, CoefficientImageType::Pointer) ///< conatins spherical harmonic coefficients
itkSetMacro( MaxNumPeaks, unsigned int) ///< if more peaks are found, only the largest are kept
itkSetMacro( PeakThreshold, double) ///< threshold on peak length relative to the largest peak in the current voxel
void GenerateData();
protected:
OdfMaximaExtractionFilter();
~OdfMaximaExtractionFilter(){}
/** CSA Qball reconstruction (SH order 4) **/
bool ReconstructQballImage();
/** calculate roots of cubic equation ax³ + bx² + cx + d = 0 using cardanos method **/
std::vector<double> SolveCubic(const double& a, const double& b, const double& c, const double& d);
/** derivatives of SH representation of the ODF **/
double ODF_dtheta2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);
/** derivatives of SH representation of the ODF **/
double ODF_dphi2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);
/** derivatives of SH representation of the ODF **/
double ODF_dtheta(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);
/** calculate all directions fullfilling the maximum consitions **/
void FindCandidatePeaks(const CoefficientPixelType& SHcoeff);
/** cluster the peaks detected by FindCandidatePeaks and retain maximum m_MaxNumPeaks **/
std::vector< Vector3D > ClusterPeaks(const CoefficientPixelType& shCoeff);
void Cart2Sph(const std::vector< Vector3D >& dir, vnl_matrix<double>& sphCoords);
vnl_matrix<double> CalcShBasis(vnl_matrix<double>& sphCoords, const int& shOrder);
// diffusion weighted image (mandatory input)
DirectionContainerType::Pointer m_DiffusionGradients; ///< input for qball reconstruction
DiffusionImageType::Pointer m_DiffusionImage; ///< input for qball reconstruction
float m_Bvalue; ///< input for qball reconstruction
// binary mask image (optional input)
ItkUcharImgType::Pointer m_MaskImage; ///< only voxels inside the binary mask are processed
// input parameters
NormalizationMethods m_NormalizationMethod; ///< normalization for peaks
double m_PeakThreshold; ///< threshold on peak length relative to the largest peak in the current voxel
unsigned int m_MaxNumPeaks; ///< if more peaks are found, only the largest are kept
// intermediate results
CoefficientImageType::Pointer m_ShCoeffImage; ///< conatins spherical harmonic coefficients
std::vector< vnl_vector_fixed< double, 2 > > m_CandidatePeaks; ///< container for candidate peaks (all extrema, also minima)
// output data
- mitk::FiberBundleX::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
+ mitk::FiberBundle::Pointer m_OutputFiberBundle; ///< vector field (peak sizes rescaled for visualization purposes)
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< number of peaks per voxel
ItkDirectionImageContainer::Pointer m_DirectionImageContainer; ///< output peaks
private:
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkOdfMaximaExtractionFilter.cpp"
#endif
#endif //__itkOdfMaximaExtractionFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionIO/files.cmake b/Modules/DiffusionImaging/DiffusionIO/files.cmake
index f3a9cf5840..01f7540f91 100644
--- a/Modules/DiffusionImaging/DiffusionIO/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionIO/files.cmake
@@ -1,41 +1,43 @@
set(CPP_FILES
mitkDiffusionModuleActivator.cpp
mitkNrrdTbssImageWriterFactory.cpp
- #mitkFiberBundleXIOFactory.cpp
+ #mitkFiberBundleIOFactory.cpp
mitkConnectomicsNetworkReader.cpp
mitkConnectomicsNetworkWriter.cpp
mitkConnectomicsNetworkSerializer.cpp
mitkConnectomicsNetworkDefinitions.cpp
mitkNrrdTbssRoiImageIOFactory.cpp
- #mitkFiberBundleXWriterFactory.cpp
+ #mitkFiberBundleWriterFactory.cpp
mitkNrrdTbssRoiImageWriterFactory.cpp
mitkNrrdTensorImageReader.cpp
mitkNrrdTensorImageWriter.cpp
mitkTensorImageSerializer.cpp
mitkTensorImageSource.cpp
mitkFiberTrackingObjectFactory.cpp
mitkConnectomicsObjectFactory.cpp
mitkQuantificationObjectFactory.cpp
mitkNrrdTbssImageIOFactory.cpp
mitkDiffusionCoreObjectFactory.cpp
mitkDiffusionIOMimeTypes.cpp
mitkDiffusionImageNrrdReaderService.cpp
mitkDiffusionImageNrrdWriterService.cpp
mitkDiffusionImageNiftiReaderService.cpp
mitkDiffusionImageNiftiWriterService.cpp
mitkNrrdQBallImageReader.cpp
mitkNrrdQBallImageWriter.cpp
mitkQBallImageSerializer.cpp
- mitkFiberBundleXReader.cpp
- mitkFiberBundleXWriter.cpp
- mitkFiberBundleXSerializer.cpp
- mitkFiberBundleXMapper2D.cpp
- mitkFiberBundleXMapper3D.cpp
+ mitkFiberBundleTrackVisReader.cpp
+ mitkFiberBundleTrackVisWriter.cpp
+ mitkFiberBundleVtkReader.cpp
+ mitkFiberBundleVtkWriter.cpp
+ mitkFiberBundleSerializer.cpp
+ mitkFiberBundleMapper2D.cpp
+ mitkFiberBundleMapper3D.cpp
mitkCompositeMapper.cpp
)
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
index fda24fc676..f3bb89a8e2 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
@@ -1,311 +1,327 @@
/*===================================================================
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>
#include <mitkLogMacros.h>
namespace mitk
{
std::vector<CustomMimeType*> DiffusionIOMimeTypes::Get()
{
std::vector<CustomMimeType*> mimeTypes;
// order matters here (descending rank for mime types)
mimeTypes.push_back(DWI_NRRD_MIMETYPE().Clone());
mimeTypes.push_back(DWI_NIFTI_MIMETYPE().Clone());
mimeTypes.push_back(DTI_MIMETYPE().Clone());
mimeTypes.push_back(QBI_MIMETYPE().Clone());
- mimeTypes.push_back(FIBERBUNDLE_MIMETYPE().Clone());
+ mimeTypes.push_back(FIBERBUNDLE_VTK_MIMETYPE().Clone());
+ mimeTypes.push_back(FIBERBUNDLE_TRK_MIMETYPE().Clone());
mimeTypes.push_back(CONNECTOMICS_MIMETYPE().Clone());
return mimeTypes;
}
// Mime Types
-CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE()
+CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE()
{
- CustomMimeType mimeType(FIBERBUNDLE_MIMETYPE_NAME());
- std::string category = "Fiber Bundle File";
- mimeType.SetComment("Fiber Bundles");
+ CustomMimeType mimeType(FIBERBUNDLE_VTK_MIMETYPE_NAME());
+ std::string category = "VTK Fibers";
+ mimeType.SetComment("VTK Fibers");
mimeType.SetCategory(category);
mimeType.AddExtension("fib");
+ mimeType.AddExtension("vtk");
+ return mimeType;
+}
+
+CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE()
+{
+ CustomMimeType mimeType(FIBERBUNDLE_TRK_MIMETYPE_NAME());
+ std::string category = "TrackVis Fibers";
+ mimeType.SetComment("TrackVis Fibers");
+ mimeType.SetCategory(category);
mimeType.AddExtension("trk");
- //mimeType.AddExtension("vtk");
return mimeType;
}
DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::DiffusionImageNrrdMimeType()
: CustomMimeType(DWI_NRRD_MIMETYPE_NAME())
{
std::string category = "Diffusion Weighted Image";
this->SetCategory(category);
this->SetComment("Diffusion Weighted Images");
this->AddExtension("dwi");
this->AddExtension("hdwi");
this->AddExtension("nrrd");
}
bool DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::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 = this->GetExtension( 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);
try
{
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;
}
}
}
}
catch( const itk::ExceptionObject &e )
{
MITK_ERROR << "ITK Exception: " << e.what();
}
canRead = false;
}
return canRead;
}
DiffusionIOMimeTypes::DiffusionImageNrrdMimeType* DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::Clone() const
{
return new DiffusionImageNrrdMimeType(*this);
}
DiffusionIOMimeTypes::DiffusionImageNrrdMimeType DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE()
{
return DiffusionImageNrrdMimeType();
}
DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::DiffusionImageNiftiMimeType()
: CustomMimeType(DWI_NIFTI_MIMETYPE_NAME())
{
std::string category = "Diffusion Weighted Image";
this->SetCategory(category);
this->SetComment("Diffusion Weighted Images");
this->AddExtension("fsl");
this->AddExtension("fslgz");
this->AddExtension("nii");
this->AddExtension("nii.gz");
}
bool DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::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 = this->GetExtension(path);
ext = itksys::SystemTools::LowerCase(ext);
// Nifti files should only be considered for this mime type if they are
// accompanied by bvecs and bvals files defining the diffusion information
if (ext == ".nii" || ext == ".nii.gz")
{
std::string base = itksys::SystemTools::GetFilenamePath(path) + "/"
+ this->GetFilenameWithoutExtension(path);
if (itksys::SystemTools::FileExists(std::string(base + ".bvec").c_str())
&& itksys::SystemTools::FileExists(std::string(base + ".bval").c_str())
)
{
return canRead;
}
if (itksys::SystemTools::FileExists(std::string(base + ".bvecs").c_str())
&& itksys::SystemTools::FileExists(std::string(base + ".bvals").c_str())
)
{
return canRead;
}
canRead = false;
}
return canRead;
}
DiffusionIOMimeTypes::DiffusionImageNiftiMimeType* DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::Clone() const
{
return new DiffusionImageNiftiMimeType(*this);
}
DiffusionIOMimeTypes::DiffusionImageNiftiMimeType DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE()
{
return DiffusionImageNiftiMimeType();
}
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_NRRD_MIMETYPE_NAME()
{
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dwi";
return name;
}
std::string DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME()
{
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fsl";
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()
+std::string DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME()
+{
+ static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".FiberBundle.vtk";
+ return name;
+}
+
+std::string DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE_NAME()
{
- static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fib";
+ static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".FiberBundle.trk";
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_NRRD_MIMETYPE_DESCRIPTION()
{
static std::string description = "Diffusion Weighted Images";
return description;
}
std::string DiffusionIOMimeTypes::DWI_NIFTI_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 a58c35bfb6..f458090fe6 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
@@ -1,91 +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 MITKDIFFUSIONIOMIMETYPES_H
#define MITKDIFFUSIONIOMIMETYPES_H
#include "mitkCustomMimeType.h"
#include <MitkDiffusionIOExports.h>
#include <string>
namespace mitk {
class DiffusionIOMimeTypes
{
public:
class MitkDiffusionIO_EXPORT DiffusionImageNrrdMimeType : public CustomMimeType
{
public:
DiffusionImageNrrdMimeType();
virtual bool AppliesTo(const std::string &path) const;
virtual DiffusionImageNrrdMimeType* Clone() const;
};
class MitkDiffusionIO_EXPORT DiffusionImageNiftiMimeType : public CustomMimeType
{
public:
DiffusionImageNiftiMimeType();
virtual bool AppliesTo(const std::string &path) const;
virtual DiffusionImageNiftiMimeType* 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 CustomMimeType FIBERBUNDLE_VTK_MIMETYPE();
+ static std::string FIBERBUNDLE_VTK_MIMETYPE_NAME();
static std::string FIBERBUNDLE_MIMETYPE_DESCRIPTION();
+ // ------------------------------ TrackVis formats ----------------------------------
+
+ static CustomMimeType FIBERBUNDLE_TRK_MIMETYPE();
+ static std::string FIBERBUNDLE_TRK_MIMETYPE_NAME();
+
+
// ------------------------- Image formats (ITK based) --------------------------
static DiffusionImageNrrdMimeType DWI_NRRD_MIMETYPE();
static DiffusionImageNiftiMimeType DWI_NIFTI_MIMETYPE();
static CustomMimeType DTI_MIMETYPE(); // dti, hdti
static CustomMimeType QBI_MIMETYPE(); // qbi, hqbi
static std::string DWI_NRRD_MIMETYPE_NAME();
static std::string DWI_NIFTI_MIMETYPE_NAME();
static std::string DTI_MIMETYPE_NAME();
static std::string QBI_MIMETYPE_NAME();
static std::string DWI_NRRD_MIMETYPE_DESCRIPTION();
static std::string DWI_NIFTI_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/mitkDiffusionModuleActivator.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
index 813ead9e5e..1a4edcb659 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
@@ -1,114 +1,122 @@
/*===================================================================
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 <usModuleActivator.h>
#include <usModuleContext.h>
#include <mitkDiffusionImageNrrdReaderService.h>
#include <mitkDiffusionImageNiftiReaderService.h>
#include <mitkNrrdTensorImageReader.h>
#include <mitkNrrdQBallImageReader.h>
-#include <mitkFiberBundleXReader.h>
+#include <mitkFiberBundleVtkReader.h>
+#include <mitkFiberBundleTrackVisReader.h>
#include <mitkConnectomicsNetworkReader.h>
#include <mitkDiffusionImageNrrdWriterService.h>
#include <mitkDiffusionImageNiftiWriterService.h>
#include <mitkNrrdTensorImageWriter.h>
#include <mitkNrrdQBallImageWriter.h>
-#include <mitkFiberBundleXWriter.h>
+#include <mitkFiberBundleVtkWriter.h>
+#include <mitkFiberBundleTrackVisWriter.h>
#include <mitkConnectomicsNetworkWriter.h>
#include "mitkDiffusionIOMimeTypes.h"
namespace mitk
{
/**
\brief Registers services for segmentation module.
*/
class DiffusionModuleActivator : public us::ModuleActivator
{
public:
void Load(us::ModuleContext* context)
{
us::ServiceProperties props;
props[ us::ServiceConstants::SERVICE_RANKING() ] = 10;
m_MimeTypes = mitk::DiffusionIOMimeTypes::Get();
for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = m_MimeTypes.begin(),
iterEnd = m_MimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
{
context->RegisterService(*mimeTypeIter, props);
}
m_DiffusionImageNrrdReaderService = new DiffusionImageNrrdReaderService();
m_DiffusionImageNiftiReaderService = new DiffusionImageNiftiReaderService();
m_NrrdTensorImageReader = new NrrdTensorImageReader();
m_NrrdQBallImageReader = new NrrdQBallImageReader();
- m_FiberBundleXReader = new FiberBundleXReader();
+ m_FiberBundleVtkReader = new FiberBundleVtkReader();
+ m_FiberBundleTrackVisReader = new FiberBundleTrackVisReader();
m_ConnectomicsNetworkReader = new ConnectomicsNetworkReader();
m_DiffusionImageNrrdWriterService = new DiffusionImageNrrdWriterService();
m_DiffusionImageNiftiWriterService = new DiffusionImageNiftiWriterService();
m_NrrdTensorImageWriter = new NrrdTensorImageWriter();
m_NrrdQBallImageWriter = new NrrdQBallImageWriter();
- m_FiberBundleXWriter = new FiberBundleXWriter();
+ m_FiberBundleVtkWriter = new FiberBundleVtkWriter();
+ m_FiberBundleTrackVisWriter = new FiberBundleTrackVisWriter();
m_ConnectomicsNetworkWriter = new ConnectomicsNetworkWriter();
}
void Unload(us::ModuleContext*)
{
for (unsigned int loop(0); loop < m_MimeTypes.size(); ++loop)
{
delete m_MimeTypes.at(loop);
}
delete m_DiffusionImageNrrdReaderService;
delete m_DiffusionImageNiftiReaderService;
delete m_NrrdTensorImageReader;
delete m_NrrdQBallImageReader;
- delete m_FiberBundleXReader;
+ delete m_FiberBundleVtkReader;
+ delete m_FiberBundleTrackVisReader;
delete m_ConnectomicsNetworkReader;
delete m_DiffusionImageNrrdWriterService;
delete m_DiffusionImageNiftiWriterService;
delete m_NrrdTensorImageWriter;
delete m_NrrdQBallImageWriter;
- delete m_FiberBundleXWriter;
+ delete m_FiberBundleVtkWriter;
+ delete m_FiberBundleTrackVisWriter;
delete m_ConnectomicsNetworkWriter;
}
private:
DiffusionImageNrrdReaderService * m_DiffusionImageNrrdReaderService;
DiffusionImageNiftiReaderService * m_DiffusionImageNiftiReaderService;
NrrdTensorImageReader * m_NrrdTensorImageReader;
NrrdQBallImageReader * m_NrrdQBallImageReader;
- FiberBundleXReader * m_FiberBundleXReader;
+ FiberBundleVtkReader * m_FiberBundleVtkReader;
+ FiberBundleTrackVisReader * m_FiberBundleTrackVisReader;
ConnectomicsNetworkReader * m_ConnectomicsNetworkReader;
DiffusionImageNrrdWriterService * m_DiffusionImageNrrdWriterService;
DiffusionImageNiftiWriterService * m_DiffusionImageNiftiWriterService;
NrrdTensorImageWriter * m_NrrdTensorImageWriter;
NrrdQBallImageWriter * m_NrrdQBallImageWriter;
- FiberBundleXWriter * m_FiberBundleXWriter;
+ FiberBundleVtkWriter * m_FiberBundleVtkWriter;
+ FiberBundleTrackVisWriter * m_FiberBundleTrackVisWriter;
ConnectomicsNetworkWriter * m_ConnectomicsNetworkWriter;
std::vector<mitk::CustomMimeType*> m_MimeTypes;
};
}
US_EXPORT_MODULE_ACTIVATOR(mitk::DiffusionModuleActivator)
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
similarity index 87%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
index fc7de2ff13..e2fd8d57fd 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
@@ -1,199 +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 "mitkFiberBundleXMapper2D.h"
+#include "mitkFiberBundleMapper2D.h"
#include <mitkBaseRenderer.h>
#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
#include <vtkPlane.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkProperty.h>
#include <vtkLookupTable.h>
#include <vtkPoints.h>
#include <vtkCamera.h>
#include <vtkPolyLine.h>
#include <vtkRenderer.h>
#include <vtkCellArray.h>
#include <vtkMatrix4x4.h>
#include <vtkTubeFilter.h>
#include <mitkPlaneGeometry.h>
#include <mitkSliceNavigationController.h>
#include <mitkIShaderRepository.h>
#include <mitkShaderProperty.h>
#include <mitkCoreServices.h>
-mitk::FiberBundleXMapper2D::FiberBundleXMapper2D()
+mitk::FiberBundleMapper2D::FiberBundleMapper2D()
: m_LineWidth(1)
{
m_lut = vtkLookupTable::New();
m_lut->Build();
}
-mitk::FiberBundleXMapper2D::~FiberBundleXMapper2D()
+mitk::FiberBundleMapper2D::~FiberBundleMapper2D()
{
}
-mitk::FiberBundleX* mitk::FiberBundleXMapper2D::GetInput()
+mitk::FiberBundle* mitk::FiberBundleMapper2D::GetInput()
{
- return dynamic_cast< mitk::FiberBundleX * > ( GetDataNode()->GetData() );
+ return dynamic_cast< mitk::FiberBundle * > ( GetDataNode()->GetData() );
}
-void mitk::FiberBundleXMapper2D::Update(mitk::BaseRenderer * renderer)
+void mitk::FiberBundleMapper2D::Update(mitk::BaseRenderer * renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible )
return;
// Calculate time step of the input data for the specified renderer (integer value)
// this method is implemented in mitkMapper
this->CalculateTimeStep( renderer );
//check if updates occured in the node or on the display
FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
//set renderer independent shader properties
const DataNode::Pointer node = this->GetDataNode();
float thickness = 2.0;
if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness))
MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR";
bool fiberfading = false;
if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading))
MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR";
float fiberOpacity;
this->GetDataNode()->GetOpacity(fiberOpacity, NULL);
node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberThickness",thickness);
node->SetIntProperty("shader.mitkShaderFiberClipping.fiberFadingON",fiberfading);
node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberOpacity",fiberOpacity);
- mitk::FiberBundleX* fiberBundle = this->GetInput();
+ mitk::FiberBundle* fiberBundle = this->GetInput();
if (fiberBundle==NULL)
return;
int lineWidth = 0;
node->GetIntProperty("LineWidth", lineWidth);
if (m_LineWidth!=lineWidth)
{
m_LineWidth = lineWidth;
fiberBundle->RequestUpdate2D();
}
if ( localStorage->m_LastUpdateTime<renderer->GetDisplayGeometry()->GetMTime() || localStorage->m_LastUpdateTime<fiberBundle->GetUpdateTime2D() )
{
this->UpdateShaderParameter(renderer);
this->GenerateDataForRenderer( renderer );
}
}
-void mitk::FiberBundleXMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer)
+void mitk::FiberBundleMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer)
{
//get information about current position of views
mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController();
mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry();
//generate according cutting planes based on the view position
float planeNormal[3];
planeNormal[0] = planeGeo->GetNormal()[0];
planeNormal[1] = planeGeo->GetNormal()[1];
planeNormal[2] = planeGeo->GetNormal()[2];
float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0];
float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1];
float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2];
float thickness = tmp1 + tmp2 + tmp3; //attention, correct normalvector
DataNode::Pointer node = this->GetDataNode();
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.w",thickness,renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.x",planeNormal[0],renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.y",planeNormal[1],renderer);
node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.z",planeNormal[2],renderer);
}
// vtkActors and Mappers are feeded here
-void mitk::FiberBundleXMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
+void mitk::FiberBundleMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
- mitk::FiberBundleX* fiberBundle = this->GetInput();
+ mitk::FiberBundle* fiberBundle = this->GetInput();
//the handler of local storage gets feeded in this method with requested data for related renderwindow
FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
mitk::DataNode* node = this->GetDataNode();
if ( node == NULL )
return;
vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
if (fiberPolyData == NULL)
return;
fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors());
localStorage->m_FiberMapper->ScalarVisibilityOn();
localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
localStorage->m_FiberMapper->SetLookupTable(m_lut); //apply the properties after the slice was set
localStorage->m_PointActor->GetProperty()->SetOpacity(0.999);
localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
localStorage->m_FiberMapper->SetInputData(fiberPolyData);
localStorage->m_PointActor->SetMapper(localStorage->m_FiberMapper);
localStorage->m_PointActor->GetProperty()->ShadingOn();
localStorage->m_PointActor->GetProperty()->SetLineWidth(m_LineWidth);
// Applying shading properties
this->ApplyShaderProperties(renderer);
// We have been modified => save this for next Update()
localStorage->m_LastUpdateTime.Modified();
}
-vtkProp* mitk::FiberBundleXMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
+vtkProp* mitk::FiberBundleMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
{
this->Update(renderer);
return m_LocalStorageHandler.GetLocalStorage(renderer)->m_PointActor;
}
-void mitk::FiberBundleXMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+void mitk::FiberBundleMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
Superclass::SetDefaultProperties(node, renderer, overwrite);
node->SetProperty("shader",mitk::ShaderProperty::New("mitkShaderFiberClipping"));
// Shaders
IShaderRepository* shaderRepo = CoreServices::GetShaderRepository();
if (shaderRepo)
{
shaderRepo->AddDefaultProperties(node, renderer, overwrite);
}
//add other parameters to propertylist
node->AddProperty( "Fiber2DSliceThickness", mitk::FloatProperty::New(1.0f), renderer, overwrite );
node->AddProperty( "Fiber2DfadeEFX", mitk::BoolProperty::New(true), renderer, overwrite );
node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
node->AddProperty( "TubeRadius",mitk::FloatProperty::New( 0.0 ), renderer, overwrite);
}
-mitk::FiberBundleXMapper2D::FBXLocalStorage::FBXLocalStorage()
+mitk::FiberBundleMapper2D::FBXLocalStorage::FBXLocalStorage()
{
m_PointActor = vtkSmartPointer<vtkActor>::New();
m_FiberMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
similarity index 89%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
index 85d61d0df8..ba1089e97f 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
@@ -1,109 +1,109 @@
/*===================================================================
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 FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
-#define FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
+#ifndef FiberBundleMAPPER2D_H_HEADER_INCLUDED
+#define FiberBundleMAPPER2D_H_HEADER_INCLUDED
//MITK Rendering
#include <mitkCommon.h>
#include <mitkBaseRenderer.h>
//#include <MitkFiberTrackingExports.h>
#include <mitkVtkMapper.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <vtkSmartPointer.h>
class vtkActor;
//class vtkPropAssembly; //lets see if we need it
class mitkBaseRenderer;
class vtkPolyDataMapper;
class vtkCutter;
class vtkPlane;
class vtkPolyData;
namespace mitk {
struct IShaderRepository;
-class FiberBundleXMapper2D : public VtkMapper
+class FiberBundleMapper2D : public VtkMapper
{
public:
- mitkClassMacro(FiberBundleXMapper2D, VtkMapper);
+ mitkClassMacro(FiberBundleMapper2D, VtkMapper);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
- mitk::FiberBundleX* GetInput();
+ mitk::FiberBundle* GetInput();
/** \brief Checks whether this mapper needs to update itself and generate data. */
virtual void Update(mitk::BaseRenderer * renderer);
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
//### methods of MITK-VTK rendering pipeline
virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
//### end of methods of MITK-VTK rendering pipeline
class FBXLocalStorage : public mitk::Mapper::BaseLocalStorage
{
public:
/** \brief Point Actor of a 2D render window. */
vtkSmartPointer<vtkActor> m_PointActor;
/** \brief Point Mapper of a 2D render window. */
vtkSmartPointer<vtkPolyDataMapper> m_FiberMapper;
vtkSmartPointer<vtkPlane> m_SlicingPlane; //needed later when optimized 2D mapper
vtkSmartPointer<vtkPolyData> m_SlicedResult; //might be depricated in optimized 2D mapper
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastUpdateTime;
/** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
FBXLocalStorage(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
~FBXLocalStorage()
{
}
};
/** \brief This member holds all three LocalStorages for the three 2D render windows. */
mitk::LocalStorageHandler<FBXLocalStorage> m_LocalStorageHandler;
protected:
- FiberBundleXMapper2D();
- virtual ~FiberBundleXMapper2D();
+ FiberBundleMapper2D();
+ virtual ~FiberBundleMapper2D();
/** Does the actual resampling, without rendering. */
virtual void GenerateDataForRenderer(mitk::BaseRenderer*);
void UpdateShaderParameter(mitk::BaseRenderer*);
private:
vtkSmartPointer<vtkLookupTable> m_lut;
int m_LineWidth;
};
}//end namespace
#endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
similarity index 82%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
index fd949cdbfa..b69590a4fe 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
@@ -1,189 +1,189 @@
/*===================================================================
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 "mitkFiberBundleXMapper3D.h"
+#include "mitkFiberBundleMapper3D.h"
#include <mitkProperties.h>
#include <vtkPropAssembly.h>
#include <vtkPointData.h>
#include <vtkProperty.h>
#include <vtkCellArray.h>
#include <vtkDepthSortPolyData.h>
#include <vtkCamera.h>
#include <vtkTubeFilter.h>
-mitk::FiberBundleXMapper3D::FiberBundleXMapper3D()
+mitk::FiberBundleMapper3D::FiberBundleMapper3D()
: m_TubeRadius(0.0)
, m_TubeSides(15)
, m_LineWidth(1)
{
m_lut = vtkLookupTable::New();
m_lut->Build();
}
-mitk::FiberBundleXMapper3D::~FiberBundleXMapper3D()
+mitk::FiberBundleMapper3D::~FiberBundleMapper3D()
{
}
-const mitk::FiberBundleX* mitk::FiberBundleXMapper3D::GetInput()
+const mitk::FiberBundle* mitk::FiberBundleMapper3D::GetInput()
{
- return static_cast<const mitk::FiberBundleX * > ( GetDataNode()->GetData() );
+ return static_cast<const mitk::FiberBundle * > ( GetDataNode()->GetData() );
}
/*
This method is called once the mapper gets new input,
for UI rotation or changes in colorcoding this method is NOT called
*/
-void mitk::FiberBundleXMapper3D::InternalGenerateData(mitk::BaseRenderer *renderer)
+void mitk::FiberBundleMapper3D::InternalGenerateData(mitk::BaseRenderer *renderer)
{
- mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*> (GetDataNode()->GetData());
+ mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*> (GetDataNode()->GetData());
if (fiberBundle == NULL)
return;
vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
if (fiberPolyData == NULL)
return;
fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors());
float tmpopa;
this->GetDataNode()->GetOpacity(tmpopa, NULL);
FBXLocalStorage3D *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
if (m_TubeRadius>0.0)
{
vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
tubeFilter->SetInputData(fiberPolyData);
tubeFilter->SetNumberOfSides(m_TubeSides);
tubeFilter->SetRadius(m_TubeRadius);
tubeFilter->Update();
fiberPolyData = tubeFilter->GetOutput();
}
if (tmpopa<1)
{
vtkSmartPointer<vtkDepthSortPolyData> depthSort = vtkSmartPointer<vtkDepthSortPolyData>::New();
depthSort->SetInputData( fiberPolyData );
depthSort->SetCamera( renderer->GetVtkRenderer()->GetActiveCamera() );
depthSort->SetDirectionToFrontToBack();
depthSort->Update();
localStorage->m_FiberMapper->SetInputConnection(depthSort->GetOutputPort());
}
else
{
localStorage->m_FiberMapper->SetInputData(fiberPolyData);
}
localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
localStorage->m_FiberMapper->ScalarVisibilityOn();
localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
localStorage->m_FiberActor->SetMapper(localStorage->m_FiberMapper);
localStorage->m_FiberMapper->SetLookupTable(m_lut);
// set Opacity
localStorage->m_FiberActor->GetProperty()->SetOpacity((double) tmpopa);
localStorage->m_FiberActor->GetProperty()->SetLineWidth(m_LineWidth);
localStorage->m_FiberAssembly->AddPart(localStorage->m_FiberActor);
localStorage->m_LastUpdateTime.Modified();
}
-void mitk::FiberBundleXMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
+void mitk::FiberBundleMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
const DataNode* node = this->GetDataNode();
FBXLocalStorage3D* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
- mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+ mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
// did any rendering properties change?
float tubeRadius = 0;
node->GetFloatProperty("TubeRadius", tubeRadius);
if (m_TubeRadius!=tubeRadius)
{
m_TubeRadius = tubeRadius;
fiberBundle->RequestUpdate3D();
}
int tubeSides = 0;
node->GetIntProperty("TubeSides", tubeSides);
if (m_TubeSides!=tubeSides)
{
m_TubeSides = tubeSides;
fiberBundle->RequestUpdate3D();
}
int lineWidth = 0;
node->GetIntProperty("LineWidth", lineWidth);
if (m_LineWidth!=lineWidth)
{
m_LineWidth = lineWidth;
fiberBundle->RequestUpdate3D();
}
if (localStorage->m_LastUpdateTime>=fiberBundle->GetUpdateTime3D())
return;
// Calculate time step of the input data for the specified renderer (integer value)
// this method is implemented in mitkMapper
this->CalculateTimeStep( renderer );
this->InternalGenerateData(renderer);
}
-void mitk::FiberBundleXMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+void mitk::FiberBundleMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
Superclass::SetDefaultProperties(node, renderer, overwrite);
node->AddProperty( "LineWidth", mitk::IntProperty::New( true ), renderer, overwrite );
node->AddProperty( "opacity", mitk::FloatProperty::New( 1.0 ), renderer, overwrite);
node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
node->AddProperty( "pickable", mitk::BoolProperty::New( true ), renderer, overwrite);
node->AddProperty( "TubeRadius",mitk::FloatProperty::New( 0.0 ), renderer, overwrite);
node->AddProperty( "TubeSides",mitk::IntProperty::New( 15 ), renderer, overwrite);
}
-vtkProp* mitk::FiberBundleXMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
+vtkProp* mitk::FiberBundleMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
return m_LocalStorageHandler.GetLocalStorage(renderer)->m_FiberAssembly;
}
-void mitk::FiberBundleXMapper3D::UpdateVtkObjects()
+void mitk::FiberBundleMapper3D::UpdateVtkObjects()
{
}
-void mitk::FiberBundleXMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
+void mitk::FiberBundleMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
{
}
-mitk::FiberBundleXMapper3D::FBXLocalStorage3D::FBXLocalStorage3D()
+mitk::FiberBundleMapper3D::FBXLocalStorage3D::FBXLocalStorage3D()
{
m_FiberActor = vtkSmartPointer<vtkActor>::New();
m_FiberMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_FiberAssembly = vtkSmartPointer<vtkPropAssembly>::New();
}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h
similarity index 86%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h
index b583b97a98..e1ffad5bb8 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h
@@ -1,104 +1,104 @@
/*===================================================================
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 FiberBundleXMapper3D_H_HEADER_INCLUDED
-#define FiberBundleXMapper3D_H_HEADER_INCLUDED
+#ifndef FiberBundleMapper3D_H_HEADER_INCLUDED
+#define FiberBundleMapper3D_H_HEADER_INCLUDED
//#include <mitkBaseData.h> //?? necessary
#include <mitkVtkMapper.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <vtkSmartPointer.h>
#include <vtkOpenGLPolyDataMapper.h>
#include <vtkOpenGLActor.h>
#include <vtkLookupTable.h>
class vtkPropAssembly;
namespace mitk {
//##Documentation
-//## @brief Mapper for FiberBundleX
+//## @brief Mapper for FiberBundle
//## @ingroup Mapper
-class FiberBundleXMapper3D : public VtkMapper
+class FiberBundleMapper3D : public VtkMapper
{
public:
- mitkClassMacro(FiberBundleXMapper3D, VtkMapper)
+ mitkClassMacro(FiberBundleMapper3D, VtkMapper)
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
//========== essential implementation for 3D mapper ========
- const FiberBundleX* GetInput();
+ const FiberBundle* GetInput();
virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer); //looks like depricated.. should be replaced bz GetViewProp()
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper);
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
//=========================================================
class FBXLocalStorage3D : public mitk::Mapper::BaseLocalStorage
{
public:
/** \brief Point Actor of a 3D render window. */
vtkSmartPointer<vtkActor> m_FiberActor;
/** \brief Point Mapper of a 3D render window. */
vtkSmartPointer<vtkPolyDataMapper> m_FiberMapper;
vtkSmartPointer<vtkPropAssembly> m_FiberAssembly;
/** \brief Timestamp of last update of stored data. */
itk::TimeStamp m_LastUpdateTime;
/** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
FBXLocalStorage3D(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
~FBXLocalStorage3D()
{
}
};
/** \brief This member holds all three LocalStorages for the 3D render window(s). */
mitk::LocalStorageHandler<FBXLocalStorage3D> m_LocalStorageHandler;
protected:
- FiberBundleXMapper3D();
- virtual ~FiberBundleXMapper3D();
+ FiberBundleMapper3D();
+ virtual ~FiberBundleMapper3D();
void InternalGenerateData(mitk::BaseRenderer *renderer);
void UpdateVtkObjects(); //??
private:
vtkSmartPointer<vtkLookupTable> m_lut;
float m_TubeRadius;
int m_TubeSides;
int m_LineWidth;
};
} // end namespace mitk
-#endif /* FiberBundleXMapper3D_H_HEADER_INCLUDED */
+#endif /* FiberBundleMapper3D_H_HEADER_INCLUDED */
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.cpp
similarity index 68%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.cpp
index cd9b2a3725..28f7963fab 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.cpp
@@ -1,72 +1,72 @@
/*===================================================================
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 "mitkFiberBundleXSerializer.h"
-#include "mitkFiberBundleX.h"
-#include "mitkFiberBundleXWriter.h"
+#include "mitkFiberBundleSerializer.h"
+#include "mitkFiberBundle.h"
+#include "mitkFiberBundleVtkWriter.h"
#include <itksys/SystemTools.hxx>
#include <mitkIOUtil.h>
-MITK_REGISTER_SERIALIZER(FiberBundleXSerializer)
+MITK_REGISTER_SERIALIZER(FiberBundleSerializer)
-mitk::FiberBundleXSerializer::FiberBundleXSerializer()
+mitk::FiberBundleSerializer::FiberBundleSerializer()
{
}
-mitk::FiberBundleXSerializer::~FiberBundleXSerializer()
+mitk::FiberBundleSerializer::~FiberBundleSerializer()
{
}
-std::string mitk::FiberBundleXSerializer::Serialize()
+std::string mitk::FiberBundleSerializer::Serialize()
{
- const FiberBundleX* fb = dynamic_cast<const FiberBundleX*>( m_Data.GetPointer() );
+ const FiberBundle* fb = dynamic_cast<const FiberBundle*>( m_Data.GetPointer() );
if (fb == NULL)
{
MITK_ERROR << " Object at " << (const void*) this->m_Data
- << " is not an mitk::FiberBundleX. Cannot serialize as FiberBundleX.";
+ << " is not an mitk::FiberBundle. Cannot serialize as FiberBundle.";
return "";
}
std::string filename( this->GetUniqueFilenameInWorkingDirectory() );
filename += "_";
filename += m_FilenameHint;
filename += ".fib";
std::string fullname(m_WorkingDirectory);
fullname += "/";
fullname += itksys::SystemTools::ConvertToOutputPath(filename.c_str());
try
{
- mitk::IOUtil::Save(const_cast<FiberBundleX*>(fb),fullname);
+ mitk::IOUtil::Save(const_cast<FiberBundle*>(fb),fullname);
}
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/mitkFiberBundleXSerializer.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.h
similarity index 72%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.h
index 02043bd112..df9640df27 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.h
@@ -1,39 +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.
===================================================================*/
-#ifndef mitkFiberBundleXSerializer_h_included
-#define mitkFiberBundleXSerializer_h_included
+#ifndef mitkFiberBundleSerializer_h_included
+#define mitkFiberBundleSerializer_h_included
#include "mitkBaseDataSerializer.h"
namespace mitk
{
/**
\brief Serializes mitk::Surface for mitk::SceneIO
*/
-class FiberBundleXSerializer : public BaseDataSerializer
+class FiberBundleSerializer : public BaseDataSerializer
{
public:
- mitkClassMacro( FiberBundleXSerializer, BaseDataSerializer );
+ mitkClassMacro( FiberBundleSerializer, BaseDataSerializer );
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
virtual std::string Serialize();
protected:
- FiberBundleXSerializer();
- virtual ~FiberBundleXSerializer();
+ FiberBundleSerializer();
+ virtual ~FiberBundleSerializer();
};
} // namespace
#endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.cpp
new file mode 100644
index 0000000000..5e7a3712be
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.cpp
@@ -0,0 +1,86 @@
+/*===================================================================
+
+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 "mitkFiberBundleTrackVisReader.h"
+#include <itkMetaDataObject.h>
+#include <vtkPolyData.h>
+#include <vtkDataReader.h>
+#include <vtkPolyDataReader.h>
+#include <vtkMatrix4x4.h>
+#include <vtkPolyLine.h>
+#include <vtkCellArray.h>
+#include <vtkDataArray.h>
+#include <vtkFloatArray.h>
+#include <vtkCellData.h>
+#include <vtkPointData.h>
+#include <itksys/SystemTools.hxx>
+#include <tinyxml.h>
+#include <vtkCleanPolyData.h>
+#include <mitkTrackvis.h>
+#include <mitkCustomMimeType.h>
+#include "mitkDiffusionIOMimeTypes.h"
+
+
+mitk::FiberBundleTrackVisReader::FiberBundleTrackVisReader()
+ : mitk::AbstractFileReader( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE_NAME(), "TrackVis Fiber Bundle Reader" )
+{
+ m_ServiceReg = this->RegisterService();
+}
+
+mitk::FiberBundleTrackVisReader::FiberBundleTrackVisReader(const FiberBundleTrackVisReader &other)
+ :mitk::AbstractFileReader(other)
+{
+}
+
+mitk::FiberBundleTrackVisReader * mitk::FiberBundleTrackVisReader::Clone() const
+{
+ return new FiberBundleTrackVisReader(*this);
+}
+
+std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleTrackVisReader::Read()
+{
+
+ std::vector<itk::SmartPointer<mitk::BaseData> > result;
+ try
+ {
+ const std::string& locale = "C";
+ const std::string& currLocale = setlocale( LC_ALL, NULL );
+ setlocale(LC_ALL, locale.c_str());
+
+ std::string filename = this->GetInputLocation();
+
+ std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
+ ext = itksys::SystemTools::LowerCase(ext);
+
+ if (ext==".trk")
+ {
+ FiberBundle::Pointer image = FiberBundle::New();
+ TrackVisFiberReader reader;
+ reader.open(this->GetInputLocation().c_str());
+ reader.read(image.GetPointer());
+ result.push_back(image.GetPointer());
+ return result;
+ }
+
+ setlocale(LC_ALL, currLocale.c_str());
+ MITK_INFO << "Fiber bundle read";
+ }
+ catch(...)
+ {
+ throw;
+ }
+ return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.h
similarity index 67%
copy from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
copy to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.h
index 386fdad556..035e96f44e 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.h
@@ -1,52 +1,52 @@
/*===================================================================
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 __mitkFiberBundleXReader_h
-#define __mitkFiberBundleXReader_h
+#ifndef __mitkFiberBundleTrackVisReader_h
+#define __mitkFiberBundleTrackVisReader_h
#include <mitkCommon.h>
#include <mitkFileReader.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <vtkSmartPointer.h>
#include <mitkAbstractFileReader.h>
namespace mitk
{
/** \brief
*/
- class FiberBundleXReader : public AbstractFileReader
+ class FiberBundleTrackVisReader : public AbstractFileReader
{
public:
- FiberBundleXReader();
- virtual ~FiberBundleXReader(){}
- FiberBundleXReader(const FiberBundleXReader& other);
- virtual FiberBundleXReader * Clone() const;
+ FiberBundleTrackVisReader();
+ virtual ~FiberBundleTrackVisReader(){}
+ FiberBundleTrackVisReader(const FiberBundleTrackVisReader& other);
+ virtual FiberBundleTrackVisReader * Clone() const;
using mitk::AbstractFileReader::Read;
virtual std::vector<itk::SmartPointer<BaseData> > Read();
private:
us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
};
} //namespace MITK
-#endif // __mitkFiberBundleXReader_h
+#endif // __mitkFiberBundleReader_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.cpp
new file mode 100644
index 0000000000..109ffc3480
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.cpp
@@ -0,0 +1,104 @@
+/*===================================================================
+
+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 "mitkFiberBundleTrackVisWriter.h"
+#include <vtkSmartPointer.h>
+#include <vtkCleanPolyData.h>
+#include <itksys/SystemTools.hxx>
+#include <mitkTrackvis.h>
+#include <itkSize.h>
+#include <vtkFloatArray.h>
+#include <vtkCellData.h>
+#include <vtkPointData.h>
+#include <mitkAbstractFileWriter.h>
+#include <mitkCustomMimeType.h>
+#include "mitkDiffusionIOMimeTypes.h"
+
+mitk::FiberBundleTrackVisWriter::FiberBundleTrackVisWriter()
+ : mitk::AbstractFileWriter(mitk::FiberBundle::GetStaticNameOfClass(), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE_NAME(), "TrackVis Fiber Bundle Reader")
+{
+ // Options defaultOptions;
+ // this->SetDefaultOptions(defaultOptions);
+ RegisterService();
+}
+
+mitk::FiberBundleTrackVisWriter::FiberBundleTrackVisWriter(const mitk::FiberBundleTrackVisWriter & other)
+ :mitk::AbstractFileWriter(other)
+{}
+
+mitk::FiberBundleTrackVisWriter::~FiberBundleTrackVisWriter()
+{}
+
+mitk::FiberBundleTrackVisWriter * mitk::FiberBundleTrackVisWriter::Clone() const
+{
+ return new mitk::FiberBundleTrackVisWriter(*this);
+}
+
+void mitk::FiberBundleTrackVisWriter::Write()
+{
+
+ std::ostream* out;
+ std::ofstream outStream;
+
+ if( this->GetOutputStream() )
+ {
+ out = this->GetOutputStream();
+ }else{
+ outStream.open( this->GetOutputLocation().c_str() );
+ out = &outStream;
+ }
+
+ if ( !out->good() )
+ {
+ mitkThrow() << "Stream not good.";
+ }
+
+ try
+ {
+ const std::string& locale = "C";
+ const std::string& currLocale = setlocale( LC_ALL, NULL );
+ setlocale(LC_ALL, locale.c_str());
+
+ std::locale previousLocale(out->getloc());
+ std::locale I("C");
+ out->imbue(I);
+
+ std::string filename = this->GetOutputLocation().c_str();
+
+ mitk::FiberBundle::ConstPointer input = dynamic_cast<const mitk::FiberBundle*>(this->GetInput());
+ std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation().c_str());
+
+ // default extension is .fib
+ if(ext == "")
+ {
+ ext = ".trk";
+ this->SetOutputLocation(this->GetOutputLocation() + ext);
+ }
+
+ MITK_INFO << "Writing fiber bundle as TRK";
+ TrackVisFiberReader trk;
+ trk.create(filename, input.GetPointer());
+ trk.writeHdr();
+ trk.append(input.GetPointer());
+
+ setlocale(LC_ALL, currLocale.c_str());
+ MITK_INFO << "Fiber bundle written";
+ }
+ catch(...)
+ {
+ throw;
+ }
+}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.h
similarity index 82%
copy from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
copy to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.h
index e7c7194e03..576a1b86b0 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.h
@@ -1,118 +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 __mitkFiberBundleXWriter_h
-#define __mitkFiberBundleXWriter_h
+#ifndef __mitkFiberBundleTrackVisWriter_h
+#define __mitkFiberBundleTrackVisWriter_h
#include <mitkAbstractFileWriter.h>
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
#include <vtkPolyDataWriter.h>
namespace mitk
{
/**
* Writes fiber bundles to a file
* @ingroup Process
*/
-class FiberBundleXWriter : public mitk::AbstractFileWriter
+class FiberBundleTrackVisWriter : public mitk::AbstractFileWriter
{
public:
- FiberBundleXWriter();
- FiberBundleXWriter(const FiberBundleXWriter & other);
- virtual FiberBundleXWriter * Clone() const;
- virtual ~FiberBundleXWriter();
+ FiberBundleTrackVisWriter();
+ FiberBundleTrackVisWriter(const FiberBundleTrackVisWriter & other);
+ virtual FiberBundleTrackVisWriter * Clone() const;
+ virtual ~FiberBundleTrackVisWriter();
using mitk::AbstractFileWriter::Write;
virtual void Write();
static const char* XML_GEOMETRY;
static const char* XML_MATRIX_XX;
static const char* XML_MATRIX_XY;
static const char* XML_MATRIX_XZ;
static const char* XML_MATRIX_YX;
static const char* XML_MATRIX_YY;
static const char* XML_MATRIX_YZ;
static const char* XML_MATRIX_ZX;
static const char* XML_MATRIX_ZY;
static const char* XML_MATRIX_ZZ;
static const char* XML_ORIGIN_X;
static const char* XML_ORIGIN_Y;
static const char* XML_ORIGIN_Z;
static const char* XML_SPACING_X;
static const char* XML_SPACING_Y;
static const char* XML_SPACING_Z;
static const char* XML_SIZE_X;
static const char* XML_SIZE_Y;
static const char* XML_SIZE_Z;
static const char* XML_FIBER_BUNDLE;
static const char* XML_FIBER;
static const char* XML_PARTICLE;
static const char* XML_ID;
static const char* XML_POS_X;
static const char* XML_POS_Y;
static const char* XML_POS_Z;
static const char* VERSION_STRING;
static const char* XML_FIBER_BUNDLE_FILE;
static const char* XML_FILE_VERSION;
static const char* XML_NUM_FIBERS;
static const char* XML_NUM_PARTICLES;
static const char* ASCII_FILE;
static const char* FILE_NAME;
};
} // end of namespace mitk
-#endif //__mitkFiberBundleXWriter_h
+#endif //__mitkFiberBundleWriter_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.cpp
similarity index 89%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.cpp
index 025f2bbe20..cf874cb3ac 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.cpp
@@ -1,229 +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 "mitkFiberBundleXReader.h"
+#include "mitkFiberBundleVtkReader.h"
#include <itkMetaDataObject.h>
#include <vtkPolyData.h>
#include <vtkDataReader.h>
#include <vtkPolyDataReader.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkDataArray.h>
#include <vtkFloatArray.h>
#include <vtkCellData.h>
#include <vtkPointData.h>
#include <itksys/SystemTools.hxx>
#include <tinyxml.h>
#include <vtkCleanPolyData.h>
#include <mitkTrackvis.h>
#include <mitkCustomMimeType.h>
#include "mitkDiffusionIOMimeTypes.h"
-mitk::FiberBundleXReader::FiberBundleXReader()
- : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE() ), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION() )
+mitk::FiberBundleVtkReader::FiberBundleVtkReader()
+ : mitk::AbstractFileReader( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME(), "VTK Fiber Bundle Reader" )
{
m_ServiceReg = this->RegisterService();
}
-mitk::FiberBundleXReader::FiberBundleXReader(const FiberBundleXReader &other)
+mitk::FiberBundleVtkReader::FiberBundleVtkReader(const FiberBundleVtkReader &other)
:mitk::AbstractFileReader(other)
{
}
-mitk::FiberBundleXReader * mitk::FiberBundleXReader::Clone() const
+mitk::FiberBundleVtkReader * mitk::FiberBundleVtkReader::Clone() const
{
- return new FiberBundleXReader(*this);
+ return new FiberBundleVtkReader(*this);
}
-std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleXReader::Read()
+std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleVtkReader::Read()
{
std::vector<itk::SmartPointer<mitk::BaseData> > result;
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
setlocale(LC_ALL, locale.c_str());
std::string filename = this->GetInputLocation();
std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
ext = itksys::SystemTools::LowerCase(ext);
- if (ext==".trk")
- {
- FiberBundleX::Pointer image = FiberBundleX::New();
- TrackVisFiberReader reader;
- reader.open(this->GetInputLocation().c_str());
- reader.read(image.GetPointer());
- result.push_back(image.GetPointer());
- return result;
- }
-
vtkSmartPointer<vtkDataReader> chooser=vtkSmartPointer<vtkDataReader>::New();
chooser->SetFileName( this->GetInputLocation().c_str() );
if( chooser->IsFilePolyData())
{
vtkSmartPointer<vtkPolyDataReader> reader = vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName( this->GetInputLocation().c_str() );
reader->Update();
if ( reader->GetOutput() != NULL )
{
vtkSmartPointer<vtkPolyData> fiberPolyData = reader->GetOutput();
- FiberBundleX::Pointer fiberBundle = FiberBundleX::New(fiberPolyData);
+ FiberBundle::Pointer fiberBundle = FiberBundle::New(fiberPolyData);
vtkSmartPointer<vtkFloatArray> weights = vtkFloatArray::SafeDownCast(fiberPolyData->GetCellData()->GetArray("FIBER_WEIGHTS"));
if (weights!=NULL)
{
// float weight=0;
// for (int i=0; i<weights->GetSize(); i++)
// if (!mitk::Equal(weights->GetValue(i),weight,0.00001))
// {
// MITK_INFO << "Weight: " << weights->GetValue(i);
// weight = weights->GetValue(i);
// }
fiberBundle->SetFiberWeights(weights);
}
vtkSmartPointer<vtkUnsignedCharArray> fiberColors = vtkUnsignedCharArray::SafeDownCast(fiberPolyData->GetPointData()->GetArray("FIBER_COLORS"));
if (fiberColors!=NULL)
fiberBundle->SetFiberColors(fiberColors);
result.push_back(fiberBundle.GetPointer());
return result;
}
}
else // try to read deprecated fiber bundle file format
{
MITK_INFO << "Reading xml fiber bundle";
vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> cellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
TiXmlDocument doc( this->GetInputLocation().c_str() );
if(doc.LoadFile())
{
TiXmlHandle hDoc(&doc);
TiXmlElement* pElem;
TiXmlHandle hRoot(0);
pElem = hDoc.FirstChildElement().Element();
// save this for later
hRoot = TiXmlHandle(pElem);
pElem = hRoot.FirstChildElement("geometry").Element();
// read geometry
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
// read origin
mitk::Point3D origin;
double temp = 0;
pElem->Attribute("origin_x", &temp);
origin[0] = temp;
pElem->Attribute("origin_y", &temp);
origin[1] = temp;
pElem->Attribute("origin_z", &temp);
origin[2] = temp;
geometry->SetOrigin(origin);
// read spacing
ScalarType spacing[3];
pElem->Attribute("spacing_x", &temp);
spacing[0] = temp;
pElem->Attribute("spacing_y", &temp);
spacing[1] = temp;
pElem->Attribute("spacing_z", &temp);
spacing[2] = temp;
geometry->SetSpacing(spacing);
// read transform
vtkMatrix4x4* m = vtkMatrix4x4::New();
pElem->Attribute("xx", &temp);
m->SetElement(0,0,temp);
pElem->Attribute("xy", &temp);
m->SetElement(1,0,temp);
pElem->Attribute("xz", &temp);
m->SetElement(2,0,temp);
pElem->Attribute("yx", &temp);
m->SetElement(0,1,temp);
pElem->Attribute("yy", &temp);
m->SetElement(1,1,temp);
pElem->Attribute("yz", &temp);
m->SetElement(2,1,temp);
pElem->Attribute("zx", &temp);
m->SetElement(0,2,temp);
pElem->Attribute("zy", &temp);
m->SetElement(1,2,temp);
pElem->Attribute("zz", &temp);
m->SetElement(2,2,temp);
m->SetElement(0,3,origin[0]);
m->SetElement(1,3,origin[1]);
m->SetElement(2,3,origin[2]);
m->SetElement(3,3,1);
geometry->SetIndexToWorldTransformByVtkMatrix(m);
// read bounds
float bounds[] = {0, 0, 0, 0, 0, 0};
pElem->Attribute("size_x", &temp);
bounds[1] = temp;
pElem->Attribute("size_y", &temp);
bounds[3] = temp;
pElem->Attribute("size_z", &temp);
bounds[5] = temp;
geometry->SetFloatBounds(bounds);
geometry->SetImageGeometry(true);
pElem = hRoot.FirstChildElement("fiber_bundle").FirstChild().Element();
for( ; pElem ; pElem=pElem->NextSiblingElement())
{
TiXmlElement* pElem2 = pElem->FirstChildElement();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for( ; pElem2; pElem2=pElem2->NextSiblingElement())
{
Point3D point;
pElem2->Attribute("pos_x", &temp);
point[0] = temp;
pElem2->Attribute("pos_y", &temp);
point[1] = temp;
pElem2->Attribute("pos_z", &temp);
point[2] = temp;
geometry->IndexToWorld(point, point);
vtkIdType id = points->InsertNextPoint(point.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
}
cellArray->InsertNextCell(container);
}
fiberPolyData->SetPoints(points);
fiberPolyData->SetLines(cellArray);
vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
cleaner->SetInputData(fiberPolyData);
cleaner->Update();
fiberPolyData = cleaner->GetOutput();
- FiberBundleX::Pointer image = FiberBundleX::New(fiberPolyData);
+ FiberBundle::Pointer image = FiberBundle::New(fiberPolyData);
result.push_back(image.GetPointer());
return result;
}
else
{
MITK_ERROR << "could not open xml file";
throw "could not open xml file";
}
}
setlocale(LC_ALL, currLocale.c_str());
MITK_INFO << "Fiber bundle read";
}
catch(...)
{
throw;
}
return result;
}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.h
similarity index 70%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.h
index 386fdad556..3f5ec08a60 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.h
@@ -1,52 +1,52 @@
/*===================================================================
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 __mitkFiberBundleXReader_h
-#define __mitkFiberBundleXReader_h
+#ifndef __mitkFiberBundleVtkReader_h
+#define __mitkFiberBundleVtkReader_h
#include <mitkCommon.h>
#include <mitkFileReader.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <vtkSmartPointer.h>
#include <mitkAbstractFileReader.h>
namespace mitk
{
/** \brief
*/
- class FiberBundleXReader : public AbstractFileReader
+ class FiberBundleVtkReader : public AbstractFileReader
{
public:
- FiberBundleXReader();
- virtual ~FiberBundleXReader(){}
- FiberBundleXReader(const FiberBundleXReader& other);
- virtual FiberBundleXReader * Clone() const;
+ FiberBundleVtkReader();
+ virtual ~FiberBundleVtkReader(){}
+ FiberBundleVtkReader(const FiberBundleVtkReader& other);
+ virtual FiberBundleVtkReader * Clone() const;
using mitk::AbstractFileReader::Read;
virtual std::vector<itk::SmartPointer<BaseData> > Read();
private:
us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
};
} //namespace MITK
-#endif // __mitkFiberBundleXReader_h
+#endif // __mitkFiberBundleReader_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.cpp
new file mode 100644
index 0000000000..b8794229f9
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.cpp
@@ -0,0 +1,133 @@
+/*===================================================================
+
+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 "mitkFiberBundleVtkWriter.h"
+#include <vtkSmartPointer.h>
+#include <vtkCleanPolyData.h>
+#include <itksys/SystemTools.hxx>
+#include <mitkTrackvis.h>
+#include <itkSize.h>
+#include <vtkFloatArray.h>
+#include <vtkCellData.h>
+#include <vtkPointData.h>
+#include <mitkAbstractFileWriter.h>
+#include <mitkCustomMimeType.h>
+#include "mitkDiffusionIOMimeTypes.h"
+
+mitk::FiberBundleVtkWriter::FiberBundleVtkWriter()
+ : mitk::AbstractFileWriter(mitk::FiberBundle::GetStaticNameOfClass(), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME(), "VTK Fiber Bundle Reader")
+{
+ Options defaultOptions;
+ defaultOptions["Save as binary file"] = true;
+ defaultOptions["Save color information"] = true;
+ defaultOptions["Save fiber weights"] = true;
+ this->SetDefaultOptions(defaultOptions);
+ RegisterService();
+}
+
+mitk::FiberBundleVtkWriter::FiberBundleVtkWriter(const mitk::FiberBundleVtkWriter & other)
+ :mitk::AbstractFileWriter(other)
+{}
+
+mitk::FiberBundleVtkWriter::~FiberBundleVtkWriter()
+{}
+
+mitk::FiberBundleVtkWriter * mitk::FiberBundleVtkWriter::Clone() const
+{
+ return new mitk::FiberBundleVtkWriter(*this);
+}
+
+void mitk::FiberBundleVtkWriter::Write()
+{
+
+ std::ostream* out;
+ std::ofstream outStream;
+
+ if( this->GetOutputStream() )
+ {
+ out = this->GetOutputStream();
+ }else{
+ outStream.open( this->GetOutputLocation().c_str() );
+ out = &outStream;
+ }
+
+ if ( !out->good() )
+ {
+ mitkThrow() << "Stream not good.";
+ }
+
+ try
+ {
+ const std::string& locale = "C";
+ const std::string& currLocale = setlocale( LC_ALL, NULL );
+ setlocale(LC_ALL, locale.c_str());
+
+ std::locale previousLocale(out->getloc());
+ std::locale I("C");
+ out->imbue(I);
+
+ std::string filename = this->GetOutputLocation().c_str();
+
+ mitk::FiberBundle::ConstPointer input = dynamic_cast<const mitk::FiberBundle*>(this->GetInput());
+ std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation().c_str());
+ Options options = this->GetOptions();
+
+ vtkSmartPointer<vtkPolyData> fibPoly = input->GetFiberPolyData();
+ if (us::any_cast<bool>(options["Save fiber weights"]))
+ {
+ MITK_INFO << "Adding fiber weight information";
+ fibPoly->GetCellData()->AddArray(input->GetFiberWeights());
+ }
+ else if (fibPoly->GetCellData()->HasArray("FIBER_WEIGHTS"))
+ fibPoly->GetCellData()->RemoveArray("FIBER_WEIGHTS");
+ if (us::any_cast<bool>(options["Save color information"]))
+ {
+ MITK_INFO << "Adding color information";
+ fibPoly->GetPointData()->AddArray(input->GetFiberColors());
+ }
+ else if (fibPoly->GetPointData()->HasArray("FIBER_COLORS"))
+ fibPoly->GetPointData()->RemoveArray("FIBER_COLORS");
+
+ // default extension is .fib
+ if(ext == "")
+ {
+ ext = ".fib";
+ this->SetOutputLocation(this->GetOutputLocation() + ext);
+ }
+
+ vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
+ writer->SetInputData(fibPoly);
+ writer->SetFileName(filename.c_str());
+ if (us::any_cast<bool>(options["Save as binary file"]))
+ {
+ MITK_INFO << "Writing fiber bundle as vtk binary file";
+ writer->SetFileTypeToBinary();
+ }
+ else
+ {
+ MITK_INFO << "Writing fiber bundle as vtk ascii file";
+ writer->SetFileTypeToASCII();
+ }
+ writer->Write();
+
+ setlocale(LC_ALL, currLocale.c_str());
+ MITK_INFO << "Fiber bundle written";
+ }
+ catch(...)
+ {
+ throw;
+ }
+}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.h
similarity index 84%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.h
index e7c7194e03..bd44ba9d36 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.h
@@ -1,118 +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 __mitkFiberBundleXWriter_h
-#define __mitkFiberBundleXWriter_h
+#ifndef __mitkFiberBundleVtkWriter_h
+#define __mitkFiberBundleVtkWriter_h
#include <mitkAbstractFileWriter.h>
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
#include <vtkPolyDataWriter.h>
namespace mitk
{
/**
* Writes fiber bundles to a file
* @ingroup Process
*/
-class FiberBundleXWriter : public mitk::AbstractFileWriter
+class FiberBundleVtkWriter : public mitk::AbstractFileWriter
{
public:
- FiberBundleXWriter();
- FiberBundleXWriter(const FiberBundleXWriter & other);
- virtual FiberBundleXWriter * Clone() const;
- virtual ~FiberBundleXWriter();
+ FiberBundleVtkWriter();
+ FiberBundleVtkWriter(const FiberBundleVtkWriter & other);
+ virtual FiberBundleVtkWriter * Clone() const;
+ virtual ~FiberBundleVtkWriter();
using mitk::AbstractFileWriter::Write;
virtual void Write();
static const char* XML_GEOMETRY;
static const char* XML_MATRIX_XX;
static const char* XML_MATRIX_XY;
static const char* XML_MATRIX_XZ;
static const char* XML_MATRIX_YX;
static const char* XML_MATRIX_YY;
static const char* XML_MATRIX_YZ;
static const char* XML_MATRIX_ZX;
static const char* XML_MATRIX_ZY;
static const char* XML_MATRIX_ZZ;
static const char* XML_ORIGIN_X;
static const char* XML_ORIGIN_Y;
static const char* XML_ORIGIN_Z;
static const char* XML_SPACING_X;
static const char* XML_SPACING_Y;
static const char* XML_SPACING_Z;
static const char* XML_SIZE_X;
static const char* XML_SIZE_Y;
static const char* XML_SIZE_Z;
static const char* XML_FIBER_BUNDLE;
static const char* XML_FIBER;
static const char* XML_PARTICLE;
static const char* XML_ID;
static const char* XML_POS_X;
static const char* XML_POS_Y;
static const char* XML_POS_Z;
static const char* VERSION_STRING;
static const char* XML_FIBER_BUNDLE_FILE;
static const char* XML_FILE_VERSION;
static const char* XML_NUM_FIBERS;
static const char* XML_NUM_PARTICLES;
static const char* ASCII_FILE;
static const char* FILE_NAME;
};
} // end of namespace mitk
-#endif //__mitkFiberBundleXWriter_h
+#endif //__mitkFiberBundleWriter_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp
deleted file mode 100644
index 987d8f75fc..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp
+++ /dev/null
@@ -1,139 +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 "mitkFiberBundleXWriter.h"
-#include <vtkSmartPointer.h>
-#include <vtkCleanPolyData.h>
-#include <itksys/SystemTools.hxx>
-#include <mitkTrackvis.h>
-#include <itkSize.h>
-#include <vtkFloatArray.h>
-#include <vtkCellData.h>
-#include <vtkPointData.h>
-#include <mitkAbstractFileWriter.h>
-#include <mitkCustomMimeType.h>
-#include "mitkDiffusionIOMimeTypes.h"
-
-mitk::FiberBundleXWriter::FiberBundleXWriter()
- : mitk::AbstractFileWriter(mitk::FiberBundleX::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE() ), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION())
-{
- RegisterService();
-}
-
-mitk::FiberBundleXWriter::FiberBundleXWriter(const mitk::FiberBundleXWriter & other)
- :mitk::AbstractFileWriter(other)
-{}
-
-mitk::FiberBundleXWriter::~FiberBundleXWriter()
-{}
-
-mitk::FiberBundleXWriter * mitk::FiberBundleXWriter::Clone() const
-{
- return new mitk::FiberBundleXWriter(*this);
-}
-
-void mitk::FiberBundleXWriter::Write()
-{
-
- std::ostream* out;
- std::ofstream outStream;
-
- if( this->GetOutputStream() )
- {
- out = this->GetOutputStream();
- }else{
- outStream.open( this->GetOutputLocation().c_str() );
- out = &outStream;
- }
-
- if ( !out->good() )
- {
- mitkThrow() << "Stream not good.";
- }
-
- try
- {
- const std::string& locale = "C";
- const std::string& currLocale = setlocale( LC_ALL, NULL );
- setlocale(LC_ALL, locale.c_str());
-
-
- std::locale previousLocale(out->getloc());
- std::locale I("C");
- out->imbue(I);
-
- std::string filename = this->GetOutputLocation().c_str();
-
- mitk::FiberBundleX::ConstPointer input = dynamic_cast<const mitk::FiberBundleX*>(this->GetInput());
- std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation().c_str());
-
- vtkSmartPointer<vtkPolyData> fibPoly = input->GetFiberPolyData();
- fibPoly->GetCellData()->AddArray(input->GetFiberWeights());
- fibPoly->GetPointData()->AddArray(input->GetFiberColors());
-
- // default extension is .fib
- if(ext == "")
- {
- ext = ".fib";
- this->SetOutputLocation(this->GetOutputLocation() + ext);
- }
-
- if (ext==".fib" || ext==".vtk")
- {
- MITK_INFO << "Writing fiber bundle as binary VTK";
- vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
- writer->SetInputData(fibPoly);
- writer->SetFileName(filename.c_str());
- writer->SetFileTypeToBinary();
- writer->Write();
- }
- else if (ext==".afib")
- {
- itksys::SystemTools::ReplaceString(filename,".afib",".fib");
- MITK_INFO << "Writing fiber bundle as ascii VTK";
- vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
- writer->SetInputData(fibPoly);
- writer->SetFileName(filename.c_str());
- writer->SetFileTypeToASCII();
- writer->Write();
- }
- else if (ext==".avtk")
- {
- itksys::SystemTools::ReplaceString(filename,".avtk",".vtk");
- MITK_INFO << "Writing fiber bundle as ascii VTK";
- vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
- writer->SetInputData(fibPoly);
- writer->SetFileName(filename.c_str());
- writer->SetFileTypeToASCII();
- writer->Write();
- }
- else if (ext==".trk")
- {
- MITK_INFO << "Writing fiber bundle as TRK";
- TrackVisFiberReader trk;
- trk.create(filename, input.GetPointer());
- trk.writeHdr();
- trk.append(input.GetPointer());
- }
-
- setlocale(LC_ALL, currLocale.c_str());
- MITK_INFO << "Fiber bundle written";
- }
- catch(...)
- {
- throw;
- }
-}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
index cb78e2f291..a3ccbf6e60 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
@@ -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.
===================================================================*/
#include "mitkFiberTrackingObjectFactory.h"
mitk::FiberTrackingObjectFactory::FiberTrackingObjectFactory()
: CoreObjectFactoryBase()
{
}
mitk::FiberTrackingObjectFactory::~FiberTrackingObjectFactory()
{
}
mitk::Mapper::Pointer mitk::FiberTrackingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
{
mitk::Mapper::Pointer newMapper=NULL;
if ( id == mitk::BaseRenderer::Standard2D )
{
- std::string classname("FiberBundleX");
+ std::string classname("FiberBundle");
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
- newMapper = mitk::FiberBundleXMapper2D::New();
+ newMapper = mitk::FiberBundleMapper2D::New();
newMapper->SetDataNode(node);
}
}
else if ( id == mitk::BaseRenderer::Standard3D )
{
- std::string classname("FiberBundleX");
+ std::string classname("FiberBundle");
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
- newMapper = mitk::FiberBundleXMapper3D::New();
+ newMapper = mitk::FiberBundleMapper3D::New();
newMapper->SetDataNode(node);
}
}
return newMapper;
}
void mitk::FiberTrackingObjectFactory::SetDefaultProperties(mitk::DataNode* node)
{
- std::string classname("FiberBundleX");
+ std::string classname("FiberBundle");
if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
{
- mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
- mitk::FiberBundleXMapper2D::SetDefaultProperties(node);
+ mitk::FiberBundleMapper3D::SetDefaultProperties(node);
+ mitk::FiberBundleMapper2D::SetDefaultProperties(node);
}
}
const char* mitk::FiberTrackingObjectFactory::GetFileExtensions()
{
std::string fileExtension;
this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
return fileExtension.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::FiberTrackingObjectFactory::GetFileExtensionsMap()
{
return m_FileExtensionsMap;
}
const char* mitk::FiberTrackingObjectFactory::GetSaveFileExtensions()
{
std::string fileExtension;
this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
return fileExtension.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::FiberTrackingObjectFactory::GetSaveFileExtensionsMap()
{
return m_SaveFileExtensionsMap;
}
void mitk::FiberTrackingObjectFactory::CreateFileExtensionsMap()
{
}
void mitk::FiberTrackingObjectFactory::RegisterIOFactories()
{
}
struct RegisterFiberTrackingObjectFactory{
RegisterFiberTrackingObjectFactory()
: m_Factory( mitk::FiberTrackingObjectFactory::New() )
{
mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
}
~RegisterFiberTrackingObjectFactory()
{
mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
}
mitk::FiberTrackingObjectFactory::Pointer m_Factory;
};
static RegisterFiberTrackingObjectFactory registerFiberTrackingObjectFactory;
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
index b26f470e1b..0c0806e8c2 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
@@ -1,70 +1,70 @@
/*===================================================================
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 MITKFIBERTRACKINGOBJECTFACTORY_H
#define MITKFIBERTRACKINGOBJECTFACTORY_H
#include "mitkCoreObjectFactory.h"
//modernized fiberbundle datastrucutre
-#include "mitkFiberBundleX.h"
-#include "mitkFiberBundleXMapper3D.h"
-#include "mitkFiberBundleXMapper2D.h"
+#include "mitkFiberBundle.h"
+#include "mitkFiberBundleMapper3D.h"
+#include "mitkFiberBundleMapper2D.h"
-//#include "mitkFiberBundleXThreadMonitorMapper3D.h"
-//#include "mitkFiberBundleXThreadMonitor.h"
+//#include "mitkFiberBundleThreadMonitorMapper3D.h"
+//#include "mitkFiberBundleThreadMonitor.h"
namespace mitk {
class FiberTrackingObjectFactory : public CoreObjectFactoryBase
{
public:
mitkClassMacro(FiberTrackingObjectFactory,CoreObjectFactoryBase)
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
~FiberTrackingObjectFactory();
virtual Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId);
virtual void SetDefaultProperties(mitk::DataNode* node);
virtual const char* GetFileExtensions();
virtual mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap();
virtual const char* GetSaveFileExtensions();
virtual mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap();
void RegisterIOFactories();
protected:
FiberTrackingObjectFactory();
private:
void CreateFileExtensionsMap();
std::string m_ExternalFileExtensions;
std::string m_InternalFileExtensions;
std::string m_SaveFileExtensions;
MultimapType m_FileExtensionsMap;
MultimapType m_SaveFileExtensionsMap;
};
}
#endif // MITKFIBERTRACKINGOBJECTFACTORY_H
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h
index a54a2cb1b9..47f590315a 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h
@@ -1,108 +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.
===================================================================*/
/*===================================================================
This file is based heavily on a corresponding ITK filter.
===================================================================*/
#ifndef __itkEvaluateTractogramDirectionsFilter_h_
#define __itkEvaluateTractogramDirectionsFilter_h_
#include <itkProcessObject.h>
#include <itkVectorContainer.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkImageSource.h>
namespace itk{
/** \brief Calculates the voxel-wise angular error of the input tractogram to a set of voxel-wise directions.
*/
template< class PixelType >
class EvaluateTractogramDirectionsFilter : public ImageSource< Image< PixelType, 3 > >
{
public:
typedef EvaluateTractogramDirectionsFilter Self;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef ImageSource< Image< PixelType, 3 > > Superclass;
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
typedef typename Superclass::OutputImageType OutputImageType;
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Runtime information support. */
itkTypeMacro(EvaluateTractogramDirectionsFilter, ImageToImageFilter)
- typedef mitk::FiberBundleX FiberBundleType;
+ typedef mitk::FiberBundle FiberBundleType;
typedef Vector< float, 3 > DirectionType;
typedef Image< DirectionType, 3 > DirectionImageType;
typedef VectorContainer< int, DirectionImageType::Pointer > DirectionImageContainerType;
typedef Image< float, 3 > FloatImageType;
typedef Image< bool, 3 > BoolImageType;
typedef Image< unsigned char, 3 > UCharImageType;
typedef Image< double, 3 > DoubleImageType;
itkSetMacro( Tractogram, FiberBundleType::Pointer) ///< Input tractogram
itkSetMacro( ReferenceImageSet , DirectionImageContainerType::Pointer) ///< Input images containing one reference direction per voxel.
itkSetMacro( MaskImage , UCharImageType::Pointer) ///< Calculation is only performed inside of the mask image.
itkSetMacro( IgnoreMissingDirections , bool) ///< If in one voxel, the number of directions differs between the input tractogram and the reference, the excess directions are ignored. Otherwise, the error to the next closest direction is calculated.
itkSetMacro( UseInterpolation , bool) ///< Use trilinear interpolation.
/** Output statistics. */
itkGetMacro( MeanAngularError, float)
itkGetMacro( MinAngularError, float)
itkGetMacro( MaxAngularError, float)
itkGetMacro( VarAngularError, float)
itkGetMacro( MedianAngularError, float)
protected:
EvaluateTractogramDirectionsFilter();
~EvaluateTractogramDirectionsFilter() {}
void GenerateData();
itk::Point<PixelType, 3> GetItkPoint(double point[3]);
itk::Vector<PixelType, 3> GetItkVector(double point[3]);
vnl_vector_fixed<PixelType, 3> GetVnlVector(double point[3]);
vnl_vector_fixed<PixelType, 3> GetVnlVector(Vector< PixelType, 3 >& vector);
UCharImageType::Pointer m_MaskImage;
DirectionImageContainerType::Pointer m_ReferenceImageSet;
bool m_IgnoreMissingDirections;
double m_MeanAngularError;
double m_MedianAngularError;
double m_MaxAngularError;
double m_MinAngularError;
double m_VarAngularError;
std::vector< double > m_AngularErrorVector;
double m_Eps;
FiberBundleType::Pointer m_Tractogram;
bool m_UseInterpolation;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkEvaluateTractogramDirectionsFilter.cpp"
#endif
#endif //__itkEvaluateTractogramDirectionsFilter_h_
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp
index 883473377c..81ebca3171 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp
@@ -1,147 +1,147 @@
/*===================================================================
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 "itkFiberCurvatureFilter.h"
#define _USE_MATH_DEFINES
#include <math.h>
#include <vtkDoubleArray.h>
#include <vtkPointData.h>
#include <boost/progress.hpp>
namespace itk{
FiberCurvatureFilter::FiberCurvatureFilter()
: m_AngularDeviation(20)
, m_Distance(1.0)
, m_RemoveFibers(false)
{
}
FiberCurvatureFilter::~FiberCurvatureFilter()
{
}
void FiberCurvatureFilter::GenerateData()
{
vtkSmartPointer<vtkPolyData> inputPoly = m_InputFiberBundle->GetFiberPolyData();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
MITK_INFO << "Applying curvature threshold";
boost::progress_display disp(inputPoly->GetNumberOfCells());
for (int i=0; i<inputPoly->GetNumberOfCells(); i++)
{
++disp;
vtkCell* cell = inputPoly->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
// calculate curvatures
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double dist = 0;
int c = j;
std::vector< vnl_vector_fixed< float, 3 > > vectors;
vnl_vector_fixed< float, 3 > meanV;
while(dist<m_Distance/2 && c>1)
{
double p1[3];
points->GetPoint(c-1, p1);
double p2[3];
points->GetPoint(c, p2);
vnl_vector_fixed< float, 3 > v;
v[0] = p2[0]-p1[0];
v[1] = p2[1]-p1[1];
v[2] = p2[2]-p1[2];
dist += v.magnitude();
v.normalize();
vectors.push_back(v);
meanV += v;
c--;
}
c = j;
dist = 0;
while(dist<m_Distance/2 && c<numPoints-1)
{
double p1[3];
points->GetPoint(c, p1);
double p2[3];
points->GetPoint(c+1, p2);
vnl_vector_fixed< float, 3 > v;
v[0] = p2[0]-p1[0];
v[1] = p2[1]-p1[1];
v[2] = p2[2]-p1[2];
dist += v.magnitude();
v.normalize();
vectors.push_back(v);
meanV += v;
c++;
}
meanV.normalize();
double dev = 0;
for (int c=0; c<vectors.size(); c++)
{
double angle = dot_product(meanV, vectors.at(c));
if (angle>1.0)
angle = 1.0;
if (angle<0.0)
angle = 0.0;
dev += acos(angle)*180/M_PI;
}
if (vectors.size()>0)
dev /= vectors.size();
if (dev<m_AngularDeviation)
{
double p[3];
points->GetPoint(j, p);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
else
{
if (m_RemoveFibers)
{
container = vtkSmartPointer<vtkPolyLine>::New();
break;
}
if (container->GetNumberOfPoints()>0)
vtkNewCells->InsertNextCell(container);
container = vtkSmartPointer<vtkPolyLine>::New();
}
}
if (container->GetNumberOfPoints()>0)
vtkNewCells->InsertNextCell(container);
}
vtkSmartPointer<vtkPolyData> outputPoly = vtkSmartPointer<vtkPolyData>::New();
outputPoly->SetPoints(vtkNewPoints);
outputPoly->SetLines(vtkNewCells);
- m_OutputFiberBundle = FiberBundleX::New(outputPoly);
+ m_OutputFiberBundle = FiberBundle::New(outputPoly);
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h
index 3230a2675b..eeeb588d60 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h
@@ -1,83 +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.
===================================================================*/
#ifndef itkFiberCurvatureFilter_h
#define itkFiberCurvatureFilter_h
// MITK
#include <mitkPlanarEllipse.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkFiberfoxParameters.h>
// ITK
#include <itkProcessObject.h>
// VTK
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
using namespace std;
namespace itk{
/**
* \brief Generates artificial fibers distributed in and interpolated between the input planar figures. */
class FiberCurvatureFilter : public ProcessObject
{
public:
typedef FiberCurvatureFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkTypeMacro( FiberCurvatureFilter, ProcessObject )
virtual void Update(){
this->GenerateData();
}
itkSetMacro( Distance, double )
itkSetMacro( AngularDeviation, double )
itkSetMacro( RemoveFibers, bool )
- itkSetMacro( InputFiberBundle, FiberBundleX::Pointer )
- itkGetMacro( OutputFiberBundle, FiberBundleX::Pointer )
+ itkSetMacro( InputFiberBundle, FiberBundle::Pointer )
+ itkGetMacro( OutputFiberBundle, FiberBundle::Pointer )
protected:
void GenerateData();
FiberCurvatureFilter();
virtual ~FiberCurvatureFilter();
- FiberBundleX::Pointer m_InputFiberBundle;
- FiberBundleX::Pointer m_OutputFiberBundle;
+ FiberBundle::Pointer m_InputFiberBundle;
+ FiberBundle::Pointer m_OutputFiberBundle;
double m_AngularDeviation;
double m_Distance;
bool m_RemoveFibers;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFiberCurvatureFilter.cpp"
#endif
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp
index 41eaac38e2..6d2506664a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp
@@ -1,241 +1,241 @@
/*===================================================================
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 "itkFibersFromPlanarFiguresFilter.h"
#define _USE_MATH_DEFINES
#include <math.h>
// MITK
#include <itkOrientationDistributionFunction.h>
#include <itkDiffusionQballGeneralizedFaImageFilter.h>
#include <mitkStandardFileLocations.h>
#include <mitkFiberBuilder.h>
#include <mitkMetropolisHastingsSampler.h>
#include <itkTensorImageToQBallImageFilter.h>
#include <mitkGibbsEnergyComputer.h>
#include <mitkRotationOperation.h>
#include <mitkInteractionConst.h>
// ITK
#include <itkImageDuplicator.h>
#include <itkResampleImageFilter.h>
#include <itkTimeProbe.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
// MISC
#include <math.h>
namespace itk{
FibersFromPlanarFiguresFilter::FibersFromPlanarFiguresFilter()
{
}
FibersFromPlanarFiguresFilter::~FibersFromPlanarFiguresFilter()
{
}
void FibersFromPlanarFiguresFilter::GeneratePoints()
{
Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
randGen->SetSeed((unsigned int)0);
m_2DPoints.clear();
int count = 0;
while (count < m_Parameters.m_Density)
{
mitk::Vector2D p;
switch (m_Parameters.m_Distribution) {
case FiberGenerationParameters::DISTRIBUTE_GAUSSIAN:
p[0] = randGen->GetNormalVariate(0, m_Parameters.m_Variance);
p[1] = randGen->GetNormalVariate(0, m_Parameters.m_Variance);
break;
default:
p[0] = randGen->GetUniformVariate(-1, 1);
p[1] = randGen->GetUniformVariate(-1, 1);
}
if (sqrt(p[0]*p[0]+p[1]*p[1]) <= 1)
{
m_2DPoints.push_back(p);
count++;
}
}
}
void FibersFromPlanarFiguresFilter::GenerateData()
{
// check if enough fiducials are available
for (unsigned int i=0; i<m_Parameters.m_Fiducials.size(); i++)
if (m_Parameters.m_Fiducials.at(i).size()<2)
itkExceptionMacro("At least 2 fiducials needed per fiber bundle!");
for (unsigned int i=0; i<m_Parameters.m_Fiducials.size(); i++)
{
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
vector< mitk::PlanarEllipse::Pointer > bundle = m_Parameters.m_Fiducials.at(i);
vector< unsigned int > fliplist;
if (i<m_Parameters.m_FlipList.size())
fliplist = m_Parameters.m_FlipList.at(i);
else
fliplist.resize(bundle.size(), 0);
if (fliplist.size()<bundle.size())
fliplist.resize(bundle.size(), 0);
GeneratePoints();
for (int j=0; j<m_Parameters.m_Density; j++)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
mitk::PlanarEllipse::Pointer figure = bundle.at(0);
mitk::Point2D p0 = figure->GetControlPoint(0);
mitk::Point2D p1 = figure->GetControlPoint(1);
mitk::Point2D p2 = figure->GetControlPoint(2);
mitk::Point2D p3 = figure->GetControlPoint(3);
double r1 = p0.EuclideanDistanceTo(p1);
double r2 = p0.EuclideanDistanceTo(p2);
mitk::Vector2D eDir = p1-p0; eDir.Normalize();
mitk::Vector2D tDir = p3-p0; tDir.Normalize();
// apply twist
vnl_matrix_fixed<double, 2, 2> tRot;
tRot[0][0] = tDir[0];
tRot[1][1] = tRot[0][0];
tRot[1][0] = sin(acos(tRot[0][0]));
tRot[0][1] = -tRot[1][0];
if (tDir[1]<0)
tRot.inplace_transpose();
m_2DPoints[j].SetVnlVector(tRot*m_2DPoints[j].GetVnlVector());
// apply new ellipse shape
vnl_vector_fixed< double, 2 > newP;
newP[0] = m_2DPoints.at(j)[0];
newP[1] = m_2DPoints.at(j)[1];
double alpha = acos(eDir[0]);
if (eDir[1]>0)
alpha = 2*M_PI-alpha;
vnl_matrix_fixed<double, 2, 2> eRot;
eRot[0][0] = cos(alpha);
eRot[1][1] = eRot[0][0];
eRot[1][0] = sin(alpha);
eRot[0][1] = -eRot[1][0];
newP = eRot*newP;
newP[0] *= r1;
newP[1] *= r2;
newP = eRot.transpose()*newP;
p0[0] += newP[0];
p0[1] += newP[1];
const mitk::PlaneGeometry* planeGeo = figure->GetPlaneGeometry();
mitk::Point3D w, wc;
planeGeo->Map(p0, w);
wc = figure->GetWorldControlPoint(0);
vtkIdType id = m_VtkPoints->InsertNextPoint(w.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
vnl_vector_fixed< double, 3 > n = planeGeo->GetNormalVnl();
for (unsigned int k=1; k<bundle.size(); k++)
{
figure = bundle.at(k);
p0 = figure->GetControlPoint(0);
p1 = figure->GetControlPoint(1);
p2 = figure->GetControlPoint(2);
p3 = figure->GetControlPoint(3);
r1 = p0.EuclideanDistanceTo(p1);
r2 = p0.EuclideanDistanceTo(p2);
eDir = p1-p0; eDir.Normalize();
mitk::Vector2D tDir2 = p3-p0; tDir2.Normalize();
mitk::Vector2D temp; temp.SetVnlVector(tRot.transpose() * tDir2.GetVnlVector());
// apply twist
tRot[0][0] = tDir[0]*tDir2[0] + tDir[1]*tDir2[1];
tRot[1][1] = tRot[0][0];
tRot[1][0] = sin(acos(tRot[0][0]));
tRot[0][1] = -tRot[1][0];
if (temp[1]<0)
tRot.inplace_transpose();
m_2DPoints[j].SetVnlVector(tRot*m_2DPoints[j].GetVnlVector());
tDir = tDir2;
// apply new ellipse shape
newP[0] = m_2DPoints.at(j)[0];
newP[1] = m_2DPoints.at(j)[1];
// calculate normal
mitk::PlaneGeometry* planeGeo = const_cast<mitk::PlaneGeometry*>(figure->GetPlaneGeometry());
mitk::Vector3D perp = wc-planeGeo->ProjectPointOntoPlane(wc); perp.Normalize();
vnl_vector_fixed< double, 3 > n2 = planeGeo->GetNormalVnl();
wc = figure->GetWorldControlPoint(0);
// is flip needed?
if (dot_product(perp.GetVnlVector(),n2)>0 && dot_product(n,n2)<=0.00001)
newP[0] *= -1;
if (fliplist.at(k)>0)
newP[0] *= -1;
n = n2;
alpha = acos(eDir[0]);
if (eDir[1]>0)
alpha = 2*M_PI-alpha;
eRot[0][0] = cos(alpha);
eRot[1][1] = eRot[0][0];
eRot[1][0] = sin(alpha);
eRot[0][1] = -eRot[1][0];
newP = eRot*newP;
newP[0] *= r1;
newP[1] *= r2;
newP = eRot.transpose()*newP;
p0[0] += newP[0];
p0[1] += newP[1];
mitk::Point3D w;
planeGeo->Map(p0, w);
vtkIdType id = m_VtkPoints->InsertNextPoint(w.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
}
m_VtkCellArray->InsertNextCell(container);
}
vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
fiberPolyData->SetPoints(m_VtkPoints);
fiberPolyData->SetLines(m_VtkCellArray);
- mitk::FiberBundleX::Pointer mitkFiberBundle = mitk::FiberBundleX::New(fiberPolyData);
+ mitk::FiberBundle::Pointer mitkFiberBundle = mitk::FiberBundle::New(fiberPolyData);
mitkFiberBundle->ResampleSpline(m_Parameters.m_Sampling, m_Parameters.m_Tension, m_Parameters.m_Continuity, m_Parameters.m_Bias);
m_FiberBundles.push_back(mitkFiberBundle);
}
}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h
index f7e9451f76..3e6c0c0809 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h
@@ -1,87 +1,87 @@
/*===================================================================
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 itkFibersFromPlanarFiguresFilter_h
#define itkFibersFromPlanarFiguresFilter_h
// MITK
#include <mitkPlanarEllipse.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkFiberfoxParameters.h>
// ITK
#include <itkProcessObject.h>
// VTK
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
using namespace std;
namespace itk{
/**
* \brief Generates artificial fibers distributed in and interpolated between the input planar figures. */
class FibersFromPlanarFiguresFilter : public ProcessObject
{
public:
typedef FibersFromPlanarFiguresFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
- typedef mitk::FiberBundleX::Pointer FiberType;
- typedef vector< mitk::FiberBundleX::Pointer > FiberContainerType;
+ typedef mitk::FiberBundle::Pointer FiberType;
+ typedef vector< mitk::FiberBundle::Pointer > FiberContainerType;
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkTypeMacro( FibersFromPlanarFiguresFilter, ProcessObject )
virtual void Update(){
this->GenerateData();
}
// input
void SetParameters( FiberGenerationParameters param ) ///< Simulation parameters.
{
m_Parameters = param;
}
// output
FiberContainerType GetFiberBundles(){ return m_FiberBundles; }
protected:
void GenerateData();
FibersFromPlanarFiguresFilter();
virtual ~FibersFromPlanarFiguresFilter();
void GeneratePoints();
FiberContainerType m_FiberBundles; ///< container for the output fiber bundles
vector< mitk::Vector2D > m_2DPoints; ///< container for the 2D fiber waypoints
FiberGenerationParameters m_Parameters;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFibersFromPlanarFiguresFilter.cpp"
#endif
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
index b0e3724eed..fc9c23714e 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
@@ -1,87 +1,87 @@
/*===================================================================
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 __itkTractDensityImageFilter_h__
#define __itkTractDensityImageFilter_h__
#include <itkImageSource.h>
#include <itkImage.h>
#include <itkVectorContainer.h>
#include <itkRGBAPixel.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
namespace itk{
/**
* \brief Generates tract density images from input fiberbundles (Calamante 2010). */
template< class OutputImageType >
class TractDensityImageFilter : public ImageSource< OutputImageType >
{
public:
typedef TractDensityImageFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef typename OutputImageType::PixelType OutPixelType;
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkTypeMacro( TractDensityImageFilter, ImageSource )
itkSetMacro( UpsamplingFactor, float) ///< use higher resolution for ouput image
itkGetMacro( UpsamplingFactor, float) ///< use higher resolution for ouput image
itkSetMacro( InvertImage, bool) ///< voxelvalue = 1-voxelvalue
itkGetMacro( InvertImage, bool) ///< voxelvalue = 1-voxelvalue
itkSetMacro( BinaryOutput, bool) ///< generate binary fiber envelope
itkGetMacro( BinaryOutput, bool) ///< generate binary fiber envelope
itkSetMacro( OutputAbsoluteValues, bool) ///< output absolute values of the number of fibers per voxel
itkGetMacro( OutputAbsoluteValues, bool) ///< output absolute values of the number of fibers per voxel
itkSetMacro( UseImageGeometry, bool) ///< use input image geometry to initialize output image
itkGetMacro( UseImageGeometry, bool) ///< use input image geometry to initialize output image
- itkSetMacro( FiberBundle, mitk::FiberBundleX::Pointer) ///< input fiber bundle
+ itkSetMacro( FiberBundle, mitk::FiberBundle::Pointer) ///< input fiber bundle
itkSetMacro( InputImage, typename OutputImageType::Pointer) ///< use input image geometry to initialize output image
itkSetMacro( UseTrilinearInterpolation, bool )
itkSetMacro( DoFiberResampling, bool )
void GenerateData();
protected:
itk::Point<float, 3> GetItkPoint(double point[3]);
TractDensityImageFilter();
virtual ~TractDensityImageFilter();
typename OutputImageType::Pointer m_InputImage; ///< use input image geometry to initialize output image
- mitk::FiberBundleX::Pointer m_FiberBundle; ///< input fiber bundle
+ mitk::FiberBundle::Pointer m_FiberBundle; ///< input fiber bundle
float m_UpsamplingFactor; ///< use higher resolution for ouput image
bool m_InvertImage; ///< voxelvalue = 1-voxelvalue
bool m_BinaryOutput; ///< generate binary fiber envelope
bool m_UseImageGeometry; ///< use input image geometry to initialize output image
bool m_OutputAbsoluteValues; ///< do not normalize image values to 0-1
bool m_UseTrilinearInterpolation;
bool m_DoFiberResampling;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTractDensityImageFilter.cpp"
#endif
#endif // __itkTractDensityImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
index c284489d44..ee42dfddc7 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,131 +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 <mitkFiberBundle.h>
#include <itkVnlForwardFFTImageFilter.h>
#include <itkVectorImage.h>
#include <cmath>
#include <mitkFiberfoxParameters.h>
#include <itkTimeProbe.h>
#include <mitkRawShModel.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 mitk::FiberBundle::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/Algorithms/itkTractsToFiberEndingsImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.h
index 74cf06930d..4687fb80fa 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.h
@@ -1,86 +1,86 @@
/*===================================================================
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 __itkTractsToFiberEndingsImageFilter_h__
#define __itkTractsToFiberEndingsImageFilter_h__
#include <itkImageSource.h>
#include <itkImage.h>
#include <itkVectorContainer.h>
#include <itkRGBAPixel.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
namespace itk{
/**
* \brief Generates image where the pixel values are set according to the number of fibers ending in the voxel. */
template< class OutputImageType >
class TractsToFiberEndingsImageFilter : public ImageSource< OutputImageType >
{
public:
typedef TractsToFiberEndingsImageFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef typename OutputImageType::PixelType OutPixelType;
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkTypeMacro( TractsToFiberEndingsImageFilter, ImageSource )
/** Upsampling factor **/
itkSetMacro( UpsamplingFactor, float)
itkGetMacro( UpsamplingFactor, float)
/** Invert Image **/
itkSetMacro( InvertImage, bool)
itkGetMacro( InvertImage, bool)
- itkSetMacro( FiberBundle, mitk::FiberBundleX::Pointer)
+ itkSetMacro( FiberBundle, mitk::FiberBundle::Pointer)
itkSetMacro( InputImage, typename OutputImageType::Pointer)
/** Use input image geometry to initialize output image **/
itkSetMacro( UseImageGeometry, bool)
itkGetMacro( UseImageGeometry, bool)
itkSetMacro( BinaryOutput, bool)
void GenerateData();
protected:
itk::Point<float, 3> GetItkPoint(double point[3]);
TractsToFiberEndingsImageFilter();
virtual ~TractsToFiberEndingsImageFilter();
- mitk::FiberBundleX::Pointer m_FiberBundle; ///< input fiber bundle
+ mitk::FiberBundle::Pointer m_FiberBundle; ///< input fiber bundle
float m_UpsamplingFactor; ///< use higher resolution for ouput image
bool m_InvertImage; ///< voxelvalue = 1-voxelvalue
bool m_UseImageGeometry; ///< output image is given other geometry than fiberbundle (input image geometry)
bool m_BinaryOutput;
typename OutputImageType::Pointer m_InputImage;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTractsToFiberEndingsImageFilter.cpp"
#endif
#endif // __itkTractsToFiberEndingsImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.h
index 9571a150e1..29a3aa3393 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.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.
===================================================================*/
#ifndef __itkTractsToRgbaImageFilter_h__
#define __itkTractsToRgbaImageFilter_h__
#include <itkImageSource.h>
#include <itkImage.h>
#include <itkVectorContainer.h>
#include <itkRGBAPixel.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
namespace itk{
/**
* \brief Generates RGBA image from the input fibers where color values are set according to the local fiber directions. */
template< class OutputImageType >
class TractsToRgbaImageFilter : public ImageSource< OutputImageType >
{
public:
typedef TractsToRgbaImageFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef typename OutputImageType::PixelType OutPixelType;
typedef itk::Image<unsigned char, 3> InputImageType;
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkTypeMacro( TractsToRgbaImageFilter, ImageSource )
/** Upsampling factor **/
itkSetMacro( UpsamplingFactor, float)
itkGetMacro( UpsamplingFactor, float)
- itkSetMacro( FiberBundle, mitk::FiberBundleX::Pointer)
+ itkSetMacro( FiberBundle, mitk::FiberBundle::Pointer)
itkSetMacro( InputImage, typename InputImageType::Pointer)
/** Use input image geometry to initialize output image **/
itkSetMacro( UseImageGeometry, bool)
itkGetMacro( UseImageGeometry, bool)
void GenerateData();
protected:
itk::Point<float, 3> GetItkPoint(double point[3]);
TractsToRgbaImageFilter();
virtual ~TractsToRgbaImageFilter();
- mitk::FiberBundleX::Pointer m_FiberBundle; ///< input fiber bundle
+ mitk::FiberBundle::Pointer m_FiberBundle; ///< input fiber bundle
float m_UpsamplingFactor; ///< use higher resolution for ouput image
bool m_UseImageGeometry; ///< output image is given other geometry than fiberbundle (input image geometry)
typename InputImageType::Pointer m_InputImage;
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTractsToRgbaImageFilter.cpp"
#endif
#endif // __itkTractsToRgbaImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
index ad60351fb8..4d434011cb 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
@@ -1,565 +1,565 @@
#include "itkTractsToVectorImageFilter.h"
// VTK
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
// ITK
#include <itkTimeProbe.h>
#include <itkImageRegionIterator.h>
// misc
#define _USE_MATH_DEFINES
#include <math.h>
#include <boost/progress.hpp>
namespace itk{
static bool CompareVectorLengths(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
{
return (v1.magnitude()>v2.magnitude());
}
template< class PixelType >
TractsToVectorImageFilter< PixelType >::TractsToVectorImageFilter():
m_AngularThreshold(0.7),
m_Epsilon(0.999),
m_MaskImage(NULL),
m_NormalizeVectors(false),
m_UseWorkingCopy(true),
m_MaxNumDirections(3),
m_SizeThreshold(0.3),
m_NumDirectionsImage(NULL),
m_CreateDirectionImages(true)
{
this->SetNumberOfRequiredOutputs(1);
}
template< class PixelType >
TractsToVectorImageFilter< PixelType >::~TractsToVectorImageFilter()
{
}
template< class PixelType >
vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::GetVnlVector(double point[])
{
vnl_vector_fixed<double, 3> vnlVector;
vnlVector[0] = point[0];
vnlVector[1] = point[1];
vnlVector[2] = point[2];
return vnlVector;
}
template< class PixelType >
itk::Point<double, 3> TractsToVectorImageFilter< PixelType >::GetItkPoint(double point[])
{
itk::Point<double, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
template< class PixelType >
void TractsToVectorImageFilter< PixelType >::GenerateData()
{
mitk::BaseGeometry::Pointer geometry = m_FiberBundle->GetGeometry();
// calculate new image parameters
itk::Vector<double> spacing;
itk::Point<double> origin;
itk::Matrix<double, 3, 3> direction;
ImageRegion<3> imageRegion;
if (!m_MaskImage.IsNull())
{
spacing = m_MaskImage->GetSpacing();
imageRegion = m_MaskImage->GetLargestPossibleRegion();
origin = m_MaskImage->GetOrigin();
direction = m_MaskImage->GetDirection();
}
else
{
spacing = geometry->GetSpacing();
origin = geometry->GetOrigin();
mitk::BaseGeometry::BoundsArrayType bounds = geometry->GetBounds();
origin[0] += bounds.GetElement(0);
origin[1] += bounds.GetElement(2);
origin[2] += bounds.GetElement(4);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
direction[j][i] = geometry->GetMatrixColumn(i)[j];
imageRegion.SetSize(0, geometry->GetExtent(0));
imageRegion.SetSize(1, geometry->GetExtent(1));
imageRegion.SetSize(2, geometry->GetExtent(2));
m_MaskImage = ItkUcharImgType::New();
m_MaskImage->SetSpacing( spacing );
m_MaskImage->SetOrigin( origin );
m_MaskImage->SetDirection( direction );
m_MaskImage->SetRegions( imageRegion );
m_MaskImage->Allocate();
m_MaskImage->FillBuffer(1);
}
OutputImageType::RegionType::SizeType outImageSize = imageRegion.GetSize();
m_OutImageSpacing = m_MaskImage->GetSpacing();
m_ClusteredDirectionsContainer = ContainerType::New();
// initialize num directions image
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( spacing );
m_NumDirectionsImage->SetOrigin( origin );
m_NumDirectionsImage->SetDirection( direction );
m_NumDirectionsImage->SetRegions( imageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
// initialize direction images
m_DirectionImageContainer = DirectionImageContainerType::New();
// resample fiber bundle
double minSpacing = 1;
if(m_OutImageSpacing[0]<m_OutImageSpacing[1] && m_OutImageSpacing[0]<m_OutImageSpacing[2])
minSpacing = m_OutImageSpacing[0];
else if (m_OutImageSpacing[1] < m_OutImageSpacing[2])
minSpacing = m_OutImageSpacing[1];
else
minSpacing = m_OutImageSpacing[2];
if (m_UseWorkingCopy)
m_FiberBundle = m_FiberBundle->GetDeepCopy();
// resample fiber bundle for sufficient voxel coverage
m_FiberBundle->ResampleSpline(minSpacing/10);
// iterate over all fibers
vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
int numFibers = m_FiberBundle->GetNumFibers();
m_DirectionsContainer = ContainerType::New();
MITK_INFO << "Generating directions from tractogram";
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
++disp;
vtkCell* cell = fiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
if (numPoints<2)
continue;
vnl_vector_fixed<double, 3> dir;
itk::Point<double, 3> worldPos;
vnl_vector<double> v;
for( int j=0; j<numPoints-1; j++)
{
// get current position along fiber in world coordinates
double* temp = points->GetPoint(j);
worldPos = GetItkPoint(temp);
itk::Index<3> index;
m_MaskImage->TransformPhysicalPointToIndex(worldPos, index);
if (!m_MaskImage->GetLargestPossibleRegion().IsInside(index) || m_MaskImage->GetPixel(index)==0)
continue;
// get fiber tangent direction at this position
v = GetVnlVector(temp);
dir = GetVnlVector(points->GetPoint(j+1))-v;
if (dir.is_zero())
continue;
dir.normalize();
// add direction to container
unsigned int idx = index[0] + outImageSize[0]*(index[1] + outImageSize[1]*index[2]);
DirectionContainerType::Pointer dirCont;
if (m_DirectionsContainer->IndexExists(idx))
{
dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull())
{
dirCont = DirectionContainerType::New();
dirCont->push_back(dir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
else
dirCont->push_back(dir);
}
else
{
dirCont = DirectionContainerType::New();
dirCont->push_back(dir);
m_DirectionsContainer->InsertElement(idx, dirCont);
}
}
}
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
MITK_INFO << "Clustering directions";
boost::progress_display disp2(outImageSize[0]*outImageSize[1]*outImageSize[2]);
while(!dirIt.IsAtEnd())
{
++disp2;
OutputImageType::IndexType index = dirIt.GetIndex();
int idx = index[0]+(index[1]+index[2]*outImageSize[1])*outImageSize[0];
if (!m_DirectionsContainer->IndexExists(idx))
{
++dirIt;
continue;
}
DirectionContainerType::Pointer dirCont = m_DirectionsContainer->GetElement(idx);
if (dirCont.IsNull() || dirCont->empty())
{
++dirIt;
continue;
}
std::vector< double > lengths; lengths.resize(dirCont->size(), 1); // all peaks have size 1
DirectionContainerType::Pointer directions;
if (m_MaxNumDirections>0)
{
directions = FastClustering(dirCont, lengths);
std::sort( directions->begin(), directions->end(), CompareVectorLengths );
}
else
directions = dirCont;
unsigned int numDir = directions->size();
if (m_MaxNumDirections>0 && numDir>m_MaxNumDirections)
numDir = m_MaxNumDirections;
int count = 0;
for (unsigned int i=0; i<numDir; i++)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
DirectionType dir = directions->at(i);
if (dir.magnitude()<m_SizeThreshold)
continue;
if (m_NormalizeVectors)
dir.normalize();
count++;
if (m_CreateDirectionImages && i<10)
{
if (i==m_DirectionImageContainer->size())
{
ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
directionImage->SetSpacing( spacing );
directionImage->SetOrigin( origin );
directionImage->SetDirection( direction );
directionImage->SetRegions( imageRegion );
directionImage->Allocate();
Vector< float, 3 > nullVec; nullVec.Fill(0.0);
directionImage->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(i, directionImage);
}
// set direction image pixel
ItkDirectionImageType::Pointer directionImage = m_DirectionImageContainer->GetElement(i);
Vector< float, 3 > pixel;
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
directionImage->SetPixel(index, pixel);
}
// add direction to vector field (with spacing compensation)
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2*minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2*minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2*minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2*minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2*minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2*minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
dirIt.Set(count);
++dirIt;
}
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
- m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+ m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
}
template< class PixelType >
TractsToVectorImageFilter< PixelType >::DirectionContainerType::Pointer TractsToVectorImageFilter< PixelType >::FastClustering(DirectionContainerType::Pointer inDirs, std::vector< double > lengths)
{
DirectionContainerType::Pointer outDirs = DirectionContainerType::New();
if (inDirs->size()<2)
return inDirs;
DirectionType oldMean, currentMean;
std::vector< int > touched;
// initialize
touched.resize(inDirs->size(), 0);
bool free = true;
currentMean = inDirs->at(0); // initialize first seed
currentMean.normalize();
double length = lengths.at(0);
touched[0] = 1;
std::vector< double > newLengths;
bool meanChanged = false;
double max = 0;
while (free)
{
oldMean.fill(0.0);
// start mean-shift clustering
double angle = 0;
while (fabs(dot_product(currentMean, oldMean))<0.99)
{
oldMean = currentMean;
currentMean.fill(0.0);
for (unsigned int i=0; i<inDirs->size(); i++)
{
angle = dot_product(oldMean, inDirs->at(i));
if (angle>=m_AngularThreshold)
{
currentMean += inDirs->at(i);
if (meanChanged)
length += lengths.at(i);
touched[i] = 1;
meanChanged = true;
}
else if (-angle>=m_AngularThreshold)
{
currentMean -= inDirs->at(i);
if (meanChanged)
length += lengths.at(i);
touched[i] = 1;
meanChanged = true;
}
}
if(!meanChanged)
currentMean = oldMean;
else
currentMean.normalize();
}
// found stable mean
outDirs->push_back(currentMean);
newLengths.push_back(length);
if (length>max)
max = length;
// find next unused seed
free = false;
for (unsigned int i=0; i<touched.size(); i++)
if (touched[i]==0)
{
currentMean = inDirs->at(i);
free = true;
meanChanged = false;
length = lengths.at(i);
touched[i] = 1;
break;
}
}
if (inDirs->size()==outDirs->size())
{
if (max>0)
for (unsigned int i=0; i<outDirs->size(); i++)
outDirs->SetElement(i, outDirs->at(i)*newLengths.at(i)/max);
return outDirs;
}
else
return FastClustering(outDirs, newLengths);
}
//template< class PixelType >
//std::vector< DirectionType > TractsToVectorImageFilter< PixelType >::Clustering(std::vector< DirectionType >& inDirs)
//{
// std::vector< DirectionType > outDirs;
// if (inDirs.empty())
// return outDirs;
// DirectionType oldMean, currentMean, workingMean;
// std::vector< DirectionType > normalizedDirs;
// std::vector< int > touched;
// for (std::size_t i=0; i<inDirs.size(); i++)
// {
// normalizedDirs.push_back(inDirs[i]);
// normalizedDirs.back().normalize();
// }
// // initialize
// double max = 0.0;
// touched.resize(inDirs.size(), 0);
// for (std::size_t j=0; j<inDirs.size(); j++)
// {
// currentMean = inDirs[j];
// oldMean.fill(0.0);
// // start mean-shift clustering
// double angle = 0.0;
// int counter = 0;
// while ((currentMean-oldMean).magnitude()>0.0001)
// {
// counter = 0;
// oldMean = currentMean;
// workingMean = oldMean;
// workingMean.normalize();
// currentMean.fill(0.0);
// for (std::size_t i=0; i<normalizedDirs.size(); i++)
// {
// angle = dot_product(workingMean, normalizedDirs[i]);
// if (angle>=m_AngularThreshold)
// {
// currentMean += inDirs[i];
// counter++;
// }
// else if (-angle>=m_AngularThreshold)
// {
// currentMean -= inDirs[i];
// counter++;
// }
// }
// }
// // found stable mean
// if (counter>0)
// {
// bool add = true;
// DirectionType normMean = currentMean;
// normMean.normalize();
// for (std::size_t i=0; i<outDirs.size(); i++)
// {
// DirectionType dir = outDirs[i];
// dir.normalize();
// if ((normMean-dir).magnitude()<=0.0001)
// {
// add = false;
// break;
// }
// }
// currentMean /= counter;
// if (add)
// {
// double mag = currentMean.magnitude();
// if (mag>0)
// {
// if (mag>max)
// max = mag;
// outDirs.push_back(currentMean);
// }
// }
// }
// }
// if (m_NormalizeVectors)
// for (std::size_t i=0; i<outDirs.size(); i++)
// outDirs[i].normalize();
// else if (max>0)
// for (std::size_t i=0; i<outDirs.size(); i++)
// outDirs[i] /= max;
// if (inDirs.size()==outDirs.size())
// return outDirs;
// else
// return FastClustering(outDirs);
//}
//template< class PixelType >
//TractsToVectorImageFilter< PixelType >::DirectionContainerType::Pointer TractsToVectorImageFilter< PixelType >::MeanShiftClustering(DirectionContainerType::Pointer dirCont)
//{
// DirectionContainerType::Pointer container = DirectionContainerType::New();
// double max = 0;
// for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
// {
// vnl_vector_fixed<double, 3> mean = ClusterStep(dirCont, it.Value());
// if (mean.is_zero())
// continue;
// bool addMean = true;
// for (DirectionContainerType::ConstIterator it2 = container->Begin(); it2!=container->End(); ++it2)
// {
// vnl_vector_fixed<double, 3> dir = it2.Value();
// double angle = fabs(dot_product(mean, dir)/(mean.magnitude()*dir.magnitude()));
// if (angle>=m_Epsilon)
// {
// addMean = false;
// break;
// }
// }
// if (addMean)
// {
// if (m_NormalizeVectors)
// mean.normalize();
// else if (mean.magnitude()>max)
// max = mean.magnitude();
// container->InsertElement(container->Size(), mean);
// }
// }
// // max normalize voxel directions
// if (max>0 && !m_NormalizeVectors)
// for (std::size_t i=0; i<container->Size(); i++)
// container->ElementAt(i) /= max;
// if (container->Size()<dirCont->Size())
// return MeanShiftClustering(container);
// else
// return container;
//}
//template< class PixelType >
//vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean)
//{
// vnl_vector_fixed<double, 3> newMean; newMean.fill(0);
// for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
// {
// vnl_vector_fixed<double, 3> dir = it.Value();
// double angle = dot_product(currentMean, dir)/(currentMean.magnitude()*dir.magnitude());
// if (angle>=m_AngularThreshold)
// newMean += dir;
// else if (-angle>=m_AngularThreshold)
// newMean -= dir;
// }
// if (fabs(dot_product(currentMean, newMean)/(currentMean.magnitude()*newMean.magnitude()))>=m_Epsilon || newMean.is_zero())
// return newMean;
// else
// return ClusterStep(dirCont, newMean);
//}
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
index 3a3eab15be..67a324ac46 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
@@ -1,110 +1,110 @@
#ifndef __itkTractsToVectorImageFilter_h__
#define __itkTractsToVectorImageFilter_h__
// MITK
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
// ITK
#include <itkImageSource.h>
#include <itkVectorImage.h>
// VTK
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
using namespace mitk;
namespace itk{
/**
* \brief Extracts the voxel-wise main directions of the input fiber bundle. */
template< class PixelType >
class TractsToVectorImageFilter : public ImageSource< VectorImage< float, 3 > >
{
public:
typedef TractsToVectorImageFilter Self;
typedef ProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
typedef itk::Vector<float,3> OutputVectorType;
typedef itk::Image<OutputVectorType, 3> OutputImageType;
typedef std::vector< OutputImageType::Pointer > OutputImageContainerType;
typedef vnl_vector_fixed< double, 3 > DirectionType;
typedef VectorContainer< unsigned int, DirectionType > DirectionContainerType;
typedef VectorContainer< unsigned int, DirectionContainerType::Pointer > ContainerType;
typedef Image< Vector< float, 3 >, 3> ItkDirectionImageType;
typedef VectorContainer< unsigned int, ItkDirectionImageType::Pointer > DirectionImageContainerType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image<double, 3> ItkDoubleImgType;
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
itkTypeMacro( TractsToVectorImageFilter, ImageSource )
itkSetMacro( SizeThreshold, float)
itkGetMacro( SizeThreshold, float)
itkSetMacro( AngularThreshold, float) ///< cluster directions that are closer together than the specified threshold
itkGetMacro( AngularThreshold, float) ///< cluster directions that are closer together than the specified threshold
itkSetMacro( NormalizeVectors, bool) ///< Normalize vectors to length 1
itkGetMacro( NormalizeVectors, bool) ///< Normalize vectors to length 1
itkSetMacro( UseWorkingCopy, bool) ///< Do not modify input fiber bundle. Use a copy.
itkGetMacro( UseWorkingCopy, bool) ///< Do not modify input fiber bundle. Use a copy.
itkSetMacro( MaxNumDirections, unsigned long) ///< If more directions are extracted, only the largest are kept.
itkGetMacro( MaxNumDirections, unsigned long) ///< If more directions are extracted, only the largest are kept.
itkSetMacro( MaskImage, ItkUcharImgType::Pointer) ///< only process voxels inside mask
- itkSetMacro( FiberBundle, FiberBundleX::Pointer) ///< input fiber bundle
+ itkSetMacro( FiberBundle, FiberBundle::Pointer) ///< input fiber bundle
itkGetMacro( ClusteredDirectionsContainer, ContainerType::Pointer) ///< output directions
itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer) ///< number of directions per voxel
- itkGetMacro( OutputFiberBundle, FiberBundleX::Pointer) ///< vector field for visualization purposes
+ itkGetMacro( OutputFiberBundle, FiberBundle::Pointer) ///< vector field for visualization purposes
itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer) ///< output directions
itkSetMacro( CreateDirectionImages, bool)
void GenerateData();
protected:
DirectionContainerType::Pointer FastClustering(DirectionContainerType::Pointer inDirs, std::vector< double > lengths); ///< cluster fiber directions
// std::vector< DirectionType > Clustering(std::vector< DirectionType >& inDirs);
// DirectionContainerType::Pointer MeanShiftClustering(DirectionContainerType::Pointer dirCont);
// vnl_vector_fixed<double, 3> ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean);
vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
itk::Point<double, 3> GetItkPoint(double point[3]);
TractsToVectorImageFilter();
virtual ~TractsToVectorImageFilter();
- FiberBundleX::Pointer m_FiberBundle; ///< input fiber bundle
+ FiberBundle::Pointer m_FiberBundle; ///< input fiber bundle
float m_AngularThreshold; ///< cluster directions that are closer together than the specified threshold
float m_Epsilon; ///< epsilon for vector equality check
ItkUcharImgType::Pointer m_MaskImage; ///< only voxels inside the binary mask are processed
bool m_NormalizeVectors; ///< normalize vectors to length 1
itk::Vector<float> m_OutImageSpacing; ///< spacing of output image
ContainerType::Pointer m_DirectionsContainer; ///< container for fiber directions
bool m_UseWorkingCopy; ///< do not modify input fiber bundle but work on copy
unsigned long m_MaxNumDirections; ///< if more directions per voxel are extracted, only the largest are kept
float m_SizeThreshold;
bool m_CreateDirectionImages;
// output datastructures
ContainerType::Pointer m_ClusteredDirectionsContainer; ///< contains direction vectors for each voxel
ItkUcharImgType::Pointer m_NumDirectionsImage; ///< shows number of fibers per voxel
DirectionImageContainerType::Pointer m_DirectionImageContainer; ///< contains images that contain the output directions
- FiberBundleX::Pointer m_OutputFiberBundle; ///< vector field for visualization purposes
+ FiberBundle::Pointer m_OutputFiberBundle; ///< vector field for visualization purposes
};
}
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTractsToVectorImageFilter.cpp"
#endif
#endif // __itkTractsToVectorImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
index 56f846586b..1445f55941 100644
--- a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
@@ -1,65 +1,65 @@
set(_module_deps MitkDiffusionCore MitkGraphAlgorithms)
mitk_check_module_dependencies(
MODULES ${_module_deps}
MISSING_DEPENDENCIES_VAR _missing_deps
)
# Enable OpenMP support
find_package(OpenMP)
if(NOT OPENMP_FOUND)
message("OpenMP is not available.")
endif()
if(OPENMP_FOUND)
message(STATUS "Found OpenMP.")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
endif()
if(NOT _missing_deps)
set(lut_url http://mitk.org/download/data/FibertrackingLUT.tar.gz)
set(lut_tarball ${CMAKE_CURRENT_BINARY_DIR}/FibertrackingLUT.tar.gz)
message("Downloading FiberTracking LUT ${lut_url}...")
file(DOWNLOAD ${lut_url} ${lut_tarball}
EXPECTED_MD5 38ecb6d4a826c9ebb0f4965eb9aeee44
TIMEOUT 60
STATUS status
SHOW_PROGRESS
)
list(GET status 0 status_code)
list(GET status 1 status_msg)
if(NOT status_code EQUAL 0)
message(SEND_ERROR "${status_msg} (error code ${status_code})")
else()
message("done.")
endif()
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Resources)
message("Unpacking FiberTracking LUT tarball...")
execute_process(COMMAND ${CMAKE_COMMAND} -E tar xzf ../FibertrackingLUT.tar.gz
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Resources
RESULT_VARIABLE result
ERROR_VARIABLE err_msg)
if(result)
message(SEND_ERROR "Unpacking FibertrackingLUT.tar.gz failed: ${err_msg}")
else()
message("done.")
endif()
endif()
MITK_CREATE_MODULE(
SUBPROJECTS MITK-DTI
- INCLUDE_DIRS Algorithms Algorithms/GibbsTracking Algorithms/StochasticTracking IODataStructures IODataStructures/FiberBundleX IODataStructures/PlanarFigureComposite Interactions SignalModels Rendering ${CMAKE_CURRENT_BINARY_DIR}
+ INCLUDE_DIRS Algorithms Algorithms/GibbsTracking Algorithms/StochasticTracking IODataStructures IODataStructures/FiberBundle IODataStructures/PlanarFigureComposite Interactions SignalModels Rendering ${CMAKE_CURRENT_BINARY_DIR}
DEPENDS ${_module_deps}
PACKAGE_DEPENDS ITK|ITKFFT ITK|ITKDiffusionTensorImage
#WARNINGS_AS_ERRORS
)
if(MODULE_IS_ENABLED)
add_subdirectory(Testing)
endif()
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
similarity index 93%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
index 7d5e97f8ac..14db052d96 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
@@ -1,1849 +1,1849 @@
/*===================================================================
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 _USE_MATH_DEFINES
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
#include <mitkPlanarCircle.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarFigureComposite.h>
#include "mitkImagePixelReadAccessor.h"
#include <mitkPixelTypeMultiplex.h>
#include <vtkPointData.h>
#include <vtkDataArray.h>
#include <vtkUnsignedCharArray.h>
#include <vtkPolyLine.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkIdFilter.h>
#include <vtkClipPolyData.h>
#include <vtkPlane.h>
#include <vtkDoubleArray.h>
#include <vtkKochanekSpline.h>
#include <vtkParametricFunctionSource.h>
#include <vtkParametricSpline.h>
#include <vtkPolygon.h>
#include <vtkCleanPolyData.h>
#include <cmath>
#include <boost/progress.hpp>
#include <vtkTransformPolyDataFilter.h>
#include <mitkTransferFunction.h>
#include <vtkLookupTable.h>
#include <mitkLookupTable.h>
-const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
+const char* mitk::FiberBundle::FIBER_ID_ARRAY = "Fiber_IDs";
using namespace std;
-mitk::FiberBundleX::FiberBundleX( vtkPolyData* fiberPolyData )
+mitk::FiberBundle::FiberBundle( vtkPolyData* fiberPolyData )
: m_NumFibers(0)
, m_FiberSampling(0)
{
m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
m_FiberWeights->SetName("FIBER_WEIGHTS");
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
if (fiberPolyData != NULL)
{
m_FiberPolyData = fiberPolyData;
this->DoColorCodingOrientationBased();
}
this->UpdateFiberGeometry();
this->GenerateFiberIds();
}
-mitk::FiberBundleX::~FiberBundleX()
+mitk::FiberBundle::~FiberBundle()
{
}
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
+mitk::FiberBundle::Pointer mitk::FiberBundle::GetDeepCopy()
{
- mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(m_FiberPolyData);
+ mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(m_FiberPolyData);
newFib->SetFiberColors(this->m_FiberColors);
newFib->SetFiberWeights(this->m_FiberWeights);
return newFib;
}
-vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GeneratePolyDataByIds(std::vector<long> fiberIds)
+vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GeneratePolyDataByIds(std::vector<long> fiberIds)
{
vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
std::vector<long>::iterator finIt = fiberIds.begin();
while ( finIt != fiberIds.end() )
{
if (*finIt < 0 || *finIt>GetNumFibers()){
MITK_INFO << "FiberID can not be negative or >NumFibers!!! check id Extraction!" << *finIt;
break;
}
vtkSmartPointer<vtkCell> fiber = m_FiberIdDataSet->GetCell(*finIt);//->DeepCopy(fiber);
vtkSmartPointer<vtkPoints> fibPoints = fiber->GetPoints();
vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
newFiber->GetPointIds()->SetNumberOfIds( fibPoints->GetNumberOfPoints() );
for(int i=0; i<fibPoints->GetNumberOfPoints(); i++)
{
newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
}
newLineSet->InsertNextCell(newFiber);
++finIt;
}
newFiberPolyData->SetPoints(newPointSet);
newFiberPolyData->SetLines(newLineSet);
return newFiberPolyData;
}
// merge two fiber bundles
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::AddBundle(mitk::FiberBundleX* fib)
+mitk::FiberBundle::Pointer mitk::FiberBundle::AddBundle(mitk::FiberBundle* fib)
{
if (fib==NULL)
{
MITK_WARN << "trying to call AddBundle with NULL argument";
return NULL;
}
MITK_INFO << "Adding fibers";
vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
// add current fiber bundle
vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
unsigned int counter = 0;
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double p[3];
points->GetPoint(j, p);
vtkIdType id = vNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
weights->InsertValue(counter, this->GetFiberWeight(i));
vNewLines->InsertNextCell(container);
counter++;
}
// add new fiber bundle
for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
{
vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double p[3];
points->GetPoint(j, p);
vtkIdType id = vNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
weights->InsertValue(counter, fib->GetFiberWeight(i));
vNewLines->InsertNextCell(container);
counter++;
}
// initialize polydata
vNewPolyData->SetPoints(vNewPoints);
vNewPolyData->SetLines(vNewLines);
// initialize fiber bundle
- mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
+ mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
newFib->SetFiberWeights(weights);
return newFib;
}
// subtract two fiber bundles
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::SubtractBundle(mitk::FiberBundleX* fib)
+mitk::FiberBundle::Pointer mitk::FiberBundle::SubtractBundle(mitk::FiberBundle* fib)
{
MITK_INFO << "Subtracting fibers";
vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
// iterate over current fibers
boost::progress_display disp(m_NumFibers);
for( int i=0; i<m_NumFibers; i++ )
{
++disp;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
if (points==NULL || numPoints<=0)
continue;
int numFibers2 = fib->GetNumFibers();
bool contained = false;
for( int i2=0; i2<numFibers2; i2++ )
{
vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i2);
int numPoints2 = cell2->GetNumberOfPoints();
vtkPoints* points2 = cell2->GetPoints();
if (points2==NULL)// || numPoints2<=0)
continue;
// check endpoints
if (numPoints2==numPoints)
{
itk::Point<float, 3> point_start = GetItkPoint(points->GetPoint(0));
itk::Point<float, 3> point_end = GetItkPoint(points->GetPoint(numPoints-1));
itk::Point<float, 3> point2_start = GetItkPoint(points2->GetPoint(0));
itk::Point<float, 3> point2_end = GetItkPoint(points2->GetPoint(numPoints2-1));
if ((point_start.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps) ||
(point_start.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps))
{
// further checking ???
contained = true;
break;
}
}
}
// add to result because fiber is not subtracted
if (!contained)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for( int j=0; j<numPoints; j++)
{
vtkIdType id = vNewPoints->InsertNextPoint(points->GetPoint(j));
container->GetPointIds()->InsertNextId(id);
}
vNewLines->InsertNextCell(container);
}
}
if(vNewLines->GetNumberOfCells()==0)
return NULL;
// initialize polydata
vNewPolyData->SetPoints(vNewPoints);
vNewPolyData->SetLines(vNewLines);
// initialize fiber bundle
- return mitk::FiberBundleX::New(vNewPolyData);
+ return mitk::FiberBundle::New(vNewPolyData);
}
-itk::Point<float, 3> mitk::FiberBundleX::GetItkPoint(double point[3])
+itk::Point<float, 3> mitk::FiberBundle::GetItkPoint(double point[3])
{
itk::Point<float, 3> itkPoint;
itkPoint[0] = point[0];
itkPoint[1] = point[1];
itkPoint[2] = point[2];
return itkPoint;
}
/*
* set polydata (additional flag to recompute fiber geometry, default = true)
*/
-void mitk::FiberBundleX::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
+void mitk::FiberBundle::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
{
if (fiberPD == NULL)
this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
else
{
m_FiberPolyData->DeepCopy(fiberPD);
DoColorCodingOrientationBased();
}
m_NumFibers = m_FiberPolyData->GetNumberOfLines();
if (updateGeometry)
UpdateFiberGeometry();
GenerateFiberIds();
}
/*
* return vtkPolyData
*/
-vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData() const
+vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GetFiberPolyData() const
{
return m_FiberPolyData;
}
-void mitk::FiberBundleX::DoColorCodingOrientationBased()
+void mitk::FiberBundle::DoColorCodingOrientationBased()
{
//===== FOR WRITING A TEST ========================
// colorT size == tupelComponents * tupelElements
// compare color results
// to cover this code 100% also polydata needed, where colorarray already exists
// + one fiber with exactly 1 point
// + one fiber with 0 points
//=================================================
vtkPoints* extrPoints = NULL;
extrPoints = m_FiberPolyData->GetPoints();
int numOfPoints = 0;
if (extrPoints!=NULL)
numOfPoints = extrPoints->GetNumberOfPoints();
//colors and alpha value for each single point, RGBA = 4 components
unsigned char rgba[4] = {0,0,0,0};
int componentSize = 4;
m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
m_FiberColors->Allocate(numOfPoints * componentSize);
m_FiberColors->SetNumberOfComponents(componentSize);
m_FiberColors->SetName("FIBER_COLORS");
int numOfFibers = m_FiberPolyData->GetNumberOfLines();
if (numOfFibers < 1)
return;
/* extract single fibers of fiberBundle */
vtkCellArray* fiberList = m_FiberPolyData->GetLines();
fiberList->InitTraversal();
for (int fi=0; fi<numOfFibers; ++fi) {
vtkIdType* idList; // contains the point id's of the line
vtkIdType pointsPerFiber; // number of points for current line
fiberList->GetNextCell(pointsPerFiber, idList);
/* single fiber checkpoints: is number of points valid */
if (pointsPerFiber > 1)
{
/* operate on points of single fiber */
for (int i=0; i <pointsPerFiber; ++i)
{
/* process all points except starting and endpoint for calculating color value take current point, previous point and next point */
if (i<pointsPerFiber-1 && i > 0)
{
/* The color value of the current point is influenced by the previous point and next point. */
vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
vnl_vector_fixed< double, 3 > diff1;
diff1 = currentPntvtk - nextPntvtk;
vnl_vector_fixed< double, 3 > diff2;
diff2 = currentPntvtk - prevPntvtk;
vnl_vector_fixed< double, 3 > diff;
diff = (diff1 - diff2) / 2.0;
diff.normalize();
rgba[0] = (unsigned char) (255.0 * std::fabs(diff[0]));
rgba[1] = (unsigned char) (255.0 * std::fabs(diff[1]));
rgba[2] = (unsigned char) (255.0 * std::fabs(diff[2]));
rgba[3] = (unsigned char) (255.0);
}
else if (i==0)
{
/* First point has no previous point, therefore only diff1 is taken */
vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
vnl_vector_fixed< double, 3 > diff1;
diff1 = currentPntvtk - nextPntvtk;
diff1.normalize();
rgba[0] = (unsigned char) (255.0 * std::fabs(diff1[0]));
rgba[1] = (unsigned char) (255.0 * std::fabs(diff1[1]));
rgba[2] = (unsigned char) (255.0 * std::fabs(diff1[2]));
rgba[3] = (unsigned char) (255.0);
}
else if (i==pointsPerFiber-1)
{
/* Last point has no next point, therefore only diff2 is taken */
vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
vnl_vector_fixed< double, 3 > diff2;
diff2 = currentPntvtk - prevPntvtk;
diff2.normalize();
rgba[0] = (unsigned char) (255.0 * std::fabs(diff2[0]));
rgba[1] = (unsigned char) (255.0 * std::fabs(diff2[1]));
rgba[2] = (unsigned char) (255.0 * std::fabs(diff2[2]));
rgba[3] = (unsigned char) (255.0);
}
m_FiberColors->InsertTupleValue(idList[i], rgba);
}
}
else if (pointsPerFiber == 1)
{
/* a single point does not define a fiber (use vertex mechanisms instead */
continue;
}
else
{
MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
continue;
}
}
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
-void mitk::FiberBundleX::SetFiberOpacity(vtkDoubleArray* FAValArray)
+void mitk::FiberBundle::SetFiberOpacity(vtkDoubleArray* FAValArray)
{
for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
{
double faValue = FAValArray->GetValue(i);
faValue = faValue * 255.0;
m_FiberColors->SetComponent(i,3, (unsigned char) faValue );
}
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
-void mitk::FiberBundleX::ResetFiberOpacity()
+void mitk::FiberBundle::ResetFiberOpacity()
{
for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
m_FiberColors->SetComponent(i,3, 255.0 );
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
-void mitk::FiberBundleX::ColorFibersByScalarMap(mitk::Image::Pointer FAimage, bool opacity)
+void mitk::FiberBundle::ColorFibersByScalarMap(mitk::Image::Pointer FAimage, bool opacity)
{
mitkPixelTypeMultiplex2( ColorFibersByScalarMap, FAimage->GetPixelType(), FAimage, opacity );
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
template <typename TPixel>
-void mitk::FiberBundleX::ColorFibersByScalarMap(const mitk::PixelType, mitk::Image::Pointer image, bool opacity)
+void mitk::FiberBundle::ColorFibersByScalarMap(const mitk::PixelType, mitk::Image::Pointer image, bool opacity)
{
m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
m_FiberColors->SetNumberOfComponents(4);
m_FiberColors->SetName("FIBER_COLORS");
mitk::ImagePixelReadAccessor<TPixel,3> readimage(image, image->GetVolumeData(0));
unsigned char rgba[4] = {0,0,0,0};
vtkPoints* pointSet = m_FiberPolyData->GetPoints();
mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
lookupTable->SetTableRange(0.0, 0.8);
lookupTable->Build();
mitkLookup->SetVtkLookupTable(lookupTable);
mitkLookup->SetType(mitk::LookupTable::JET);
for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
{
Point3D px;
px[0] = pointSet->GetPoint(i)[0];
px[1] = pointSet->GetPoint(i)[1];
px[2] = pointSet->GetPoint(i)[2];
double pixelValue = readimage.GetPixelByWorldCoordinates(px);
double color[3];
lookupTable->GetColor(pixelValue, color);
rgba[0] = (unsigned char) (255.0 * color[0]);
rgba[1] = (unsigned char) (255.0 * color[1]);
rgba[2] = (unsigned char) (255.0 * color[2]);
if (opacity)
rgba[3] = (unsigned char) (255.0 * pixelValue);
else
rgba[3] = (unsigned char) (255.0);
m_FiberColors->InsertTupleValue(i, rgba);
}
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
-void mitk::FiberBundleX::SetFiberColors(float r, float g, float b, float alpha)
+void mitk::FiberBundle::SetFiberColors(float r, float g, float b, float alpha)
{
m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
m_FiberColors->SetNumberOfComponents(4);
m_FiberColors->SetName("FIBER_COLORS");
unsigned char rgba[4] = {0,0,0,0};
for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
{
rgba[0] = (unsigned char) r;
rgba[1] = (unsigned char) g;
rgba[2] = (unsigned char) b;
rgba[3] = (unsigned char) alpha;
m_FiberColors->InsertTupleValue(i, rgba);
}
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
-void mitk::FiberBundleX::GenerateFiberIds()
+void mitk::FiberBundle::GenerateFiberIds()
{
if (m_FiberPolyData == NULL)
return;
vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
idFiberFilter->SetInputData(m_FiberPolyData);
idFiberFilter->CellIdsOn();
// idFiberFilter->PointIdsOn(); // point id's are not needed
idFiberFilter->SetIdsArrayName(FIBER_ID_ARRAY);
idFiberFilter->FieldDataOn();
idFiberFilter->Update();
m_FiberIdDataSet = idFiberFilter->GetOutput();
}
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert)
+mitk::FiberBundle::Pointer mitk::FiberBundle::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert)
{
vtkSmartPointer<vtkPolyData> polyData = m_FiberPolyData;
if (anyPoint)
{
float minSpacing = 1;
if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
minSpacing = mask->GetSpacing()[0];
else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
minSpacing = mask->GetSpacing()[1];
else
minSpacing = mask->GetSpacing()[2];
- mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
+ mitk::FiberBundle::Pointer fibCopy = this->GetDeepCopy();
fibCopy->ResampleSpline(minSpacing/5);
polyData = fibCopy->GetFiberPolyData();
}
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
MITK_INFO << "Extracting fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
vtkCell* cell = polyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkCell* cellOriginal = m_FiberPolyData->GetCell(i);
int numPointsOriginal = cellOriginal->GetNumberOfPoints();
vtkPoints* pointsOriginal = cellOriginal->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
if (numPoints>1 && numPointsOriginal)
{
if (anyPoint)
{
if (!invert)
{
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
mask->TransformPhysicalPointToIndex(itkP, idx);
if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
{
for (int k=0; k<numPointsOriginal; k++)
{
double* p = pointsOriginal->GetPoint(k);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
break;
}
}
}
else
{
bool includeFiber = true;
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
mask->TransformPhysicalPointToIndex(itkP, idx);
if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
{
includeFiber = false;
break;
}
}
if (includeFiber)
{
for (int k=0; k<numPointsOriginal; k++)
{
double* p = pointsOriginal->GetPoint(k);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
}
}
}
else
{
double* start = pointsOriginal->GetPoint(0);
itk::Point<float, 3> itkStart;
itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
itk::Index<3> idxStart;
mask->TransformPhysicalPointToIndex(itkStart, idxStart);
double* end = pointsOriginal->GetPoint(numPointsOriginal-1);
itk::Point<float, 3> itkEnd;
itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
itk::Index<3> idxEnd;
mask->TransformPhysicalPointToIndex(itkEnd, idxEnd);
if ( mask->GetPixel(idxStart)>0 && mask->GetPixel(idxEnd)>0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
{
for (int j=0; j<numPointsOriginal; j++)
{
double* p = pointsOriginal->GetPoint(j);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
}
}
}
vtkNewCells->InsertNextCell(container);
}
if (vtkNewCells->GetNumberOfCells()<=0)
return NULL;
vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
newPolyData->SetPoints(vtkNewPoints);
newPolyData->SetLines(vtkNewCells);
- return mitk::FiberBundleX::New(newPolyData);
+ return mitk::FiberBundle::New(newPolyData);
}
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
+mitk::FiberBundle::Pointer mitk::FiberBundle::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
{
float minSpacing = 1;
if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
minSpacing = mask->GetSpacing()[0];
else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
minSpacing = mask->GetSpacing()[1];
else
minSpacing = mask->GetSpacing()[2];
- mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
+ mitk::FiberBundle::Pointer fibCopy = this->GetDeepCopy();
fibCopy->ResampleSpline(minSpacing/10);
vtkSmartPointer<vtkPolyData> polyData =fibCopy->GetFiberPolyData();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
MITK_INFO << "Cutting fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
vtkCell* cell = polyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
if (numPoints>1)
{
int newNumPoints = 0;
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
mask->TransformPhysicalPointToIndex(itkP, idx);
if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) && !invert )
{
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
newNumPoints++;
}
else if ( (mask->GetPixel(idx)<=0 || !mask->GetLargestPossibleRegion().IsInside(idx)) && invert )
{
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
newNumPoints++;
}
else if (newNumPoints>0)
{
vtkNewCells->InsertNextCell(container);
newNumPoints = 0;
container = vtkSmartPointer<vtkPolyLine>::New();
}
}
if (newNumPoints>0)
vtkNewCells->InsertNextCell(container);
}
}
if (vtkNewCells->GetNumberOfCells()<=0)
return NULL;
vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
newPolyData->SetPoints(vtkNewPoints);
newPolyData->SetLines(vtkNewCells);
- mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(newPolyData);
+ mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(newPolyData);
newFib->ResampleSpline(minSpacing/2);
return newFib;
}
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(BaseData* roi)
+mitk::FiberBundle::Pointer mitk::FiberBundle::ExtractFiberSubset(BaseData* roi)
{
if (roi==NULL || !(dynamic_cast<PlanarFigure*>(roi) || dynamic_cast<PlanarFigureComposite*>(roi)) )
return NULL;
std::vector<long> tmp = ExtractFiberIdSubset(roi);
if (tmp.size()<=0)
- return mitk::FiberBundleX::New();
+ return mitk::FiberBundle::New();
vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
- return mitk::FiberBundleX::New(pTmp);
+ return mitk::FiberBundle::New(pTmp);
}
-std::vector<long> mitk::FiberBundleX::ExtractFiberIdSubset(BaseData* roi)
+std::vector<long> mitk::FiberBundle::ExtractFiberIdSubset(BaseData* roi)
{
std::vector<long> result;
if (roi==NULL)
return result;
mitk::PlanarFigureComposite::Pointer pfc = dynamic_cast<mitk::PlanarFigureComposite*>(roi);
if (!pfc.IsNull()) // handle composite
{
switch (pfc->getOperationType())
{
case 0: // AND
{
result = this->ExtractFiberIdSubset(pfc->getChildAt(0));
std::vector<long>::iterator it;
for (int i=1; i<pfc->getNumberOfChildren(); ++i)
{
std::vector<long> inRoi = this->ExtractFiberIdSubset(pfc->getChildAt(i));
std::vector<long> rest(std::min(result.size(),inRoi.size()));
it = std::set_intersection(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
rest.resize( it - rest.begin() );
result = rest;
}
break;
}
case 1: // OR
{
result = ExtractFiberIdSubset(pfc->getChildAt(0));
std::vector<long>::iterator it;
for (int i=1; i<pfc->getNumberOfChildren(); ++i)
{
it = result.end();
std::vector<long> inRoi = ExtractFiberIdSubset(pfc->getChildAt(i));
result.insert(it, inRoi.begin(), inRoi.end());
}
// remove duplicates
sort(result.begin(), result.end());
it = unique(result.begin(), result.end());
result.resize( it - result.begin() );
break;
}
case 2: // NOT
{
for(long i=0; i<this->GetNumFibers(); i++)
result.push_back(i);
std::vector<long>::iterator it;
for (long i=0; i<pfc->getNumberOfChildren(); ++i)
{
std::vector<long> inRoi = ExtractFiberIdSubset(pfc->getChildAt(i));
std::vector<long> rest(result.size()-inRoi.size());
it = std::set_difference(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
rest.resize( it - rest.begin() );
result = rest;
}
break;
}
}
}
else if ( dynamic_cast<mitk::PlanarFigure*>(roi) ) // actual extraction
{
if ( dynamic_cast<mitk::PlanarPolygon*>(roi) )
{
mitk::PlanarFigure::Pointer planarPoly = dynamic_cast<mitk::PlanarFigure*>(roi);
//create vtkPolygon using controlpoints from planarFigure polygon
vtkSmartPointer<vtkPolygon> polygonVtk = vtkSmartPointer<vtkPolygon>::New();
for (unsigned int i=0; i<planarPoly->GetNumberOfControlPoints(); ++i)
{
itk::Point<double,3> p = planarPoly->GetWorldControlPoint(i);
vtkIdType id = polygonVtk->GetPoints()->InsertNextPoint(p[0], p[1], p[2] );
polygonVtk->GetPointIds()->InsertNextId(id);
}
MITK_INFO << "Extracting with polygon";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp ;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
for (int j=0; j<numPoints-1; j++)
{
// Inputs
double p1[3] = {0,0,0};
points->GetPoint(j, p1);
double p2[3] = {0,0,0};
points->GetPoint(j+1, p2);
double tolerance = 0.001;
// Outputs
double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
double x[3] = {0,0,0}; // The coordinate of the intersection
double pcoords[3] = {0,0,0};
int subId = 0;
int iD = polygonVtk->IntersectWithLine(p1, p2, tolerance, t, x, pcoords, subId);
if (iD!=0)
{
result.push_back(i);
break;
}
}
}
}
else if ( dynamic_cast<mitk::PlanarCircle*>(roi) )
{
mitk::PlanarFigure::Pointer planarFigure = dynamic_cast<mitk::PlanarFigure*>(roi);
Vector3D planeNormal = planarFigure->GetPlaneGeometry()->GetNormal();
planeNormal.Normalize();
//calculate circle radius
mitk::Point3D V1w = planarFigure->GetWorldControlPoint(0); //centerPoint
mitk::Point3D V2w = planarFigure->GetWorldControlPoint(1); //radiusPoint
double radius = V1w.EuclideanDistanceTo(V2w);
radius *= radius;
MITK_INFO << "Extracting with circle";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp ;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
for (int j=0; j<numPoints-1; j++)
{
// Inputs
double p1[3] = {0,0,0};
points->GetPoint(j, p1);
double p2[3] = {0,0,0};
points->GetPoint(j+1, p2);
// Outputs
double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
double x[3] = {0,0,0}; // The coordinate of the intersection
int iD = vtkPlane::IntersectWithLine(p1,p2,planeNormal.GetDataPointer(),V1w.GetDataPointer(),t,x);
if (iD!=0)
{
double dist = (x[0]-V1w[0])*(x[0]-V1w[0])+(x[1]-V1w[1])*(x[1]-V1w[1])+(x[2]-V1w[2])*(x[2]-V1w[2]);
if( dist <= radius)
{
result.push_back(i);
break;
}
}
}
}
}
return result;
}
return result;
}
-void mitk::FiberBundleX::UpdateFiberGeometry()
+void mitk::FiberBundle::UpdateFiberGeometry()
{
vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
cleaner->SetInputData(m_FiberPolyData);
cleaner->PointMergingOff();
cleaner->Update();
m_FiberPolyData = cleaner->GetOutput();
m_FiberLengths.clear();
m_MeanFiberLength = 0;
m_MedianFiberLength = 0;
m_LengthStDev = 0;
m_NumFibers = m_FiberPolyData->GetNumberOfCells();
if (m_FiberColors==NULL || m_FiberColors->GetNumberOfTuples()!=m_FiberPolyData->GetNumberOfPoints())
this->DoColorCodingOrientationBased();
if (m_FiberWeights->GetSize()!=m_NumFibers)
{
m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
m_FiberWeights->SetName("FIBER_WEIGHTS");
m_FiberWeights->SetNumberOfValues(m_NumFibers);
this->SetFiberWeights(1);
}
if (m_NumFibers<=0) // no fibers present; apply default geometry
{
m_MinFiberLength = 0;
m_MaxFiberLength = 0;
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetImageGeometry(false);
float b[] = {0, 1, 0, 1, 0, 1};
geometry->SetFloatBounds(b);
SetGeometry(geometry);
return;
}
double b[6];
m_FiberPolyData->GetBounds(b);
// calculate statistics
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
int p = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
float length = 0;
for (int j=0; j<p-1; j++)
{
double p1[3];
points->GetPoint(j, p1);
double p2[3];
points->GetPoint(j+1, p2);
float dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
length += dist;
}
m_FiberLengths.push_back(length);
m_MeanFiberLength += length;
if (i==0)
{
m_MinFiberLength = length;
m_MaxFiberLength = length;
}
else
{
if (length<m_MinFiberLength)
m_MinFiberLength = length;
if (length>m_MaxFiberLength)
m_MaxFiberLength = length;
}
}
m_MeanFiberLength /= m_NumFibers;
std::vector< float > sortedLengths = m_FiberLengths;
std::sort(sortedLengths.begin(), sortedLengths.end());
for (int i=0; i<m_NumFibers; i++)
m_LengthStDev += (m_MeanFiberLength-sortedLengths.at(i))*(m_MeanFiberLength-sortedLengths.at(i));
if (m_NumFibers>1)
m_LengthStDev /= (m_NumFibers-1);
else
m_LengthStDev = 0;
m_LengthStDev = std::sqrt(m_LengthStDev);
m_MedianFiberLength = sortedLengths.at(m_NumFibers/2);
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetFloatBounds(b);
this->SetGeometry(geometry);
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
-float mitk::FiberBundleX::GetFiberWeight(unsigned int fiber)
+float mitk::FiberBundle::GetFiberWeight(unsigned int fiber)
{
return m_FiberWeights->GetValue(fiber);
}
-void mitk::FiberBundleX::SetFiberWeights(float newWeight)
+void mitk::FiberBundle::SetFiberWeights(float newWeight)
{
for (int i=0; i<m_FiberWeights->GetSize(); i++)
m_FiberWeights->SetValue(i, newWeight);
}
-void mitk::FiberBundleX::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
+void mitk::FiberBundle::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
{
if (m_NumFibers!=weights->GetSize())
return;
for (int i=0; i<weights->GetSize(); i++)
m_FiberWeights->SetValue(i, weights->GetValue(i));
m_FiberWeights->SetName("FIBER_WEIGHTS");
}
-void mitk::FiberBundleX::SetFiberWeight(unsigned int fiber, float weight)
+void mitk::FiberBundle::SetFiberWeight(unsigned int fiber, float weight)
{
m_FiberWeights->SetValue(fiber, weight);
}
-void mitk::FiberBundleX::SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors)
+void mitk::FiberBundle::SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors)
{
for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
{
unsigned char source[4] = {0,0,0,0};
fiberColors->GetTupleValue(i, source);
unsigned char target[4] = {0,0,0,0};
target[0] = source[0];
target[1] = source[1];
target[2] = source[2];
target[3] = source[3];
m_FiberColors->InsertTupleValue(i, target);
}
m_UpdateTime3D.Modified();
m_UpdateTime2D.Modified();
}
-itk::Matrix< double, 3, 3 > mitk::FiberBundleX::TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz)
+itk::Matrix< double, 3, 3 > mitk::FiberBundle::TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz)
{
rx = rx*M_PI/180;
ry = ry*M_PI/180;
rz = rz*M_PI/180;
itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
rotX[1][1] = cos(rx);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(rx);
rotX[2][1] = -rotX[1][2];
itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
rotY[0][0] = cos(ry);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(ry);
rotY[2][0] = -rotY[0][2];
itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
rotZ[0][0] = cos(rz);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(rz);
rotZ[1][0] = -rotZ[0][1];
itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
m = rot*m;
return m;
}
-itk::Point<float, 3> mitk::FiberBundleX::TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz)
+itk::Point<float, 3> mitk::FiberBundle::TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz)
{
rx = rx*M_PI/180;
ry = ry*M_PI/180;
rz = rz*M_PI/180;
vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
rotX[1][1] = cos(rx);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(rx);
rotX[2][1] = -rotX[1][2];
vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
rotY[0][0] = cos(ry);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(ry);
rotY[2][0] = -rotY[0][2];
vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
rotZ[0][0] = cos(rz);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(rz);
rotZ[1][0] = -rotZ[0][1];
vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
mitk::BaseGeometry::Pointer geom = this->GetGeometry();
mitk::Point3D center = geom->GetCenter();
point[0] -= center[0];
point[1] -= center[1];
point[2] -= center[2];
point = rot*point;
point[0] += center[0]+tx;
point[1] += center[1]+ty;
point[2] += center[2]+tz;
itk::Point<float, 3> out; out[0] = point[0]; out[1] = point[1]; out[2] = point[2];
return out;
}
-void mitk::FiberBundleX::TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz)
+void mitk::FiberBundle::TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz)
{
rx = rx*M_PI/180;
ry = ry*M_PI/180;
rz = rz*M_PI/180;
vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
rotX[1][1] = cos(rx);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(rx);
rotX[2][1] = -rotX[1][2];
vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
rotY[0][0] = cos(ry);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(ry);
rotY[2][0] = -rotY[0][2];
vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
rotZ[0][0] = cos(rz);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(rz);
rotZ[1][0] = -rotZ[0][1];
vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
mitk::BaseGeometry::Pointer geom = this->GetGeometry();
mitk::Point3D center = geom->GetCenter();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
for (int i=0; i<m_NumFibers; i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vnl_vector_fixed< double, 3 > dir;
dir[0] = p[0]-center[0];
dir[1] = p[1]-center[1];
dir[2] = p[2]-center[2];
dir = rot*dir;
dir[0] += center[0]+tx;
dir[1] += center[1]+ty;
dir[2] += center[2]+tz;
vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
}
-void mitk::FiberBundleX::RotateAroundAxis(double x, double y, double z)
+void mitk::FiberBundle::RotateAroundAxis(double x, double y, double z)
{
x = x*M_PI/180;
y = y*M_PI/180;
z = z*M_PI/180;
vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
rotX[1][1] = cos(x);
rotX[2][2] = rotX[1][1];
rotX[1][2] = -sin(x);
rotX[2][1] = -rotX[1][2];
vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
rotY[0][0] = cos(y);
rotY[2][2] = rotY[0][0];
rotY[0][2] = sin(y);
rotY[2][0] = -rotY[0][2];
vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
rotZ[0][0] = cos(z);
rotZ[1][1] = rotZ[0][0];
rotZ[0][1] = -sin(z);
rotZ[1][0] = -rotZ[0][1];
mitk::BaseGeometry::Pointer geom = this->GetGeometry();
mitk::Point3D center = geom->GetCenter();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
for (int i=0; i<m_NumFibers; i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vnl_vector_fixed< double, 3 > dir;
dir[0] = p[0]-center[0];
dir[1] = p[1]-center[1];
dir[2] = p[2]-center[2];
dir = rotZ*rotY*rotX*dir;
dir[0] += center[0];
dir[1] += center[1];
dir[2] += center[2];
vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
}
-void mitk::FiberBundleX::ScaleFibers(double x, double y, double z, bool subtractCenter)
+void mitk::FiberBundle::ScaleFibers(double x, double y, double z, bool subtractCenter)
{
MITK_INFO << "Scaling fibers";
boost::progress_display disp(m_NumFibers);
mitk::BaseGeometry* geom = this->GetGeometry();
mitk::Point3D c = geom->GetCenter();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
for (int i=0; i<m_NumFibers; i++)
{
++disp ;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
if (subtractCenter)
{
p[0] -= c[0]; p[1] -= c[1]; p[2] -= c[2];
}
p[0] *= x;
p[1] *= y;
p[2] *= z;
if (subtractCenter)
{
p[0] += c[0]; p[1] += c[1]; p[2] += c[2];
}
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
}
-void mitk::FiberBundleX::TranslateFibers(double x, double y, double z)
+void mitk::FiberBundle::TranslateFibers(double x, double y, double z)
{
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
for (int i=0; i<m_NumFibers; i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
p[0] += x;
p[1] += y;
p[2] += z;
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
}
-void mitk::FiberBundleX::MirrorFibers(unsigned int axis)
+void mitk::FiberBundle::MirrorFibers(unsigned int axis)
{
if (axis>2)
return;
MITK_INFO << "Mirroring fibers";
boost::progress_display disp(m_NumFibers);
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
for (int i=0; i<m_NumFibers; i++)
{
++disp;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
p[axis] = -p[axis];
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
}
-void mitk::FiberBundleX::RemoveDir(vnl_vector_fixed<double,3> dir, double threshold)
+void mitk::FiberBundle::RemoveDir(vnl_vector_fixed<double,3> dir, double threshold)
{
dir.normalize();
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
++disp ;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
// calculate curvatures
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
bool discard = false;
for (int j=0; j<numPoints-1; j++)
{
double p1[3];
points->GetPoint(j, p1);
double p2[3];
points->GetPoint(j+1, p2);
vnl_vector_fixed< double, 3 > v1;
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
if (v1.magnitude()>0.001)
{
v1.normalize();
if (fabs(dot_product(v1,dir))>threshold)
{
discard = true;
break;
}
}
}
if (!discard)
{
for (int j=0; j<numPoints; j++)
{
double p1[3];
points->GetPoint(j, p1);
vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
// UpdateColorCoding();
// UpdateFiberGeometry();
}
-bool mitk::FiberBundleX::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
+bool mitk::FiberBundle::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
{
if (minRadius<0)
return true;
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
MITK_INFO << "Applying curvature threshold";
boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
++disp ;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
// calculate curvatures
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints-2; j++)
{
double p1[3];
points->GetPoint(j, p1);
double p2[3];
points->GetPoint(j+1, p2);
double p3[3];
points->GetPoint(j+2, p3);
vnl_vector_fixed< float, 3 > v1, v2, v3;
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
v2[0] = p3[0]-p2[0];
v2[1] = p3[1]-p2[1];
v2[2] = p3[2]-p2[2];
v3[0] = p1[0]-p3[0];
v3[1] = p1[1]-p3[1];
v3[2] = p1[2]-p3[2];
float a = v1.magnitude();
float b = v2.magnitude();
float c = v3.magnitude();
float r = a*b*c/std::sqrt((a+b+c)*(a+b-c)*(b+c-a)*(a-b+c)); // radius of triangle via Heron's formula (area of triangle)
vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
container->GetPointIds()->InsertNextId(id);
if (deleteFibers && r<minRadius)
break;
if (r<minRadius)
{
j += 2;
vtkNewCells->InsertNextCell(container);
container = vtkSmartPointer<vtkPolyLine>::New();
}
else if (j==numPoints-3)
{
id = vtkNewPoints->InsertNextPoint(p2);
container->GetPointIds()->InsertNextId(id);
id = vtkNewPoints->InsertNextPoint(p3);
container->GetPointIds()->InsertNextId(id);
vtkNewCells->InsertNextCell(container);
}
}
}
if (vtkNewCells->GetNumberOfCells()<=0)
return false;
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
return true;
}
-bool mitk::FiberBundleX::RemoveShortFibers(float lengthInMM)
+bool mitk::FiberBundle::RemoveShortFibers(float lengthInMM)
{
MITK_INFO << "Removing short fibers";
if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
{
MITK_INFO << "No fibers shorter than " << lengthInMM << " mm found!";
return true;
}
if (lengthInMM>m_MaxFiberLength) // can't remove all fibers
{
MITK_WARN << "Process aborted. No fibers would be left!";
return false;
}
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
float min = m_MaxFiberLength;
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
if (m_FiberLengths.at(i)>=lengthInMM)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
if (m_FiberLengths.at(i)<min)
min = m_FiberLengths.at(i);
}
}
if (vtkNewCells->GetNumberOfCells()<=0)
return false;
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
return true;
}
-bool mitk::FiberBundleX::RemoveLongFibers(float lengthInMM)
+bool mitk::FiberBundle::RemoveLongFibers(float lengthInMM)
{
if (lengthInMM<=0 || lengthInMM>m_MaxFiberLength)
return true;
if (lengthInMM<m_MinFiberLength) // can't remove all fibers
return false;
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
MITK_INFO << "Removing long fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
if (m_FiberLengths.at(i)<=lengthInMM)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = vtkNewPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
}
if (vtkNewCells->GetNumberOfCells()<=0)
return false;
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
return true;
}
-void mitk::FiberBundleX::ResampleSpline(float pointDistance, double tension, double continuity, double bias )
+void mitk::FiberBundle::ResampleSpline(float pointDistance, double tension, double continuity, double bias )
{
if (pointDistance<=0)
return;
vtkSmartPointer<vtkPoints> vtkSmoothPoints = vtkSmartPointer<vtkPoints>::New(); //in smoothpoints the interpolated points representing a fiber are stored.
//in vtkcells all polylines are stored, actually all id's of them are stored
vtkSmartPointer<vtkCellArray> vtkSmoothCells = vtkSmartPointer<vtkCellArray>::New(); //cellcontainer for smoothed lines
vtkIdType pointHelperCnt = 0;
MITK_INFO << "Smoothing fibers";
boost::progress_display disp(m_NumFibers);
for (int i=0; i<m_NumFibers; i++)
{
++disp;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
for (int j=0; j<numPoints; j++)
newPoints->InsertNextPoint(points->GetPoint(j));
float length = m_FiberLengths.at(i);
int sampling = std::ceil(length/pointDistance);
vtkSmartPointer<vtkKochanekSpline> xSpline = vtkSmartPointer<vtkKochanekSpline>::New();
vtkSmartPointer<vtkKochanekSpline> ySpline = vtkSmartPointer<vtkKochanekSpline>::New();
vtkSmartPointer<vtkKochanekSpline> zSpline = vtkSmartPointer<vtkKochanekSpline>::New();
xSpline->SetDefaultBias(bias); xSpline->SetDefaultTension(tension); xSpline->SetDefaultContinuity(continuity);
ySpline->SetDefaultBias(bias); ySpline->SetDefaultTension(tension); ySpline->SetDefaultContinuity(continuity);
zSpline->SetDefaultBias(bias); zSpline->SetDefaultTension(tension); zSpline->SetDefaultContinuity(continuity);
vtkSmartPointer<vtkParametricSpline> spline = vtkSmartPointer<vtkParametricSpline>::New();
spline->SetXSpline(xSpline);
spline->SetYSpline(ySpline);
spline->SetZSpline(zSpline);
spline->SetPoints(newPoints);
vtkSmartPointer<vtkParametricFunctionSource> functionSource = vtkSmartPointer<vtkParametricFunctionSource>::New();
functionSource->SetParametricFunction(spline);
functionSource->SetUResolution(sampling);
functionSource->SetVResolution(sampling);
functionSource->SetWResolution(sampling);
functionSource->Update();
vtkPolyData* outputFunction = functionSource->GetOutput();
vtkPoints* tmpSmoothPnts = outputFunction->GetPoints(); //smoothPoints of current fiber
vtkSmartPointer<vtkPolyLine> smoothLine = vtkSmartPointer<vtkPolyLine>::New();
smoothLine->GetPointIds()->SetNumberOfIds(tmpSmoothPnts->GetNumberOfPoints());
for (int j=0; j<smoothLine->GetNumberOfPoints(); j++)
{
smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
}
vtkSmoothCells->InsertNextCell(smoothLine);
pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
}
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkSmoothPoints);
m_FiberPolyData->SetLines(vtkSmoothCells);
this->SetFiberPolyData(m_FiberPolyData, true);
m_FiberSampling = 10/pointDistance;
}
-void mitk::FiberBundleX::ResampleSpline(float pointDistance)
+void mitk::FiberBundle::ResampleSpline(float pointDistance)
{
ResampleSpline(pointDistance, 0, 0, 0 );
}
-unsigned long mitk::FiberBundleX::GetNumberOfPoints()
+unsigned long mitk::FiberBundle::GetNumberOfPoints()
{
unsigned long points = 0;
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
points += cell->GetNumberOfPoints();
}
return points;
}
-void mitk::FiberBundleX::Compress(float error)
+void mitk::FiberBundle::Compress(float error)
{
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
MITK_INFO << "Compressing fibers";
unsigned long numRemovedPoints = 0;
boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
{
++disp;
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
// calculate curvatures
std::vector< int > removedPoints; removedPoints.resize(numPoints, 0);
removedPoints[0]=-1; removedPoints[numPoints-1]=-1;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
bool pointFound = true;
while (pointFound)
{
pointFound = false;
double minError = error;
int removeIndex = -1;
for (int j=0; j<numPoints; j++)
{
if (removedPoints[j]==0)
{
double cand[3];
points->GetPoint(j, cand);
vnl_vector_fixed< double, 3 > candV;
candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
int validP = -1;
vnl_vector_fixed< double, 3 > pred;
for (int k=j-1; k>=0; k--)
if (removedPoints[k]<=0)
{
double ref[3];
points->GetPoint(k, ref);
pred[0]=ref[0]; pred[1]=ref[1]; pred[2]=ref[2];
validP = k;
break;
}
int validS = -1;
vnl_vector_fixed< double, 3 > succ;
for (int k=j+1; k<numPoints; k++)
if (removedPoints[k]<=0)
{
double ref[3];
points->GetPoint(k, ref);
succ[0]=ref[0]; succ[1]=ref[1]; succ[2]=ref[2];
validS = k;
break;
}
if (validP>=0 && validS>=0)
{
double a = (candV-pred).magnitude();
double b = (candV-succ).magnitude();
double c = (pred-succ).magnitude();
double s=0.5*(a+b+c);
double hc=(2.0/c)*sqrt(fabs(s*(s-a)*(s-b)*(s-c)));
if (hc<minError)
{
removeIndex = j;
minError = hc;
pointFound = true;
}
}
}
}
if (pointFound)
{
removedPoints[removeIndex] = 1;
numRemovedPoints++;
}
}
for (int j=0; j<numPoints; j++)
{
if (removedPoints[j]<=0)
{
double cand[3];
points->GetPoint(j, cand);
vtkIdType id = vtkNewPoints->InsertNextPoint(cand);
container->GetPointIds()->InsertNextId(id);
}
}
vtkNewCells->InsertNextCell(container);
}
if (vtkNewCells->GetNumberOfCells()>0)
{
MITK_INFO << "Removed points: " << numRemovedPoints;
m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
m_FiberPolyData->SetPoints(vtkNewPoints);
m_FiberPolyData->SetLines(vtkNewCells);
this->SetFiberPolyData(m_FiberPolyData, true);
}
}
// reapply selected colorcoding in case polydata structure has changed
-bool mitk::FiberBundleX::Equals(mitk::FiberBundleX* fib, double eps)
+bool mitk::FiberBundle::Equals(mitk::FiberBundle* fib, double eps)
{
if (fib==NULL)
{
MITK_INFO << "Reference bundle is NULL!";
return false;
}
if (m_NumFibers!=fib->GetNumFibers())
{
MITK_INFO << "Unequal number of fibers!";
MITK_INFO << m_NumFibers << " vs. " << fib->GetNumFibers();
return false;
}
for (int i=0; i<m_NumFibers; i++)
{
vtkCell* cell = m_FiberPolyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i);
int numPoints2 = cell2->GetNumberOfPoints();
vtkPoints* points2 = cell2->GetPoints();
if (numPoints2!=numPoints)
{
MITK_INFO << "Unequal number of points in fiber " << i << "!";
MITK_INFO << numPoints2 << " vs. " << numPoints;
return false;
}
for (int j=0; j<numPoints; j++)
{
double* p1 = points->GetPoint(j);
double* p2 = points2->GetPoint(j);
if (fabs(p1[0]-p2[0])>eps || fabs(p1[1]-p2[1])>eps || fabs(p1[2]-p2[2])>eps)
{
MITK_INFO << "Unequal points in fiber " << i << " at position " << j << "!";
MITK_INFO << "p1: " << p1[0] << ", " << p1[1] << ", " << p1[2];
MITK_INFO << "p2: " << p2[0] << ", " << p2[1] << ", " << p2[2];
return false;
}
}
}
return true;
}
/* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
-void mitk::FiberBundleX::UpdateOutputInformation()
+void mitk::FiberBundle::UpdateOutputInformation()
{
}
-void mitk::FiberBundleX::SetRequestedRegionToLargestPossibleRegion()
+void mitk::FiberBundle::SetRequestedRegionToLargestPossibleRegion()
{
}
-bool mitk::FiberBundleX::RequestedRegionIsOutsideOfTheBufferedRegion()
+bool mitk::FiberBundle::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
-bool mitk::FiberBundleX::VerifyRequestedRegion()
+bool mitk::FiberBundle::VerifyRequestedRegion()
{
return true;
}
-void mitk::FiberBundleX::SetRequestedRegion(const itk::DataObject* )
+void mitk::FiberBundle::SetRequestedRegion(const itk::DataObject* )
{
}
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
similarity index 87%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
index 37d44ad5f2..59ca9cf869 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
@@ -1,178 +1,178 @@
/*===================================================================
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
+#ifndef _MITK_FiberBundle_H
+#define _MITK_FiberBundle_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 <vtkFloatArray.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
+class MitkFiberTracking_EXPORT FiberBundle : public BaseData
{
public:
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
// fiber colorcodings
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 )
+ mitkClassMacro( FiberBundle, BaseData )
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
mitkNewMacro1Param(Self, vtkSmartPointer<vtkPolyData>) // custom constructor
// colorcoding related methods
void ColorFibersByScalarMap(mitk::Image::Pointer, bool opacity);
template <typename TPixel>
void ColorFibersByScalarMap(const mitk::PixelType pixelType, mitk::Image::Pointer, bool opacity);
void DoColorCodingOrientationBased();
void SetFiberOpacity(vtkDoubleArray *FAValArray);
void ResetFiberOpacity();
void SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors);
void SetFiberColors(float r, float g, float b, float alpha=255);
vtkSmartPointer<vtkUnsignedCharArray> GetFiberColors() const { return m_FiberColors; }
// 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);
+ FiberBundle::Pointer AddBundle(FiberBundle* fib);
+ FiberBundle::Pointer SubtractBundle(FiberBundle* fib);
// fiber subset extraction
- FiberBundleX::Pointer ExtractFiberSubset(BaseData* roi);
+ FiberBundle::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);
+ FiberBundle::Pointer ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert=false);
+ FiberBundle::Pointer RemoveFibersOutside(ItkUcharImgType* mask, bool invert=false);
vtkSmartPointer<vtkPolyData> GeneratePolyDataByIds( std::vector<long> ); // TODO: make protected
void GenerateFiberIds(); // TODO: make protected
// get/set data
vtkSmartPointer<vtkFloatArray> GetFiberWeights() const { return m_FiberWeights; }
float GetFiberWeight(unsigned int fiber);
void SetFiberWeights(float newWeight);
void SetFiberWeight(unsigned int fiber, float weight);
void SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights);
void SetFiberPolyData(vtkSmartPointer<vtkPolyData>, bool updateGeometry = true);
vtkSmartPointer<vtkPolyData> GetFiberPolyData() const;
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(); }
void RequestUpdate(){ m_UpdateTime2D.Modified(); m_UpdateTime3D.Modified(); }
unsigned long GetNumberOfPoints();
// copy fiber bundle
- mitk::FiberBundleX::Pointer GetDeepCopy();
+ mitk::FiberBundle::Pointer GetDeepCopy();
// compare fiber bundles
- bool Equals(FiberBundleX* fib, double eps=0.0001);
+ bool Equals(FiberBundle* fib, double eps=0.0001);
itkSetMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
itkGetConstMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
protected:
- FiberBundleX( vtkPolyData* fiberPolyData = NULL );
- virtual ~FiberBundleX();
+ FiberBundle( vtkPolyData* fiberPolyData = NULL );
+ virtual ~FiberBundle();
itk::Point<float, 3> GetItkPoint(double point[3]);
// calculate geometry from fiber extent
void UpdateFiberGeometry();
private:
// actual fiber container
vtkSmartPointer<vtkPolyData> m_FiberPolyData;
// contains fiber ids
vtkSmartPointer<vtkDataSet> m_FiberIdDataSet;
int m_NumFibers;
vtkSmartPointer<vtkUnsignedCharArray> m_FiberColors;
vtkSmartPointer<vtkFloatArray> m_FiberWeights;
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 */
+#endif /* _MITK_FiberBundle_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.cpp
similarity index 100%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.cpp
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.h
similarity index 100%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.h
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.cpp
similarity index 55%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.cpp
index caf0d042cd..3aa3cbf85f 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.cpp
@@ -1,254 +1,254 @@
/*===================================================================
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 "mitkFiberBundleXThreadMonitor.h"
+#include "mitkFiberBundleThreadMonitor.h"
-mitk::FiberBundleXThreadMonitor::FiberBundleXThreadMonitor()
+mitk::FiberBundleThreadMonitor::FiberBundleThreadMonitor()
: m_monitorBracketOpen("[")
, m_monitorBracketClose("]")
, m_monitorHeading("Monitoring Fiberprocessing Threads")
, m_monitorMask("Thread Status:\nStarted: Finished: Terminated:")
, m_monitorStatus("_initialized")
, m_monitorStarted(0)
, m_monitorFinished(0)
, m_monitorTerminated(0)
{
m_monitorBracketOpenPosition[0] = 0;
m_monitorBracketOpenPosition[1] = 0;
m_monitorBracketClosePosition[0] = 0;
m_monitorBracketClosePosition[1] = 0;
m_monitorHeadingPosition[0] = 0;
m_monitorHeadingPosition[1] = 0;
m_monitorMaskPosition[0] = 0;
m_monitorMaskPosition[1] = 0;
m_monitorStatusPosition[0] = 0;
m_monitorStatusPosition[1] = 0;
m_monitorStartedPosition[0] = 0;
m_monitorStartedPosition[1] = 0;
m_monitorFinishedPosition[0] = 0;
m_monitorFinishedPosition[1] = 0;
m_monitorTerminatedPosition[0] = 0;
m_monitorTerminatedPosition[1] = 0;
m_monitorHeadingOpacity = 0;
m_monitorMaskOpacity = 0;
m_monitorTerminatedOpacity = 0;
m_monitorFinishedOpacity = 0;
m_monitorStartedOpacity = 0;
m_monitorStatusOpacity = 0;
}
-mitk::FiberBundleXThreadMonitor::~FiberBundleXThreadMonitor()
+mitk::FiberBundleThreadMonitor::~FiberBundleThreadMonitor()
{
}
-QString mitk::FiberBundleXThreadMonitor::getBracketOpen(){
+QString mitk::FiberBundleThreadMonitor::getBracketOpen(){
return m_monitorBracketOpen;
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketOpenPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getBracketOpenPosition(){
return m_monitorBracketOpenPosition;
}
-void mitk::FiberBundleXThreadMonitor::setBracketOpenPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setBracketOpenPosition(mitk::Point2D pnt){
m_monitorBracketOpenPosition[0] = pnt[0];
m_monitorBracketOpenPosition[1] = pnt[1];
}
-QString mitk::FiberBundleXThreadMonitor::getBracketClose(){
+QString mitk::FiberBundleThreadMonitor::getBracketClose(){
return m_monitorBracketClose;
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketClosePosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getBracketClosePosition(){
return m_monitorBracketClosePosition;
}
-void mitk::FiberBundleXThreadMonitor::setBracketClosePosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setBracketClosePosition(mitk::Point2D pnt){
m_monitorBracketClosePosition[0] = pnt[0];
m_monitorBracketClosePosition[1] = pnt[1];
}
-QString mitk::FiberBundleXThreadMonitor::getHeading(){
+QString mitk::FiberBundleThreadMonitor::getHeading(){
return m_monitorHeading;
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getHeadingPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getHeadingPosition(){
return m_monitorHeadingPosition;
}
-void mitk::FiberBundleXThreadMonitor::setHeadingPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setHeadingPosition(mitk::Point2D pnt){
m_monitorHeadingPosition[0] = pnt[0];
m_monitorHeadingPosition[1] = pnt[1];
}
-int mitk::FiberBundleXThreadMonitor::getHeadingOpacity(){
+int mitk::FiberBundleThreadMonitor::getHeadingOpacity(){
return m_monitorHeadingOpacity;
}
-void mitk::FiberBundleXThreadMonitor::setHeadingOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setHeadingOpacity(int opacity){
m_monitorHeadingOpacity = opacity;
}
-QString mitk::FiberBundleXThreadMonitor::getMask(){
+QString mitk::FiberBundleThreadMonitor::getMask(){
return m_monitorMask;
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getMaskPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getMaskPosition(){
return m_monitorMaskPosition;
}
-void mitk::FiberBundleXThreadMonitor::setMaskPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setMaskPosition(mitk::Point2D pnt){
m_monitorMaskPosition[0] = pnt[0];
m_monitorMaskPosition[1] = pnt[1];
}
-int mitk::FiberBundleXThreadMonitor::getMaskOpacity(){
+int mitk::FiberBundleThreadMonitor::getMaskOpacity(){
return m_monitorMaskOpacity;
}
-void mitk::FiberBundleXThreadMonitor::setMaskOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setMaskOpacity(int opacity){
m_monitorMaskOpacity = opacity;
}
-QString mitk::FiberBundleXThreadMonitor::getStatus(){
+QString mitk::FiberBundleThreadMonitor::getStatus(){
return m_monitorStatus;
}
-void mitk::FiberBundleXThreadMonitor::setStatus(QString status){
+void mitk::FiberBundleThreadMonitor::setStatus(QString status){
m_statusMutex.lock();
m_monitorStatus = status;
m_statusMutex.unlock();
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getStatusPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getStatusPosition(){
return m_monitorStatusPosition;
}
-void mitk::FiberBundleXThreadMonitor::setStatusPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setStatusPosition(mitk::Point2D pnt){
m_monitorStatusPosition[0] = pnt[0];
m_monitorStatusPosition[1] = pnt[1];
}
-int mitk::FiberBundleXThreadMonitor::getStatusOpacity(){
+int mitk::FiberBundleThreadMonitor::getStatusOpacity(){
return m_monitorStatusOpacity;
}
-void mitk::FiberBundleXThreadMonitor::setStatusOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setStatusOpacity(int opacity){
m_monitorStatusOpacity = opacity;
}
-int mitk::FiberBundleXThreadMonitor::getStarted(){
+int mitk::FiberBundleThreadMonitor::getStarted(){
return m_monitorStarted;
}
/* is thread safe :) */
-void mitk::FiberBundleXThreadMonitor::setStarted(int val)
+void mitk::FiberBundleThreadMonitor::setStarted(int val)
{
m_startedMutex.lock();
m_monitorStarted = val;
m_startedMutex.unlock();
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getStartedPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getStartedPosition(){
return m_monitorStartedPosition;
}
-void mitk::FiberBundleXThreadMonitor::setStartedPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setStartedPosition(mitk::Point2D pnt){
m_monitorStartedPosition[0] = pnt[0];
m_monitorStartedPosition[1] = pnt[1];
}
-int mitk::FiberBundleXThreadMonitor::getStartedOpacity(){
+int mitk::FiberBundleThreadMonitor::getStartedOpacity(){
return m_monitorStartedOpacity;
}
-void mitk::FiberBundleXThreadMonitor::setStartedOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setStartedOpacity(int opacity){
m_monitorStartedOpacity = opacity;
}
-int mitk::FiberBundleXThreadMonitor::getFinished(){
+int mitk::FiberBundleThreadMonitor::getFinished(){
return m_monitorFinished;
}
-void mitk::FiberBundleXThreadMonitor::setFinished(int val)
+void mitk::FiberBundleThreadMonitor::setFinished(int val)
{
m_finishedMutex.lock();
m_monitorFinished = val;
m_finishedMutex.unlock();
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getFinishedPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getFinishedPosition(){
return m_monitorFinishedPosition;
}
-void mitk::FiberBundleXThreadMonitor::setFinishedPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setFinishedPosition(mitk::Point2D pnt){
m_monitorFinishedPosition[0] = pnt[0];
m_monitorFinishedPosition[1] = pnt[1];
}
-int mitk::FiberBundleXThreadMonitor::getFinishedOpacity(){
+int mitk::FiberBundleThreadMonitor::getFinishedOpacity(){
return m_monitorFinishedOpacity;
}
-void mitk::FiberBundleXThreadMonitor::setFinishedOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setFinishedOpacity(int opacity){
m_monitorFinishedOpacity = opacity;
}
-int mitk::FiberBundleXThreadMonitor::getTerminated(){
+int mitk::FiberBundleThreadMonitor::getTerminated(){
return m_monitorTerminated;
}
-void mitk::FiberBundleXThreadMonitor::setTerminated(int val)
+void mitk::FiberBundleThreadMonitor::setTerminated(int val)
{
m_terminatedMutex.lock();
m_monitorTerminated = val;
m_terminatedMutex.unlock();
}
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getTerminatedPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getTerminatedPosition(){
return m_monitorTerminatedPosition;
}
-void mitk::FiberBundleXThreadMonitor::setTerminatedPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setTerminatedPosition(mitk::Point2D pnt){
m_monitorTerminatedPosition[0] = pnt[0];
m_monitorTerminatedPosition[1] = pnt[1];
}
-int mitk::FiberBundleXThreadMonitor::getTerminatedOpacity(){
+int mitk::FiberBundleThreadMonitor::getTerminatedOpacity(){
return m_monitorTerminatedOpacity;
}
-void mitk::FiberBundleXThreadMonitor::setTerminatedOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setTerminatedOpacity(int opacity){
m_monitorTerminatedOpacity = opacity;
}
/* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
-void mitk::FiberBundleXThreadMonitor::UpdateOutputInformation()
+void mitk::FiberBundleThreadMonitor::UpdateOutputInformation()
{
}
-void mitk::FiberBundleXThreadMonitor::SetRequestedRegionToLargestPossibleRegion()
+void mitk::FiberBundleThreadMonitor::SetRequestedRegionToLargestPossibleRegion()
{
}
-bool mitk::FiberBundleXThreadMonitor::RequestedRegionIsOutsideOfTheBufferedRegion()
+bool mitk::FiberBundleThreadMonitor::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
-bool mitk::FiberBundleXThreadMonitor::VerifyRequestedRegion()
+bool mitk::FiberBundleThreadMonitor::VerifyRequestedRegion()
{
return true;
}
-void mitk::FiberBundleXThreadMonitor::SetRequestedRegion(const itk::DataObject *data )
+void mitk::FiberBundleThreadMonitor::SetRequestedRegion(const itk::DataObject *data )
{
}
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.h
similarity index 92%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.h
index 406e587d79..24f57d17a2 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.h
@@ -1,154 +1,154 @@
/*===================================================================
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_FiberBundleXThreadMonitor_H
-#define _MITK_FiberBundleXThreadMonitor_H
+#ifndef _MITK_FiberBundleThreadMonitor_H
+#define _MITK_FiberBundleThreadMonitor_H
//includes for MITK datastructure
#include "mitkBaseData.h"
#include <MitkFiberTrackingExports.h>
#include <QString>
#include <QMutex>
namespace mitk {
/**
* \brief Base Class for Fiber Bundles; */
- class Mitk FiberTracking_EXPORT FiberBundleXThreadMonitor : public BaseData
+ class Mitk FiberTracking_EXPORT FiberBundleThreadMonitor : public BaseData
{
public:
// ======virtual methods must have======
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
virtual void SetRequestedRegion(const itk::DataObject *data );
//=======================================
- mitkClassMacro( FiberBundleXThreadMonitor, BaseData );
+ mitkClassMacro( FiberBundleThreadMonitor, BaseData );
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
void setTextL1(QString);
QString getTextL1();
QString getBracketOpen();
mitk::Point2D getBracketOpenPosition();
void setBracketOpenPosition(mitk::Point2D);
int getBracketOpenOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper)
QString getBracketClose();
mitk::Point2D getBracketClosePosition();
void setBracketClosePosition(mitk::Point2D);
int getBracketCloseOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper)
QString getHeading();
mitk::Point2D getHeadingPosition();
void setHeadingPosition(mitk::Point2D);
int getHeadingOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper)
void setHeadingOpacity(int);
QString getMask();
mitk::Point2D getMaskPosition();
void setMaskPosition(mitk::Point2D);
int getMaskOpacity(); // multiplicationfactor 0.1 (in mapper)
void setMaskOpacity(int);
QString getStatus();
void setStatus(QString);
mitk::Point2D getStatusPosition();
void setStatusPosition(mitk::Point2D);
int getStatusOpacity(); // multiplicationfactor 0.1 (in mapper)
void setStatusOpacity(int);
int getStarted();
void setStarted(int);
mitk::Point2D getStartedPosition();
void setStartedPosition(mitk::Point2D);
int getStartedOpacity(); // multiplicationfactor 0.1 (in mapper)
void setStartedOpacity(int);
int getFinished();
void setFinished(int);
mitk::Point2D getFinishedPosition();
void setFinishedPosition(mitk::Point2D);
int getFinishedOpacity(); // multiplicationfactor 0.1 (in mapper)
void setFinishedOpacity(int);
int getTerminated();
void setTerminated(int);
mitk::Point2D getTerminatedPosition();
void setTerminatedPosition(mitk::Point2D);
int getTerminatedOpacity(); // multiplicationfactor 0.1 (in mapper)
void setTerminatedOpacity(int);
protected:
- FiberBundleXThreadMonitor();
- virtual ~FiberBundleXThreadMonitor();
+ FiberBundleThreadMonitor();
+ virtual ~FiberBundleThreadMonitor();
private:
QString m_monitorBracketOpen;
mitk::Point2D m_monitorBracketOpenPosition;
QString m_monitorBracketClose;
mitk::Point2D m_monitorBracketClosePosition;
QString m_monitorHeading;
mitk::Point2D m_monitorHeadingPosition;
int m_monitorHeadingOpacity;
QString m_monitorMask;
mitk::Point2D m_monitorMaskPosition;
int m_monitorMaskOpacity;
QString m_monitorStatus;
mitk::Point2D m_monitorStatusPosition;
int m_monitorStatusOpacity;
int m_monitorStarted;
mitk::Point2D m_monitorStartedPosition;
int m_monitorStartedOpacity;
int m_monitorFinished;
mitk::Point2D m_monitorFinishedPosition;
int m_monitorFinishedOpacity;
int m_monitorTerminated;
mitk::Point2D m_monitorTerminatedPosition;
int m_monitorTerminatedOpacity;
QMutex m_startedMutex;
QMutex m_finishedMutex;
QMutex m_terminatedMutex;
QMutex m_statusMutex;
};
} // namespace mitk
-#endif /* _MITK_FiberBundleX_H */
+#endif /* _MITK_FiberBundle_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.cpp
similarity index 98%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.cpp
index e63fdb8603..93bd176a51 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.cpp
@@ -1,237 +1,237 @@
#include <mitkTrackvis.h>
#include <vtkTransformPolyDataFilter.h>
TrackVisFiberReader::TrackVisFiberReader() { m_Filename = ""; m_FilePointer = NULL; }
TrackVisFiberReader::~TrackVisFiberReader() { if (m_FilePointer) fclose( m_FilePointer ); }
// Create a TrackVis file and store standard metadata. The file is ready to append fibers.
// ---------------------------------------------------------------------------------------
-short TrackVisFiberReader::create(string filename , const mitk::FiberBundleX *fib)
+short TrackVisFiberReader::create(string filename , const mitk::FiberBundle *fib)
{
// prepare the header
for(int i=0; i<3 ;i++)
{
if (fib->GetReferenceGeometry().IsNotNull())
{
m_Header.dim[i] = fib->GetReferenceGeometry()->GetExtent(i);
m_Header.voxel_size[i] = fib->GetReferenceGeometry()->GetSpacing()[i];
m_Header.origin[i] = fib->GetReferenceGeometry()->GetOrigin()[i];
}
else
{
m_Header.dim[i] = fib->GetGeometry()->GetExtent(i);
m_Header.voxel_size[i] = fib->GetGeometry()->GetSpacing()[i];
m_Header.origin[i] = fib->GetGeometry()->GetOrigin()[i];
}
}
m_Header.n_scalars = 0;
m_Header.n_properties = 0;
sprintf(m_Header.voxel_order,"LPS");
m_Header.image_orientation_patient[0] = 1.0;
m_Header.image_orientation_patient[1] = 0.0;
m_Header.image_orientation_patient[2] = 0.0;
m_Header.image_orientation_patient[3] = 0.0;
m_Header.image_orientation_patient[4] = 1.0;
m_Header.image_orientation_patient[5] = 0.0;
m_Header.pad1[0] = 0;
m_Header.pad1[1] = 0;
m_Header.pad2[0] = 0;
m_Header.pad2[1] = 0;
m_Header.invert_x = 0;
m_Header.invert_y = 0;
m_Header.invert_z = 0;
m_Header.swap_xy = 0;
m_Header.swap_yz = 0;
m_Header.swap_zx = 0;
m_Header.n_count = 0;
m_Header.version = 1;
m_Header.hdr_size = 1000;
// write the header to the file
m_FilePointer = fopen(filename.c_str(),"w+b");
if (m_FilePointer == NULL)
{
printf("[ERROR] Unable to create file '%s'\n",filename.c_str());
return 0;
}
sprintf(m_Header.id_string,"TRACK");
if (fwrite((char*)&m_Header, 1, 1000, m_FilePointer) != 1000)
MITK_ERROR << "TrackVis::create : Error occurding during writing fiber.";
this->m_Filename = filename;
return 1;
}
// Open an existing TrackVis file and read metadata information.
// The file pointer is positiond at the beginning of fibers data
// -------------------------------------------------------------
short TrackVisFiberReader::open( string filename )
{
m_FilePointer = fopen(filename.c_str(),"r+b");
if (m_FilePointer == NULL)
{
printf("[ERROR] Unable to open file '%s'\n",filename.c_str());
return 0;
}
this->m_Filename = filename;
return fread((char*)(&m_Header), 1, 1000, m_FilePointer);
}
// Append a fiber to the file
// --------------------------
-short TrackVisFiberReader::append(const mitk::FiberBundleX *fib)
+short TrackVisFiberReader::append(const mitk::FiberBundle *fib)
{
vtkPolyData* poly = fib->GetFiberPolyData();
for (int i=0; i<fib->GetNumFibers(); i++)
{
vtkCell* cell = poly->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
unsigned int numSaved, pos = 0;
//float* tmp = new float[3*maxSteps];
std::vector< float > tmp;
tmp.reserve(3*numPoints);
numSaved = numPoints;
for(unsigned int i=0; i<numSaved ;i++)
{
double* p = points->GetPoint(i);
tmp[pos++] = p[0];
tmp[pos++] = p[1];
tmp[pos++] = p[2];
}
// write the coordinates to the file
if ( fwrite((char*)&numSaved, 1, 4, m_FilePointer) != 4 )
{
printf( "[ERROR] Problems saving the fiber!\n" );
return 1;
}
if ( fwrite((char*)&(tmp.front()), 1, 4*pos, m_FilePointer) != 4*pos )
{
printf( "[ERROR] Problems saving the fiber!\n" );
return 1;
}
}
return 0;
}
//// Read one fiber from the file
//// ----------------------------
-short TrackVisFiberReader::read( mitk::FiberBundleX* fib )
+short TrackVisFiberReader::read( mitk::FiberBundle* fib )
{
int numPoints;
vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
while (fread((char*)&numPoints, 1, 4, m_FilePointer)==4)
{
if ( numPoints <= 0 )
{
printf( "[ERROR] Trying to read a fiber with %d points!\n", numPoints );
return -1;
}
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
float tmp[3];
for(int i=0; i<numPoints; i++)
{
if (fread((char*)tmp, 1, 12, m_FilePointer) == 0)
MITK_ERROR << "TrackVis::read: Error during read.";
vtkIdType id = vtkNewPoints->InsertNextPoint(tmp);
container->GetPointIds()->InsertNextId(id);
}
vtkNewCells->InsertNextCell(container);
}
vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
fiberPolyData->SetPoints(vtkNewPoints);
fiberPolyData->SetLines(vtkNewCells);
MITK_INFO << "Coordinate convention: " << m_Header.voxel_order;
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
vtkSmartPointer< vtkMatrix4x4 > matrix = vtkSmartPointer< vtkMatrix4x4 >::New();
matrix->Identity();
if (m_Header.voxel_order[0]=='R')
matrix->SetElement(0,0,-matrix->GetElement(0,0));
if (m_Header.voxel_order[1]=='A')
matrix->SetElement(1,1,-matrix->GetElement(1,1));
if (m_Header.voxel_order[2]=='I')
matrix->SetElement(2,2,-matrix->GetElement(2,2));
geometry->SetIndexToWorldTransformByVtkMatrix(matrix);
vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
transformFilter->SetInputData(fiberPolyData);
transformFilter->SetTransform(geometry->GetVtkTransform());
transformFilter->Update();
fib->SetFiberPolyData(transformFilter->GetOutput());
mitk::Point3D origin;
origin[0]=m_Header.origin[0];
origin[1]=m_Header.origin[1];
origin[2]=m_Header.origin[2];
geometry->SetOrigin(origin);
mitk::Vector3D spacing;
spacing[0]=m_Header.voxel_size[0];
spacing[1]=m_Header.voxel_size[1];
spacing[2]=m_Header.voxel_size[2];
geometry->SetSpacing(spacing);
geometry->SetExtentInMM(0, m_Header.voxel_size[0]*m_Header.dim[0]);
geometry->SetExtentInMM(1, m_Header.voxel_size[1]*m_Header.dim[1]);
geometry->SetExtentInMM(2, m_Header.voxel_size[2]*m_Header.dim[2]);
fib->SetReferenceGeometry(dynamic_cast<mitk::BaseGeometry*>(geometry.GetPointer()));
return numPoints;
}
// Update the field in the header to the new FIBER TOTAL.
// ------------------------------------------------------
void TrackVisFiberReader::updateTotal( int totFibers )
{
fseek(m_FilePointer, 1000-12, SEEK_SET);
if (fwrite((char*)&totFibers, 1, 4, m_FilePointer) != 4)
MITK_ERROR << "[ERROR] Problems saving the fiber!";
}
void TrackVisFiberReader::writeHdr()
{
fseek(m_FilePointer, 0, SEEK_SET);
if (fwrite((char*)&m_Header, 1, 1000, m_FilePointer) != 1000)
MITK_ERROR << "[ERROR] Problems saving the fiber!";
}
// Close the TrackVis file, but keep the metadata in the header.
// -------------------------------------------------------------
void TrackVisFiberReader::close()
{
fclose(m_FilePointer);
m_FilePointer = NULL;
}
bool TrackVisFiberReader::IsTransformValid()
{
if (fabs(m_Header.image_orientation_patient[0])<=0.001 || fabs(m_Header.image_orientation_patient[3])<=0.001 || fabs(m_Header.image_orientation_patient[5])<=0.001)
return false;
return true;
}
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.h
similarity index 91%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.h
index ab48c25597..69d90c0a97 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.h
@@ -1,82 +1,82 @@
/*===================================================================
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 _TRACKVIS
#define _TRACKVIS
#include <mitkCommon.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <itkSize.h>
using namespace std;
// Structure to hold metadata of a TrackVis file
// ---------------------------------------------
struct TrackVis_header
{
char id_string[6];
short int dim[3];
float voxel_size[3];
float origin[3];
short int n_scalars;
char scalar_name[10][20];
short int n_properties;
char property_name[10][20];
char reserved[508];
char voxel_order[4];
char pad2[4];
float image_orientation_patient[6];
char pad1[2];
unsigned char invert_x;
unsigned char invert_y;
unsigned char invert_z;
unsigned char swap_xy;
unsigned char swap_yz;
unsigned char swap_zx;
int n_count;
int version;
int hdr_size;
};
// Class to handle TrackVis files.
// -------------------------------
class MitkFiberTracking_EXPORT TrackVisFiberReader
{
private:
string m_Filename;
FILE* m_FilePointer;
public:
TrackVis_header m_Header;
- short create(string m_Filename, const mitk::FiberBundleX* fib);
+ short create(string m_Filename, const mitk::FiberBundle* fib);
short open( string m_Filename );
- short read( mitk::FiberBundleX* fib );
- short append(const mitk::FiberBundleX* fib );
+ short read( mitk::FiberBundle* fib );
+ short append(const mitk::FiberBundle* fib );
void writeHdr();
void updateTotal( int totFibers );
void close();
bool IsTransformValid();
TrackVisFiberReader();
~TrackVisFiberReader();
};
#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp b/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp
index 29096f44b0..ba35536836 100644
--- a/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp
@@ -1,240 +1,240 @@
/*===================================================================
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 "mitkFiberBundleInteractor.h"
#include <mitkPointOperation.h>
#include <mitkPositionEvent.h>
#include <mitkOperationEvent.h>
#include <mitkDataNode.h>
#include <mitkPointSet.h>
#include <mitkInteractionConst.h>
#include <mitkAction.h>
#include <mitkProperties.h>
#include <mitkUndoController.h>
#include <mitkStateEvent.h>
#include <mitkState.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include "mitkBaseRenderer.h"
#include <vtkLinearTransform.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <vtkInteractorObserver.h>
// #include <qapplication.h>
mitk::FiberBundleInteractor::FiberBundleInteractor(const char * type, DataNode* dataNode)
: Interactor(type, dataNode), m_LastPosition(0)
{
m_LastPoint.Fill(0);
}
mitk::FiberBundleInteractor::~FiberBundleInteractor()
{}
void mitk::FiberBundleInteractor::SelectFiber(int position)
{
MITK_INFO << "mitk::FiberBundleInteractor::SelectFiber " << position;
mitk::PointSet* pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if (pointSet == NULL)
return;
if (pointSet->GetSize()<=0)//if List is empty, then no select of a point can be done!
return;
mitk::Point3D noPoint;//dummyPoint... not needed anyway
noPoint.Fill(0);
mitk::PointOperation* doOp = new mitk::PointOperation(OpSELECTPOINT, noPoint, position);
if (m_UndoEnabled)
{
mitk::PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT, noPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
pointSet->ExecuteOperation(doOp);
}
void mitk::FiberBundleInteractor::DeselectAllFibers()
{
MITK_INFO << "mitk::FiberBundleInteractor::DeselectAllFibers ";
mitk::PointSet* pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if (pointSet == NULL)
return;
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet();
mitk::PointSet::PointsContainer::Iterator it, end;
end = itkPointSet->GetPoints()->End();
for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
{
int position = it->Index();
PointSet::PointDataType pointData = {0, false, PTUNDEFINED};
itkPointSet->GetPointData(position, &pointData);
if ( pointData.selected )//then declare an operation which unselects this point; UndoOperation as well!
{
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation* doOp = new mitk::PointOperation(OpDESELECTPOINT, noPoint, position);
if (m_UndoEnabled)
{
mitk::PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT, noPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
pointSet->ExecuteOperation(doOp);
}
}
}
float mitk::FiberBundleInteractor::CanHandleEvent(StateEvent const* stateEvent) const
//go through all points and check, if the given Point lies near a line
{
mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
//checking if a keyevent can be handled:
if (posEvent == NULL)
{
//check, if the current state has a transition waiting for that key event.
if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
{
return 0.5;
}
else
{
return 0;
}
}
//Mouse event handling:
//on MouseMove do nothing! reimplement if needed differently
if (stateEvent->GetEvent()->GetType() == mitk::Type_MouseMove)
{
return 0;
}
//check on the right data-type
- mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_DataNode->GetData());
+ mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_DataNode->GetData());
if (bundle == NULL)
return 0;
return 0.5;
}
bool mitk::FiberBundleInteractor::ExecuteAction( Action* action, mitk::StateEvent const* stateEvent )
{
bool ok = false;//for return type bool
//checking corresponding Data; has to be a PointSet or a subclass
- mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_DataNode->GetData());
+ mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_DataNode->GetData());
if (bundle == NULL)
return false;
// Get Event and extract renderer
vtkRenderWindowInteractor *renderWindowInteractor = NULL;
/*Each case must watch the type of the event!*/
switch (action->GetActionId())
{
case AcCHECKHOVERING:
{
// QApplication::restoreOverrideCursor();
// Re-enable VTK interactor (may have been disabled previously)
if ( renderWindowInteractor != NULL )
{
renderWindowInteractor->Enable();
}
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
// Check if we have a DisplayPositionEvent
if ( dpe != NULL )
{
// Check if an object is present at the current mouse position
DataNode *pickedNode = dpe->GetPickedObjectNode();
if ( pickedNode != m_DataNode )
{
// if(pickedNode == 0)
// MITK_INFO << "picked node is NULL, no hovering";
// else
// MITK_INFO << "wrong node: " << pickedNode;
this->HandleEvent( new StateEvent( EIDNOFIGUREHOVER ) );
ok = true;
break;
}
m_CurrentPickedPoint = dpe->GetWorldPosition();
m_CurrentPickedDisplayPoint = dpe->GetDisplayPosition();
// QApplication::setOverrideCursor(Qt::UpArrowCursor);
this->HandleEvent( new StateEvent( EIDFIGUREHOVER ) );
}
ok = true;
break;
}
break;
// case AcSELECTPICKEDOBJECT:
// MITK_INFO << "FiberBundleInteractor AcSELECTPICKEDOBJECT";
// break;
// case AcDESELECTALL:
// MITK_INFO << "FiberBundleInteractor AcDESELECTALL";
// break;
case AcREMOVE:
{
MITK_INFO << "picking fiber at " << m_CurrentPickedPoint;
// QmitkStdMultiWidgetEditor::Pointer multiWidgetEditor;
// multiWidgetEditor->GetStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetSliceNavigationController()->SelectSliceByPoint(
// m_CurrentPickedPoint);
BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget1");
renderer->GetSliceNavigationController()->SelectSliceByPoint(
m_CurrentPickedPoint);
renderer = mitk::BaseRenderer::GetByName("stdmulti.widget2");
renderer->GetSliceNavigationController()->SelectSliceByPoint(
m_CurrentPickedPoint);
renderer = mitk::BaseRenderer::GetByName("stdmulti.widget3");
renderer->GetSliceNavigationController()->SelectSliceByPoint(
m_CurrentPickedPoint);
// mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
break;
default:
return Superclass::ExecuteAction( action, stateEvent );
}
return ok;
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.cpp
similarity index 82%
rename from Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
rename to Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.cpp
index cff4f67bb3..4402c2d72a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.cpp
@@ -1,206 +1,206 @@
/*===================================================================
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 "mitkFiberBundleXThreadMonitorMapper3D.h"
+#include "mitkFiberBundleThreadMonitorMapper3D.h"
#include <mitkProperties.h>
#include <vtkPropAssembly.h>
//#include <vtkTextActor.h>
#include <vtkTextProperty.h>
-mitk::FiberBundleXThreadMonitorMapper3D::FiberBundleXThreadMonitorMapper3D()
+mitk::FiberBundleThreadMonitorMapper3D::FiberBundleThreadMonitorMapper3D()
: m_FiberMonitorMapper(vtkSmartPointer<vtkPolyDataMapper>::New())
, m_TextActorClose(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorOpen(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorHeading(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorMask(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorStatus(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorStarted(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorFinished(vtkSmartPointer<vtkTextActor>::New())
, m_TextActorTerminated(vtkSmartPointer<vtkTextActor>::New())
, m_FiberAssembly(vtkPropAssembly::New())
, m_lastModifiedMonitorNodeTime(-1)
{
m_FiberAssembly->AddPart(m_TextActorClose);
m_FiberAssembly->AddPart(m_TextActorOpen);
m_FiberAssembly->AddPart(m_TextActorHeading);
m_FiberAssembly->AddPart(m_TextActorMask);
m_FiberAssembly->AddPart(m_TextActorStatus);
m_FiberAssembly->AddPart(m_TextActorStarted);
m_FiberAssembly->AddPart(m_TextActorFinished);
m_FiberAssembly->AddPart(m_TextActorTerminated);
}
-mitk::FiberBundleXThreadMonitorMapper3D::~FiberBundleXThreadMonitorMapper3D()
+mitk::FiberBundleThreadMonitorMapper3D::~FiberBundleThreadMonitorMapper3D()
{
m_FiberAssembly->Delete();
}
-const mitk::FiberBundleXThreadMonitor* mitk::FiberBundleXThreadMonitorMapper3D::GetInput()
+const mitk::FiberBundleThreadMonitor* mitk::FiberBundleThreadMonitorMapper3D::GetInput()
{
- return static_cast<const mitk::FiberBundleXThreadMonitor * > ( GetDataNode()->GetData() );
+ return static_cast<const mitk::FiberBundleThreadMonitor * > ( GetDataNode()->GetData() );
}
/*
This method is called once the mapper gets new input,
for UI rotation or changes in colorcoding this method is NOT called
*/
-void mitk::FiberBundleXThreadMonitorMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
+void mitk::FiberBundleThreadMonitorMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
const DataNode *node = this->GetDataNode();
if (m_lastModifiedMonitorNodeTime >= node->GetMTime())
return;
m_lastModifiedMonitorNodeTime = node->GetMTime();
// MITK_INFO << m_LastUpdateTime;
- FiberBundleXThreadMonitor* monitor = dynamic_cast<FiberBundleXThreadMonitor * > ( GetDataNode()->GetData() );
+ FiberBundleThreadMonitor* monitor = dynamic_cast<FiberBundleThreadMonitor * > ( GetDataNode()->GetData() );
// m_TextActor->SetInput( monitor->getTextL1().toStdString().c_str() );
m_TextActorClose->SetInput( monitor->getBracketClose().toStdString().c_str() );
vtkTextProperty* tpropClose = m_TextActorClose->GetTextProperty();
//tprop->SetFontFamilyToArial ();
//tprop->SetLineSpacing(1.0);
tpropClose->SetFontSize(16);
tpropClose->SetColor(0.85,0.8,0.8);
m_TextActorClose->SetDisplayPosition( monitor->getBracketClosePosition()[0], monitor->getBracketClosePosition()[1] );
//m_TextActorClose->Modified();
m_TextActorOpen->SetInput( monitor->getBracketOpen().toStdString().c_str() );
vtkTextProperty* tpropOpen = m_TextActorOpen->GetTextProperty();
//tprop->SetFontFamilyToArial ();
//tprop->SetLineSpacing(1.0);
tpropOpen->SetFontSize(16);
tpropOpen->SetColor(0.85,0.8,0.8);
m_TextActorOpen->SetDisplayPosition( monitor->getBracketOpenPosition()[0], monitor->getBracketOpenPosition()[1] );
//m_TextActorOpen->Modified();
m_TextActorHeading->SetInput( monitor->getHeading().toStdString().c_str() );
vtkTextProperty* tpropHeading = m_TextActorHeading->GetTextProperty();
tpropHeading->SetFontSize(12);
tpropHeading->SetOpacity( monitor->getHeadingOpacity() * 0.1 );
tpropHeading->SetColor(0.85,0.8,0.8);
m_TextActorHeading->SetDisplayPosition( monitor->getHeadingPosition()[0], monitor->getHeadingPosition()[1] );
//m_TextActorHeading->Modified();
m_TextActorMask->SetInput( monitor->getMask().toStdString().c_str() );
vtkTextProperty* tpropMask = m_TextActorMask->GetTextProperty();
tpropMask->SetFontSize(12);
tpropMask->SetOpacity( monitor->getMaskOpacity() * 0.1 );
tpropMask->SetColor(1.0,1.0,1.0);
m_TextActorMask->SetDisplayPosition( monitor->getMaskPosition()[0], monitor->getMaskPosition()[1] );
//m_TextActorHeading->Modified();
m_TextActorStatus->SetInput(monitor->getStatus().toStdString().c_str());
vtkTextProperty* tpropStatus = m_TextActorStatus->GetTextProperty();
tpropStatus->SetFontSize(10);
tpropStatus->SetOpacity( monitor->getStatusOpacity() * 0.1 );
tpropStatus->SetColor(0.85,0.8,0.8);
m_TextActorStatus->SetDisplayPosition( monitor->getStatusPosition()[0], monitor->getStatusPosition()[1] );
//m_TextActorStatus->Modified();
m_TextActorStarted->SetInput(QString::number(monitor->getStarted()).toStdString().c_str());
vtkTextProperty* tpropStarted = m_TextActorStarted->GetTextProperty();
tpropStarted->SetFontSize(12);
tpropStarted->SetOpacity( monitor->getStartedOpacity() * 0.1 );
tpropStarted->SetColor(0.0,1.0,0.0);
m_TextActorStarted->SetDisplayPosition( monitor->getStartedPosition()[0], monitor->getStartedPosition()[1] );
//m_TextActorStarted->Modified();
m_TextActorFinished->SetInput(QString::number(monitor->getFinished()).toStdString().c_str());
vtkTextProperty* tpropFinished = m_TextActorFinished->GetTextProperty();
tpropFinished->SetFontSize(12);
tpropFinished->SetOpacity( monitor->getFinishedOpacity() * 0.1 );
tpropFinished->SetColor(1.0,1.0,1.0);
m_TextActorFinished->SetDisplayPosition( monitor->getFinishedPosition()[0], monitor->getFinishedPosition()[1] );
//m_TextActorFinished->Modified();
m_TextActorTerminated->SetInput(QString::number(monitor->getTerminated()).toStdString().c_str());
vtkTextProperty* tpropTerminated = m_TextActorTerminated->GetTextProperty();
tpropTerminated->SetFontSize(12);
tpropTerminated->SetOpacity( monitor->getTerminatedOpacity() * 0.1 );
tpropTerminated->SetColor(1.0,1.0,1.0);
m_TextActorTerminated->SetDisplayPosition( monitor->getTerminatedPosition()[0], monitor->getTerminatedPosition()[1] );
//m_TextActorTerminated->Modified();
// Calculate time step of the input data for the specified renderer (integer value)
// this method is implemented in mitkMapper
// this->CalculateTimeStep( renderer );
}
-void mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+void mitk::FiberBundleThreadMonitorMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
-// MITK_INFO << "FiberBundleXxXXMapper3D()SetDefaultProperties";
+// MITK_INFO << "FiberBundlexXXMapper3D()SetDefaultProperties";
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
-vtkProp* mitk::FiberBundleXThreadMonitorMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
+vtkProp* mitk::FiberBundleThreadMonitorMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
- //MITK_INFO << "FiberBundleXxXXMapper3D()GetVTKProp";
+ //MITK_INFO << "FiberBundlexXXMapper3D()GetVTKProp";
//this->GenerateData();
return m_FiberAssembly;
}
-void mitk::FiberBundleXThreadMonitorMapper3D::ApplyProperties(mitk::BaseRenderer* renderer)
+void mitk::FiberBundleThreadMonitorMapper3D::ApplyProperties(mitk::BaseRenderer* renderer)
{
-// MITK_INFO << "FiberBundleXXXXMapper3D ApplyProperties(renderer)";
+// MITK_INFO << "FiberBundleXXXMapper3D ApplyProperties(renderer)";
}
-void mitk::FiberBundleXThreadMonitorMapper3D::UpdateVtkObjects()
+void mitk::FiberBundleThreadMonitorMapper3D::UpdateVtkObjects()
{
-// MITK_INFO << "FiberBundleXxxXMapper3D UpdateVtkObjects()";
+// MITK_INFO << "FiberBundlexxXMapper3D UpdateVtkObjects()";
}
-void mitk::FiberBundleXThreadMonitorMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
+void mitk::FiberBundleThreadMonitorMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
{
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.h
similarity index 79%
rename from Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
rename to Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.h
index 270137adc9..653a9a0f21 100644
--- a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
+++ b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.h
@@ -1,90 +1,90 @@
/*===================================================================
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 FiberBundleXThreadMonitorMapper3D_H_HEADER_INCLUDED
-#define FiberBundleXThreadMonitorMapper3D_H_HEADER_INCLUDED
+#ifndef FiberBundleThreadMonitorMapper3D_H_HEADER_INCLUDED
+#define FiberBundleThreadMonitorMapper3D_H_HEADER_INCLUDED
//#include <mitkBaseData.h> //?? necessary
#include <MitkFiberTrackingExports.h>
#include <mitkVtkMapper.h>
-#include <mitkFiberBundleXThreadMonitor.h>
+#include <mitkFiberBundleThreadMonitor.h>
#include <vtkSmartPointer.h>
#include <vtkPolyDataMapper.h>
#include <vtkTextActor.h>
class vtkPropAssembly;
namespace mitk {
//##Documentation
- //## @brief Mapper for FiberBundleX
+ //## @brief Mapper for FiberBundle
//## @ingroup Mapper
- class MitkFiberTracking_EXPORT FiberBundleXThreadMonitorMapper3D : public VtkMapper
+ class MitkFiberTracking_EXPORT FiberBundleThreadMonitorMapper3D : public VtkMapper
{
public:
- mitkClassMacro(FiberBundleXThreadMonitorMapper3D, VtkMapper);
+ mitkClassMacro(FiberBundleThreadMonitorMapper3D, VtkMapper);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
//========== essential implementation for 3D mapper ========
- const FiberBundleXThreadMonitor* GetInput();
+ const FiberBundleThreadMonitor* GetInput();
virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer); //looks like depricated.. should be replaced bz GetViewProp()
static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
virtual void ApplyProperties(mitk::BaseRenderer* renderer);
static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper);
virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
//=========================================================
protected:
- FiberBundleXThreadMonitorMapper3D();
- virtual ~FiberBundleXThreadMonitorMapper3D();
+ FiberBundleThreadMonitorMapper3D();
+ virtual ~FiberBundleThreadMonitorMapper3D();
void UpdateVtkObjects(); //??
vtkSmartPointer<vtkPolyDataMapper> m_FiberMonitorMapper;
vtkSmartPointer<vtkTextActor> m_TextActorClose;
vtkSmartPointer<vtkTextActor> m_TextActorOpen;
vtkSmartPointer<vtkTextActor> m_TextActorHeading;
vtkSmartPointer<vtkTextActor> m_TextActorMask;
vtkSmartPointer<vtkTextActor> m_TextActorStatus;
vtkSmartPointer<vtkTextActor> m_TextActorStarted;
vtkSmartPointer<vtkTextActor> m_TextActorFinished;
vtkSmartPointer<vtkTextActor> m_TextActorTerminated;
vtkPropAssembly* m_FiberAssembly;
private:
double m_lastModifiedMonitorNodeTime;
};
} // end namespace mitk
-#endif /* FiberBundleXMapper3D_H_HEADER_INCLUDED */
+#endif /* FiberBundleMapper3D_H_HEADER_INCLUDED */
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
index 3b03f3f67d..712d4ecde0 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(mitkFiberBundleReaderWriterTest mitkFiberBundleReaderWriterTest)
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(mitkFiberfoxAddArtifactsToDwiTest mitkFiberfoxAddArtifactsToDwiTest)
ENDIF()
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake b/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
index 5ac537c171..a71e6776fa 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
@@ -1,14 +1,14 @@
SET(MODULE_CUSTOM_TESTS
- mitkFiberBundleXReaderWriterTest.cpp
+ mitkFiberBundleReaderWriterTest.cpp
mitkGibbsTrackingTest.cpp
mitkStreamlineTrackingTest.cpp
mitkPeakExtractionTest.cpp
mitkLocalFiberPlausibilityTest.cpp
mitkFiberTransformationTest.cpp
mitkFiberExtractionTest.cpp
mitkFiberGenerationTest.cpp
mitkFiberfoxSignalGenerationTest.cpp
mitkFiberfoxAddArtifactsToDwiTest.cpp
)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleXReaderWriterTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleReaderWriterTest.cpp
similarity index 79%
rename from Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleXReaderWriterTest.cpp
rename to Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleReaderWriterTest.cpp
index 6e048ee7fe..1105138c17 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleXReaderWriterTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleReaderWriterTest.cpp
@@ -1,71 +1,71 @@
/*===================================================================
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 <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkBaseData.h>
#include <itksys/SystemTools.hxx>
#include <mitkTestingConfig.h>
#include <mitkIOUtil.h>
#include "mitkTestFixture.h"
-class mitkFiberBundleXReaderWriterTestSuite : public mitk::TestFixture
+class mitkFiberBundleReaderWriterTestSuite : public mitk::TestFixture
{
- CPPUNIT_TEST_SUITE(mitkFiberBundleXReaderWriterTestSuite);
+ CPPUNIT_TEST_SUITE(mitkFiberBundleReaderWriterTestSuite);
MITK_TEST(Equal_SaveLoad_ReturnsTrue);
CPPUNIT_TEST_SUITE_END();
private:
/** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
- mitk::FiberBundleX::Pointer fib1;
- mitk::FiberBundleX::Pointer fib2;
+ mitk::FiberBundle::Pointer fib1;
+ mitk::FiberBundle::Pointer fib2;
public:
void setUp()
{
fib1 = NULL;
fib2 = NULL;
std::string filename = GetTestDataFilePath("DiffusionImaging/fiberBundleX.fib");
std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load( filename);
mitk::BaseData::Pointer baseData = fibInfile.at(0);
- fib1 = dynamic_cast<mitk::FiberBundleX*>(baseData.GetPointer());
+ fib1 = dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
}
void tearDown()
{
fib1 = NULL;
fib2 = NULL;
}
void Equal_SaveLoad_ReturnsTrue()
{
mitk::IOUtil::Save(fib1.GetPointer(), std::string(MITK_TEST_OUTPUT_DIR)+"/writerTest.fib");
std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(std::string(MITK_TEST_OUTPUT_DIR)+"/writerTest.fib");
- fib2 = dynamic_cast<mitk::FiberBundleX*>(baseData[0].GetPointer());
+ fib2 = dynamic_cast<mitk::FiberBundle*>(baseData[0].GetPointer());
CPPUNIT_ASSERT_MESSAGE("Should be equal", fib1->Equals(fib2));
//MITK_ASSERT_EQUAL(fib1, fib2, "A saved and re-loaded file should be equal");
}
};
-MITK_TEST_SUITE_REGISTRATION(mitkFiberBundleXReaderWriter)
+MITK_TEST_SUITE_REGISTRATION(mitkFiberBundleReaderWriter)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
index 847be12cb8..dc6fe5cc97 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
@@ -1,109 +1,109 @@
/*===================================================================
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 <mitkFiberBundle.h>
#include <mitkPlanarFigure.h>
#include <mitkPlanarFigureComposite.h>
#include <mitkImageCast.h>
#include <vtkDebugLeaks.h>
/**Documentation
* Test if fiber transfortaiom methods work correctly
*/
int mitkFiberExtractionTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkFiberExtractionTest");
/// \todo Fix VTK memory leaks. Bug 18097.
vtkDebugLeaks::SetExitError(0);
MITK_INFO << "argc: " << argc;
MITK_TEST_CONDITION_REQUIRED(argc==13,"check for input data")
try{
- mitk::FiberBundleX::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
- mitk::FiberBundleX::Pointer testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
+ mitk::FiberBundle::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
+ mitk::FiberBundle::Pointer testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
// test planar figure based extraction
mitk::PlanarFigure::Pointer pf1 = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
mitk::PlanarFigure::Pointer pf2 = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
mitk::PlanarFigure::Pointer pf3 = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
MITK_INFO << "TEST1";
mitk::PlanarFigureComposite::Pointer pfc1 = mitk::PlanarFigureComposite::New();
pfc1->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
pfc1->addPlanarFigure(dynamic_cast<mitk::BaseData*>(pf2.GetPointer()));
pfc1->addPlanarFigure(dynamic_cast<mitk::BaseData*>(pf3.GetPointer()));
MITK_INFO << "TEST2";
mitk::PlanarFigureComposite::Pointer pfc2 = mitk::PlanarFigureComposite::New();
pfc2->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
pfc2->addPlanarFigure(dynamic_cast<mitk::BaseData*>(pf1.GetPointer()));
pfc2->addPlanarFigure(pfc1.GetPointer());
MITK_INFO << "TEST3";
- mitk::FiberBundleX::Pointer extractedFibs = groundTruthFibs->ExtractFiberSubset(pfc2);
+ mitk::FiberBundle::Pointer extractedFibs = groundTruthFibs->ExtractFiberSubset(pfc2);
MITK_INFO << "TEST4";
MITK_TEST_CONDITION_REQUIRED(extractedFibs->Equals(testFibs),"check planar figure extraction")
MITK_INFO << "TEST5";
// test subtraction and addition
- mitk::FiberBundleX::Pointer notExtractedFibs = groundTruthFibs->SubtractBundle(extractedFibs);
+ mitk::FiberBundle::Pointer notExtractedFibs = groundTruthFibs->SubtractBundle(extractedFibs);
MITK_INFO << argv[11];
- testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
+ testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
MITK_TEST_CONDITION_REQUIRED(notExtractedFibs->Equals(testFibs),"check bundle subtraction")
- mitk::FiberBundleX::Pointer joinded = extractedFibs->AddBundle(notExtractedFibs);
- testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
+ mitk::FiberBundle::Pointer joinded = extractedFibs->AddBundle(notExtractedFibs);
+ testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
MITK_TEST_CONDITION_REQUIRED(joinded->Equals(testFibs),"check bundle addition")
// test binary image based extraction
mitk::Image::Pointer mitkRoiImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
typedef itk::Image< unsigned char, 3 > itkUCharImageType;
itkUCharImageType::Pointer itkRoiImage = itkUCharImageType::New();
mitk::CastToItkImage(mitkRoiImage, itkRoiImage);
- mitk::FiberBundleX::Pointer inside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, false);
+ mitk::FiberBundle::Pointer inside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, false);
mitk::IOUtil::SaveBaseData(inside, mitk::IOUtil::GetTempPath()+"inside.fib");
- mitk::FiberBundleX::Pointer outside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, true);
+ mitk::FiberBundle::Pointer outside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, true);
mitk::IOUtil::SaveBaseData(outside, mitk::IOUtil::GetTempPath()+"outside.fib");
- mitk::FiberBundleX::Pointer passing = groundTruthFibs->ExtractFiberSubset(itkRoiImage, true);
+ mitk::FiberBundle::Pointer passing = groundTruthFibs->ExtractFiberSubset(itkRoiImage, true);
mitk::IOUtil::SaveBaseData(passing, mitk::IOUtil::GetTempPath()+"passing.fib");
- mitk::FiberBundleX::Pointer ending = groundTruthFibs->ExtractFiberSubset(itkRoiImage, false);
+ mitk::FiberBundle::Pointer ending = groundTruthFibs->ExtractFiberSubset(itkRoiImage, false);
mitk::IOUtil::SaveBaseData(ending, mitk::IOUtil::GetTempPath()+"ending.fib");
- testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
+ testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
MITK_TEST_CONDITION_REQUIRED(inside->Equals(testFibs),"check inside mask extraction")
- testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
+ testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
MITK_TEST_CONDITION_REQUIRED(outside->Equals(testFibs),"check outside mask extraction")
- testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
+ testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
MITK_TEST_CONDITION_REQUIRED(passing->Equals(testFibs),"check passing mask extraction")
- testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
+ testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
MITK_TEST_CONDITION_REQUIRED(ending->Equals(testFibs),"check ending in mask extraction")
}
catch(...) {
return EXIT_FAILURE;
}
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp
index 2e06ab9d38..c4f2d01f28 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp
@@ -1,78 +1,78 @@
/*===================================================================
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 <mitkFiberBundle.h>
#include <mitkPlanarEllipse.h>
#include <itkFibersFromPlanarFiguresFilter.h>
/**Documentation
* Test if fiber transfortaiom methods work correctly
*/
int mitkFiberGenerationTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkFiberGenerationTest");
MITK_TEST_CONDITION_REQUIRED(argc==6,"check for input data")
try{
mitk::PlanarEllipse::Pointer pf1 = dynamic_cast<mitk::PlanarEllipse*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
mitk::PlanarEllipse::Pointer pf2 = dynamic_cast<mitk::PlanarEllipse*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
mitk::PlanarEllipse::Pointer pf3 = dynamic_cast<mitk::PlanarEllipse*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
- mitk::FiberBundleX::Pointer uniform = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
- mitk::FiberBundleX::Pointer gaussian = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
+ mitk::FiberBundle::Pointer uniform = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
+ mitk::FiberBundle::Pointer gaussian = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
FiberGenerationParameters parameters;
vector< mitk::PlanarEllipse::Pointer > fid; fid.push_back(pf1); fid.push_back(pf2); fid.push_back(pf3);
vector< unsigned int > flip; flip.push_back(0); flip.push_back(0); flip.push_back(0);
parameters.m_Fiducials.push_back(fid); parameters.m_FlipList.push_back(flip);
parameters.m_Density = 50;
parameters.m_Tension = 0;
parameters.m_Continuity = 0;
parameters.m_Bias = 0;
parameters.m_Sampling = 1;
parameters.m_Variance = 0.1;
// check uniform fiber distribution
{
itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
parameters.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
filter->SetParameters(parameters);
filter->Update();
- vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
+ vector< mitk::FiberBundle::Pointer > fiberBundles = filter->GetFiberBundles();
MITK_TEST_CONDITION_REQUIRED(uniform->Equals(fiberBundles.at(0)),"check uniform bundle")
}
// check gaussian fiber distribution
{
itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
parameters.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
filter->SetParameters(parameters);
filter->SetParameters(parameters);
filter->Update();
- vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
+ vector< mitk::FiberBundle::Pointer > fiberBundles = filter->GetFiberBundles();
MITK_TEST_CONDITION_REQUIRED(gaussian->Equals(fiberBundles.at(0)),"check gaussian bundle")
}
}
catch(...) {
return EXIT_FAILURE;
}
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp
index 764fcf9fe1..9e48b3c7f1 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp
@@ -1,53 +1,53 @@
/*===================================================================
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 <mitkFiberBundle.h>
/**Documentation
* Test if fiber transfortaiom methods work correctly
*/
int mitkFiberTransformationTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkFiberTransformationTest");
MITK_TEST_CONDITION_REQUIRED(argc==3,"check for input data")
try{
- mitk::FiberBundleX::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
- mitk::FiberBundleX::Pointer transformedFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
+ mitk::FiberBundle::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
+ mitk::FiberBundle::Pointer transformedFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
groundTruthFibs->RotateAroundAxis(90, 45, 10);
groundTruthFibs->TranslateFibers(2, 3, 5);
groundTruthFibs->ScaleFibers(1, 0.1, 1.3);
groundTruthFibs->RemoveLongFibers(150);
groundTruthFibs->RemoveShortFibers(20);
groundTruthFibs->ResampleSpline(1.0);
groundTruthFibs->ApplyCurvatureThreshold(3.0, true);
groundTruthFibs->MirrorFibers(0);
groundTruthFibs->MirrorFibers(1);
groundTruthFibs->MirrorFibers(2);
MITK_TEST_CONDITION_REQUIRED(groundTruthFibs->Equals(transformedFibs),"check transformation")
}
catch(...) {
return EXIT_FAILURE;
}
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
index 53622ec71b..92284a7db5 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
@@ -1,199 +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 <mitkFiberBundle.h>
#include <itkAddArtifactsToDwiImageFilter.h>
#include <mitkFiberfoxParameters.h>
#include <mitkStickModel.h>
#include <mitkTensorModel.h>
#include <mitkBallModel.h>
#include <mitkDotModel.h>
#include <mitkAstroStickModel.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::Image::Pointer m_InputDwi;
FiberfoxParameters<short> m_Parameters;
public:
void setUp()
{
// reference files
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 = 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::Image::Pointer refImage = NULL;
if (!testFileName.empty())
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(itkVectorImagePointer);
artifactsToDwiFilter->SetParameters(m_Parameters);
CPPUNIT_ASSERT_NO_THROW(artifactsToDwiFilter->Update());
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())
{
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 1e73c01dce..7265da47be 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
@@ -1,293 +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 <mitkFiberBundle.h>
#include <itkTractsToDWIImageFilter.h>
#include <mitkFiberfoxParameters.h>
#include <mitkStickModel.h>
#include <mitkTensorModel.h>
#include <mitkBallModel.h>
#include <mitkDotModel.h>
#include <mitkAstroStickModel.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::Image::Pointer refImage, string message)
+void StartSimulation(FiberfoxParameters<double> parameters, FiberBundle::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::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())
{
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.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());
+ FiberBundle::Pointer fiberBundle = dynamic_cast<FiberBundle*>(mitk::IOUtil::Load(argv[1])[0].GetPointer());
// reference diffusion weighted images
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 = 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/mitkGibbsTrackingTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
index cbfe9626ed..635d5d0a28 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
@@ -1,92 +1,92 @@
/*===================================================================
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 <mitkImageCast.h>
#include <mitkQBallImage.h>
#include <itkGibbsTrackingFilter.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkIOUtil.h>
using namespace mitk;
/**Documentation
* Test for gibbs tracking filter
*/
int mitkGibbsTrackingTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkGibbsTrackingTest");
MITK_TEST_CONDITION_REQUIRED(argc>4,"check for input data")
QBallImage::Pointer mitkQballImage;
Image::Pointer mitkMaskImage;
- mitk::FiberBundleX::Pointer fib1;
+ mitk::FiberBundle::Pointer fib1;
try{
MITK_INFO << "Q-Ball image: " << argv[1];
MITK_INFO << "Mask image: " << argv[2];
MITK_INFO << "Parameter file: " << argv[3];
MITK_INFO << "Reference bundle: " << argv[4];
std::vector<mitk::BaseData::Pointer> infile = mitk::IOUtil::Load( argv[1]);
mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(mitkQballImage.IsNotNull(),"check qball image")
infile = mitk::IOUtil::Load( argv[2] );
mitkMaskImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(mitkMaskImage.IsNotNull(),"check mask image")
infile = mitk::IOUtil::Load( argv[4]);
- fib1 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
+ fib1 = dynamic_cast<mitk::FiberBundle*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(fib1.IsNotNull(),"check fiber bundle")
typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
typedef itk::Image<float,3> MaskImgType;
typedef itk::GibbsTrackingFilter<OdfVectorImgType> GibbsTrackingFilterType;
OdfVectorImgType::Pointer itk_qbi = OdfVectorImgType::New();
mitk::CastToItkImage(mitkQballImage, itk_qbi);
MaskImgType::Pointer itk_mask = MaskImgType::New();
mitk::CastToItkImage(mitkMaskImage, itk_mask);
GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
gibbsTracker->SetMaskImage(itk_mask);
gibbsTracker->SetDuplicateImage(false);
gibbsTracker->SetRandomSeed(1);
gibbsTracker->SetLoadParameterFile(argv[3]);
gibbsTracker->Update();
- mitk::FiberBundleX::Pointer fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
+ mitk::FiberBundle::Pointer fib2 = mitk::FiberBundle::New(gibbsTracker->GetFiberBundle());
MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "check if gibbs tracking has changed");
gibbsTracker->SetRandomSeed(0);
gibbsTracker->Update();
- fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
+ fib2 = mitk::FiberBundle::New(gibbsTracker->GetFiberBundle());
MITK_TEST_CONDITION_REQUIRED(!fib1->Equals(fib2), "check if gibbs tracking has changed after wrong seed");
}
catch(...)
{
return EXIT_FAILURE;
}
// always end with this!
MITK_TEST_END();
}
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
index 99828d891b..556c6d695c 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
@@ -1,166 +1,166 @@
/*===================================================================
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 <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <itkEvaluateDirectionImagesFilter.h>
#include <itkTractsToVectorImageFilter.h>
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <fstream>
#include <itksys/SystemTools.hxx>
#include <mitkTestingMacros.h>
#include <mitkCompareImageDataFilter.h>
#include <mitkCoreObjectFactory.h>
#define _USE_MATH_DEFINES
#include <math.h>
using namespace std;
int mitkLocalFiberPlausibilityTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkLocalFiberPlausibilityTest");
MITK_TEST_CONDITION_REQUIRED(argc==8,"check for input data")
string fibFile = argv[1];
vector< string > referenceImages;
referenceImages.push_back(argv[2]);
referenceImages.push_back(argv[3]);
string LDFP_ERROR_IMAGE = argv[4];
string LDFP_NUM_DIRECTIONS = argv[5];
string LDFP_VECTOR_FIELD = argv[6];
string LDFP_ERROR_IMAGE_IGNORE = argv[7];
float angularThreshold = 30;
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;
typedef itk::EvaluateDirectionImagesFilter< float > EvaluationFilterType;
// load fiber bundle
- mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
// load reference directions
ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
for (unsigned int i=0; i<referenceImages.size(); i++)
{
try
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
}
catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
}
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
itkMaskImage->SetSpacing( dirImg->GetSpacing() );
itkMaskImage->SetOrigin( dirImg->GetOrigin() );
itkMaskImage->SetDirection( dirImg->GetDirection() );
itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->Allocate();
itkMaskImage->FillBuffer(1);
// 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(true);
fOdfFilter->SetMaxNumDirections(3);
fOdfFilter->SetSizeThreshold(0.3);
fOdfFilter->SetUseWorkingCopy(false);
fOdfFilter->SetNumberOfThreads(1);
fOdfFilter->Update();
ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
// Get directions and num directions image
ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
mitk::Image::Pointer mitkNumDirImage = mitk::Image::New();
mitkNumDirImage->InitializeByItk( numDirImage.GetPointer() );
mitkNumDirImage->SetVolume( numDirImage->GetBufferPointer() );
- mitk::FiberBundleX::Pointer testDirections = fOdfFilter->GetOutputFiberBundle();
+ mitk::FiberBundle::Pointer testDirections = fOdfFilter->GetOutputFiberBundle();
//mitk::IOUtil::SaveImage(mitkNumDirImage, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_NUM_DIRECTIONS.nrrd");
//mitk::IOUtil::SaveBaseData(testDirections, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_VECTOR_FIELD.fib");
// evaluate directions with missing directions
EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
evaluationFilter->SetImageSet(directionImageContainer);
evaluationFilter->SetReferenceImageSet(referenceImageContainer);
evaluationFilter->SetMaskImage(itkMaskImage);
evaluationFilter->SetIgnoreMissingDirections(false);
evaluationFilter->Update();
EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
mitk::Image::Pointer mitkAngularErrorImage = mitk::Image::New();
mitkAngularErrorImage->InitializeByItk( angularErrorImage.GetPointer() );
mitkAngularErrorImage->SetVolume( angularErrorImage->GetBufferPointer() );
//mitk::IOUtil::SaveImage(mitkAngularErrorImage, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_ERROR_IMAGE.nrrd");
// evaluate directions without missing directions
evaluationFilter->SetIgnoreMissingDirections(true);
evaluationFilter->Update();
EvaluationFilterType::OutputImageType::Pointer angularErrorImageIgnore = evaluationFilter->GetOutput(0);
mitk::Image::Pointer mitkAngularErrorImageIgnore = mitk::Image::New();
mitkAngularErrorImageIgnore->InitializeByItk( angularErrorImageIgnore.GetPointer() );
mitkAngularErrorImageIgnore->SetVolume( angularErrorImageIgnore->GetBufferPointer() );
//mitk::IOUtil::SaveImage(mitkAngularErrorImageIgnore, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_ERROR_IMAGE_IGNORE.nrrd");
mitk::Image::Pointer gtAngularErrorImageIgnore = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE_IGNORE)->GetData());
mitk::Image::Pointer gtAngularErrorImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE)->GetData());
mitk::Image::Pointer gtNumTestDirImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_NUM_DIRECTIONS)->GetData());
- mitk::FiberBundleX::Pointer gtTestDirections = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(LDFP_VECTOR_FIELD)->GetData());
+ mitk::FiberBundle::Pointer gtTestDirections = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(LDFP_VECTOR_FIELD)->GetData());
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImageIgnore, mitkAngularErrorImageIgnore, 0.01, true), "Check if error images are equal (ignored missing directions).");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImage, mitkAngularErrorImage, 0.01, true), "Check if error images are equal.");
MITK_TEST_CONDITION_REQUIRED(testDirections->Equals(gtTestDirections), "Check if vector fields are equal.");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtNumTestDirImage, mitkNumDirImage, 0.1, true), "Check if num direction images 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/FiberTracking/Testing/mitkPeakExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
index 6e1f252e20..fd106794d7 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
@@ -1,106 +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.
===================================================================*/
#include <itkImageFileWriter.h>
#include <itkResampleImageFilter.h>
#include <itkFiniteDiffOdfMaximaExtractionFilter.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::FiberBundle::Pointer fib1 = filter->GetOutputFiberBundle();
MITK_INFO << "Loading reference ...";
std::vector<mitk::BaseData::Pointer> infile = mitk::IOUtil::Load( referenceFileName );
- mitk::FiberBundleX::Pointer fib2 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
+ mitk::FiberBundle::Pointer fib2 = dynamic_cast<mitk::FiberBundle*>(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/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp
index a075bbf718..144c64b1a4 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp
@@ -1,127 +1,127 @@
/*===================================================================
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 <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkStreamlineTrackingFilter.h>
#include <itkDiffusionTensor3D.h>
#include <mitkTestingMacros.h>
using namespace std;
int mitkStreamlineTrackingTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkStreamlineTrackingTest");
MITK_TEST_CONDITION_REQUIRED(argc>3,"check for input data")
string dtiFileName = argv[1];
string maskFileName = argv[2];
string referenceFileName = argv[3];
MITK_INFO << "DTI file: " << dtiFileName;
MITK_INFO << "Mask file: " << maskFileName;
MITK_INFO << "Reference fiber file: " << referenceFileName;
float minFA = 0.05;
float minCurv = -1;
float stepSize = -1;
float tendf = 1;
float tendg = 0;
float minLength = 20;
int numSeeds = 1;
bool interpolate = true;
try
{
MITK_INFO << "Loading tensor image ...";
typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(dtiFileName)->GetData());
ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
mitk::CastToItkImage(mitkTensorImage, itk_dti);
MITK_INFO << "Loading seed image ...";
typedef itk::Image< unsigned char, 3 > ItkUCharImageType;
mitk::Image::Pointer mitkSeedImage = mitk::IOUtil::LoadImage(maskFileName);
MITK_INFO << "Loading mask image ...";
mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(maskFileName);
// instantiate tracker
typedef itk::StreamlineTrackingFilter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetInput(itk_dti);
filter->SetSeedsPerVoxel(numSeeds);
filter->SetFaThreshold(minFA);
filter->SetMinCurvatureRadius(minCurv);
filter->SetStepSize(stepSize);
filter->SetF(tendf);
filter->SetG(tendg);
filter->SetInterpolate(interpolate);
filter->SetMinTractLength(minLength);
filter->SetNumberOfThreads(1);
if (mitkSeedImage.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(mitkSeedImage, mask);
filter->SetSeedImage(mask);
}
if (mitkMaskImage.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(mitkMaskImage, mask);
filter->SetMaskImage(mask);
}
filter->Update();
vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
- mitk::FiberBundleX::Pointer fib1 = mitk::FiberBundleX::New(fiberBundle);
+ mitk::FiberBundle::Pointer fib1 = mitk::FiberBundle::New(fiberBundle);
- mitk::FiberBundleX::Pointer fib2 = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(referenceFileName)->GetData());
+ mitk::FiberBundle::Pointer fib2 = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(referenceFileName)->GetData());
MITK_TEST_CONDITION_REQUIRED(fib2.IsNotNull(), "Check if reference tractogram is not null.");
bool ok = fib1->Equals(fib2);
if (!ok)
{
MITK_WARN << "TEST FAILED. TRACTOGRAMS ARE NOT EQUAL!";
mitk::IOUtil::SaveBaseData(fib1, mitk::IOUtil::GetTempPath()+"testBundle.fib");
mitk::IOUtil::SaveBaseData(fib2, mitk::IOUtil::GetTempPath()+"refBundle.fib");
MITK_INFO << "OUTPUT: " << mitk::IOUtil::GetTempPath();
}
MITK_TEST_CONDITION_REQUIRED(ok, "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/FiberTracking/files.cmake b/Modules/DiffusionImaging/FiberTracking/files.cmake
index 71bb1066a5..adc2368cf2 100644
--- a/Modules/DiffusionImaging/FiberTracking/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/files.cmake
@@ -1,78 +1,78 @@
set(CPP_FILES
mitkFiberTrackingModuleActivator.cpp
## IO datastructures
- IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
- IODataStructures/FiberBundleX/mitkTrackvis.cpp
+ IODataStructures/FiberBundle/mitkFiberBundle.cpp
+ IODataStructures/FiberBundle/mitkTrackvis.cpp
IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
# Interactions
Interactions/mitkFiberBundleInteractor.cpp
# Tractography
Algorithms/GibbsTracking/mitkParticleGrid.cpp
Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.cpp
Algorithms/GibbsTracking/mitkEnergyComputer.cpp
Algorithms/GibbsTracking/mitkGibbsEnergyComputer.cpp
Algorithms/GibbsTracking/mitkFiberBuilder.cpp
Algorithms/GibbsTracking/mitkSphereInterpolator.cpp
)
set(H_FILES
- # DataStructures -> FiberBundleX
- IODataStructures/FiberBundleX/mitkFiberBundleX.h
- IODataStructures/FiberBundleX/mitkTrackvis.h
+ # DataStructures -> FiberBundle
+ IODataStructures/FiberBundle/mitkFiberBundle.h
+ IODataStructures/FiberBundle/mitkTrackvis.h
IODataStructures/mitkFiberfoxParameters.h
# Algorithms
Algorithms/itkTractDensityImageFilter.h
Algorithms/itkTractsToFiberEndingsImageFilter.h
Algorithms/itkTractsToRgbaImageFilter.h
# moved to DiffusionCore
#Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
Algorithms/itkFibersFromPlanarFiguresFilter.h
Algorithms/itkTractsToDWIImageFilter.h
Algorithms/itkTractsToVectorImageFilter.h
Algorithms/itkKspaceImageFilter.h
Algorithms/itkDftImageFilter.h
Algorithms/itkAddArtifactsToDwiImageFilter.h
Algorithms/itkFieldmapGeneratorFilter.h
Algorithms/itkEvaluateDirectionImagesFilter.h
Algorithms/itkEvaluateTractogramDirectionsFilter.h
Algorithms/itkFiberCurvatureFilter.h
# (old) Tractography
Algorithms/itkGibbsTrackingFilter.h
Algorithms/itkStochasticTractographyFilter.h
Algorithms/itkStreamlineTrackingFilter.h
Algorithms/GibbsTracking/mitkParticle.h
Algorithms/GibbsTracking/mitkParticleGrid.h
Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.h
Algorithms/GibbsTracking/mitkSimpSamp.h
Algorithms/GibbsTracking/mitkEnergyComputer.h
Algorithms/GibbsTracking/mitkGibbsEnergyComputer.h
Algorithms/GibbsTracking/mitkSphereInterpolator.h
Algorithms/GibbsTracking/mitkFiberBuilder.h
# Signal Models
SignalModels/mitkDiffusionSignalModel.h
SignalModels/mitkTensorModel.h
SignalModels/mitkBallModel.h
SignalModels/mitkDotModel.h
SignalModels/mitkAstroStickModel.h
SignalModels/mitkStickModel.h
SignalModels/mitkRawShModel.h
SignalModels/mitkDiffusionNoiseModel.h
SignalModels/mitkRicianNoiseModel.h
SignalModels/mitkChiSquareNoiseModel.h
)
set(RESOURCE_FILES
# Binary directory resources
FiberTrackingLUTBaryCoords.bin
FiberTrackingLUTIndices.bin
# Shaders
Shaders/mitkShaderFiberClipping.xml
)
diff --git a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
index 1bf5305501..b7e01c9e99 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
@@ -1,173 +1,173 @@
/*===================================================================
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 <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());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(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(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();
+ mitk::FiberBundle::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/FiberExtraction.cpp b/Modules/DiffusionImaging/MiniApps/FiberExtraction.cpp
index b3426f2f64..b038c2526c 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberExtraction.cpp
@@ -1,154 +1,154 @@
/*===================================================================
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 <metaCommand.h>
#include "mitkCommandLineParser.h"
#include <usAny.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <mitkCoreObjectFactory.h>
#include <mitkPlanarFigure.h>
#include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#define _USE_MATH_DEFINES
#include <math.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Fiber Extraction");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setContributor("MBI");
parser.setDescription(" ");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
parser.addArgument("planfirgure1", "pf1", mitkCommandLineParser::String, "Figure 1:", "first ROI", us::Any(), false);
parser.addArgument("planfirgure2", "pf2", mitkCommandLineParser::String, "Figure 2:", "second ROI", us::Any());
parser.addArgument("operation", "op", mitkCommandLineParser::String, "Operation:", "logical operation (AND, OR, NOT)", us::Any());
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
string inFib = us::any_cast<string>(parsedArgs["input"]);
string outFib = us::any_cast<string>(parsedArgs["out"]);
string pf1_path = us::any_cast<string>(parsedArgs["planfirgure1"]);
string operation("");
string pf2_path("");
if (parsedArgs.count("operation"))
{
operation = us::any_cast<string>(parsedArgs["operation"]);
if (parsedArgs.count("planfirgure2") && (operation=="AND" || operation=="OR"))
pf2_path = us::any_cast<string>(parsedArgs["planfirgure2"]);
}
try
{
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
// load fiber bundle
- mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(inFib)->GetData());
- mitk::FiberBundleX::Pointer result;
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(inFib)->GetData());
+ mitk::FiberBundle::Pointer result;
mitk::BaseData::Pointer input1 = mitk::IOUtil::LoadDataNode(pf1_path)->GetData();
mitk::PlanarFigure::Pointer pf1 = dynamic_cast<mitk::PlanarFigure*>(input1.GetPointer());
if (pf1.IsNotNull())
{
mitk::BaseData::Pointer input2;
mitk::PlanarFigure::Pointer pf2;
if (!pf2_path.empty())
{
input2 = mitk::IOUtil::LoadDataNode(pf2_path)->GetData();
pf2 = dynamic_cast<mitk::PlanarFigure*>(input2.GetPointer());
}
mitk::PlanarFigureComposite::Pointer pfc = mitk::PlanarFigureComposite::New();
if (operation.empty())
{
result = inputTractogram->ExtractFiberSubset(input1);
}
else if (operation=="NOT")
{
pfc->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
pfc->addPlanarFigure(input1);
result = inputTractogram->ExtractFiberSubset(pfc);
}
else if (operation=="AND" && pf2.IsNotNull())
{
pfc->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
pfc->addPlanarFigure(input1);
pfc->addPlanarFigure(input2);
result = inputTractogram->ExtractFiberSubset(pfc);
}
else if (operation=="OR" && pf2.IsNotNull())
{
pfc->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
pfc->addPlanarFigure(input1);
pfc->addPlanarFigure(input2);
result = inputTractogram->ExtractFiberSubset(pfc);
}
else
{
std::cout << "Could not process input:";
std::cout << pf1_path;
std::cout << pf2_path;
std::cout << operation;
}
}
else
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(pf1_path)->GetData());
mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
if (operation=="NOT")
result = inputTractogram->ExtractFiberSubset(itkMaskImage, true, true);
else
result = inputTractogram->ExtractFiberSubset(itkMaskImage, true, false);
}
if (result.IsNotNull())
mitk::IOUtil::SaveBaseData(result, outFib);
else
std::cout << "No valid fiber bundle extracted.";
}
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/FiberJoin.cpp b/Modules/DiffusionImaging/MiniApps/FiberJoin.cpp
index 5e8dd0c7c3..6cbeb3248b 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberJoin.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberJoin.cpp
@@ -1,89 +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.
===================================================================*/
#include "MiniAppManager.h"
#include <mitkBaseDataIOFactory.h>
#include <metaCommand.h>
#include "ctkCommandLineParser.h"
#include <usAny.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <mitkCoreObjectFactory.h>
#include <mitkPlanarFigure.h>
#include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#define _USE_MATH_DEFINES
#include <math.h>
int FiberJoin(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Fiber Join");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setContributor("MBI");
parser.setDescription("");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::StringList, "Input:", "input tractograms (.fib, vtk file format)", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
mitkCommandLineParser::StringContainerType inFibs = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["input"]);
string outFib = us::any_cast<string>(parsedArgs["out"]);
if (inFibs.size()<=1)
{
std::cout << "More than one input tractogram required!";
return EXIT_FAILURE;
}
try
{
- mitk::FiberBundleX::Pointer result = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(inFibs.at(0))->GetData());
+ mitk::FiberBundle::Pointer result = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(inFibs.at(0))->GetData());
for (int i=1; i<inFibs.size(); i++)
{
try
{
- mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(inFibs.at(i))->GetData());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(inFibs.at(i))->GetData());
result = result->AddBundle(inputTractogram);
}
catch(...){ std::cout << "could not load: " << inFibs.at(i); }
}
mitk::IOUtil::SaveBaseData(result, outFib);
}
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;
}
RegisterDiffusionMiniApp(FiberJoin);
diff --git a/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp b/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
index b2c1e2883c..4314696bd2 100644
--- a/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
@@ -1,203 +1,203 @@
/*===================================================================
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 <itkImageFileWriter.h>
#include <itkMetaDataObject.h>
#include <itkVectorImage.h>
#include <mitkBaseData.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include "mitkCommandLineParser.h"
#include <boost/lexical_cast.hpp>
#include <mitkCoreObjectFactory.h>
#include <mitkIOUtil.h>
-mitk::FiberBundleX::Pointer LoadFib(std::string filename)
+mitk::FiberBundle::Pointer LoadFib(std::string filename)
{
std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
if( fibInfile.empty() )
std::cout << "File " << filename << " could not be read!";
mitk::BaseData::Pointer baseData = fibInfile.at(0);
- return dynamic_cast<mitk::FiberBundleX*>(baseData.GetPointer());
+ return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
}
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Fiber Processing");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription(" ");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib)", us::Any(), false);
parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
parser.addArgument("smooth", "s", mitkCommandLineParser::Float, "Spline resampling:", "Resample fiber using splines with the given point distance (in mm)");
parser.addArgument("compress", "c", mitkCommandLineParser::Float, "Compress:", "Compress fiber using the given error threshold (in mm)");
parser.addArgument("minLength", "l", mitkCommandLineParser::Float, "Minimum length:", "Minimum fiber length (in mm)");
parser.addArgument("maxLength", "m", mitkCommandLineParser::Float, "Maximum length:", "Maximum fiber length (in mm)");
parser.addArgument("minCurv", "a", mitkCommandLineParser::Float, "Minimum curvature radius:", "Minimum curvature radius (in mm)");
parser.addArgument("mirror", "p", mitkCommandLineParser::Int, "Invert coordinates:", "Invert fiber coordinates XYZ (e.g. 010 to invert y-coordinate of each fiber point)");
parser.addArgument("rotate-x", "rx", mitkCommandLineParser::Float, "Rotate x-axis:", "Rotate around x-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("rotate-y", "ry", mitkCommandLineParser::Float, "Rotate y-axis:", "Rotate around y-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("rotate-z", "rz", mitkCommandLineParser::Float, "Rotate z-axis:", "Rotate around z-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("scale-x", "sx", mitkCommandLineParser::Float, "Scale x-axis:", "Scale in direction of x-axis (if copy is given the copy is scaled)");
parser.addArgument("scale-y", "sy", mitkCommandLineParser::Float, "Scale y-axis:", "Scale in direction of y-axis (if copy is given the copy is scaled)");
parser.addArgument("scale-z", "sz", mitkCommandLineParser::Float, "Scale z-axis", "Scale in direction of z-axis (if copy is given the copy is scaled)");
parser.addArgument("translate-x", "tx", mitkCommandLineParser::Float, "Translate x-axis:", "Translate in direction of x-axis (if copy is given the copy is translated, in mm)");
parser.addArgument("translate-y", "ty", mitkCommandLineParser::Float, "Translate y-axis:", "Translate in direction of y-axis (if copy is given the copy is translated, in mm)");
parser.addArgument("translate-z", "tz", mitkCommandLineParser::Float, "Translate z-axis:", "Translate in direction of z-axis (if copy is given the copy is translated, in mm)");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
float smoothDist = -1;
if (parsedArgs.count("smooth"))
smoothDist = us::any_cast<float>(parsedArgs["smooth"]);
float compress = -1;
if (parsedArgs.count("compress"))
compress = us::any_cast<float>(parsedArgs["compress"]);
float minFiberLength = -1;
if (parsedArgs.count("minLength"))
minFiberLength = us::any_cast<float>(parsedArgs["minLength"]);
float maxFiberLength = -1;
if (parsedArgs.count("maxLength"))
maxFiberLength = us::any_cast<float>(parsedArgs["maxLength"]);
float curvThres = -1;
if (parsedArgs.count("minCurv"))
curvThres = us::any_cast<float>(parsedArgs["minCurv"]);
int axis = 0;
if (parsedArgs.count("mirror"))
axis = us::any_cast<int>(parsedArgs["mirror"]);
float rotateX = 0;
if (parsedArgs.count("rotate-x"))
rotateX = us::any_cast<float>(parsedArgs["rotate-x"]);
float rotateY = 0;
if (parsedArgs.count("rotate-y"))
rotateY = us::any_cast<float>(parsedArgs["rotate-y"]);
float rotateZ = 0;
if (parsedArgs.count("rotate-z"))
rotateZ = us::any_cast<float>(parsedArgs["rotate-z"]);
float scaleX = 0;
if (parsedArgs.count("scale-x"))
scaleX = us::any_cast<float>(parsedArgs["scale-x"]);
float scaleY = 0;
if (parsedArgs.count("scale-y"))
scaleY = us::any_cast<float>(parsedArgs["scale-y"]);
float scaleZ = 0;
if (parsedArgs.count("scale-z"))
scaleZ = us::any_cast<float>(parsedArgs["scale-z"]);
float translateX = 0;
if (parsedArgs.count("translate-x"))
translateX = us::any_cast<float>(parsedArgs["translate-x"]);
float translateY = 0;
if (parsedArgs.count("translate-y"))
translateY = us::any_cast<float>(parsedArgs["translate-y"]);
float translateZ = 0;
if (parsedArgs.count("translate-z"))
translateZ = us::any_cast<float>(parsedArgs["translate-z"]);
string inFileName = us::any_cast<string>(parsedArgs["input"]);
string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
try
{
- mitk::FiberBundleX::Pointer fib = LoadFib(inFileName);
+ mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
if (minFiberLength>0)
fib->RemoveShortFibers(minFiberLength);
if (maxFiberLength>0)
fib->RemoveLongFibers(maxFiberLength);
if (curvThres>0)
fib->ApplyCurvatureThreshold(curvThres, false);
if (smoothDist>0)
fib->ResampleSpline(smoothDist);
if (compress>0)
fib->Compress(compress);
if (axis/100==1)
fib->MirrorFibers(0);
if ((axis%100)/10==1)
fib->MirrorFibers(1);
if (axis%10==1)
fib->MirrorFibers(2);
if (rotateX > 0 || rotateY > 0 || rotateZ > 0){
std::cout << "Rotate " << rotateX << " " << rotateY << " " << rotateZ;
fib->RotateAroundAxis(rotateX, rotateY, rotateZ);
}
if (translateX > 0 || translateY > 0 || translateZ > 0){
fib->TranslateFibers(translateX, translateY, translateZ);
}
if (scaleX > 0 || scaleY > 0 || scaleZ > 0)
fib->ScaleFibers(scaleX, scaleY, scaleZ);
mitk::IOUtil::SaveBaseData(fib.GetPointer(), outFileName );
}
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 341ecc55ef..d47a1db705 100755
--- a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
@@ -1,83 +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 <mitkImageCast.h>
#include <mitkITKImageImport.h>
#include <mitkProperties.h>
#include <mitkImage.h>
#include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.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.setTitle("FiberFox");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setContributor("MBI");
parser.setDescription(" ");
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());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
tractsToDwiFilter->SetParameters(parameters);
tractsToDwiFilter->SetFiberBundle(inputTractogram);
tractsToDwiFilter->Update();
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/FileFormatConverter.cpp b/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
index e9ae47d575..7aa93838d2 100644
--- a/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
@@ -1,77 +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.
===================================================================*/
#include <mitkImageCast.h>
#include <mitkImage.h>
#include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.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
{
std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(inName);
if ( baseData.size()>0 && dynamic_cast<Image*>(baseData[0].GetPointer()) )
{
mitk::IOUtil::Save(dynamic_cast<Image*>(baseData[0].GetPointer()), outName.c_str());
}
- else if ( baseData.size()>0 && dynamic_cast<FiberBundleX*>(baseData[0].GetPointer()) )
+ else if ( baseData.size()>0 && dynamic_cast<FiberBundle*>(baseData[0].GetPointer()) )
{
- mitk::IOUtil::Save(dynamic_cast<FiberBundleX*>(baseData[0].GetPointer()) ,outName.c_str());
+ mitk::IOUtil::Save(dynamic_cast<FiberBundle*>(baseData[0].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/GibbsTracking.cpp b/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
index 7c25e1af86..881014cba2 100755
--- a/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
+++ b/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
@@ -1,237 +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 <mitkImageCast.h>
#include <mitkQBallImage.h>
#include <mitkTensorImage.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkGibbsTrackingFilter.h>
#include <itkDiffusionTensor3D.h>
#include <itkShCoefficientImageImporter.h>
#include <mitkImageToItk.h>
#include <mitkIOUtil.h>
#include "mitkCommandLineParser.h"
#include <boost/algorithm/string.hpp>
#include <itkFlipImageFilter.h>
#include <mitkCoreObjectFactory.h>
template<int shOrder>
typename itk::ShCoefficientImageImporter< float, shOrder >::QballImageType::Pointer TemplatedConvertShCoeffs(mitk::Image* mitkImg, int toolkit, bool noFlip = false)
{
typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
typename FilterType::Pointer filter = FilterType::New();
if (noFlip)
{
filter->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);
filter->SetInputImage(flipped);
}
switch (toolkit)
{
case 0:
filter->SetToolkit(FilterType::FSL);
break;
case 1:
filter->SetToolkit(FilterType::MRTRIX);
break;
default:
filter->SetToolkit(FilterType::FSL);
}
filter->GenerateData();
return filter->GetQballImage();
}
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Gibbs Tracking");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription(" ");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", us::Any(), false);
parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameters:", "parameter file (.gtp)", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "binary mask image");
parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "SH coefficient:", "sh coefficient convention (FSL, MRtrix)", string("FSL"), true);
parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip:", "do not flip input image to match MITK coordinate convention");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
string inFileName = us::any_cast<string>(parsedArgs["input"]);
string paramFileName = us::any_cast<string>(parsedArgs["parameters"]);
string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
bool noFlip = false;
if (parsedArgs.count("noFlip"))
noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
try
{
// instantiate gibbs tracker
typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType,3> ItkQballImageType;
typedef itk::GibbsTrackingFilter<ItkQballImageType> GibbsTrackingFilterType;
GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
// load input image
mitk::Image::Pointer mitkImage = mitk::IOUtil::LoadImage(inFileName);
// try to cast to qball image
if( boost::algorithm::ends_with(inFileName, ".qbi") )
{
std::cout << "Loading qball image ...";
mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(mitkImage.GetPointer());
ItkQballImageType::Pointer itk_qbi = ItkQballImageType::New();
mitk::CastToItkImage(mitkQballImage, itk_qbi);
gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
}
else if( boost::algorithm::ends_with(inFileName, ".dti") )
{
std::cout << "Loading tensor image ...";
typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(mitkImage.GetPointer());
ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
mitk::CastToItkImage(mitkTensorImage, itk_dti);
gibbsTracker->SetTensorImage(itk_dti);
}
else if ( boost::algorithm::ends_with(inFileName, ".nii") )
{
std::cout << "Loading sh-coefficient image ...";
int nrCoeffs = mitkImage->GetLargestPossibleRegion().GetSize()[3];
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;
std::cout << "using SH-order " << shOrder;
int toolkitConvention = 0;
if (parsedArgs.count("shConvention"))
{
string convention = us::any_cast<string>(parsedArgs["shConvention"]).c_str();
if ( boost::algorithm::equals(convention, "MRtrix") )
{
toolkitConvention = 1;
std::cout << "Using MRtrix style sh-coefficient convention";
}
else
std::cout << "Using FSL style sh-coefficient convention";
}
else
std::cout << "Using FSL style sh-coefficient convention";
switch (shOrder)
{
case 4:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<4>(mitkImage, toolkitConvention, noFlip));
break;
case 6:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<6>(mitkImage, toolkitConvention, noFlip));
break;
case 8:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<8>(mitkImage, toolkitConvention, noFlip));
break;
case 10:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<10>(mitkImage, toolkitConvention, noFlip));
break;
case 12:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<12>(mitkImage, toolkitConvention, noFlip));
break;
default:
std::cout << "SH-order " << shOrder << " not supported";
}
}
else
return EXIT_FAILURE;
// global tracking
if (parsedArgs.count("mask"))
{
typedef itk::Image<float,3> MaskImgType;
mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["mask"]));
MaskImgType::Pointer itk_mask = MaskImgType::New();
mitk::CastToItkImage(mitkMaskImage, itk_mask);
gibbsTracker->SetMaskImage(itk_mask);
}
gibbsTracker->SetDuplicateImage(false);
gibbsTracker->SetLoadParameterFile( paramFileName );
// gibbsTracker->SetLutPath( "" );
gibbsTracker->Update();
- mitk::FiberBundleX::Pointer mitkFiberBundle = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
+ mitk::FiberBundle::Pointer mitkFiberBundle = mitk::FiberBundle::New(gibbsTracker->GetFiberBundle());
mitkFiberBundle->SetReferenceGeometry(mitkImage->GetGeometry());
mitk::IOUtil::SaveBaseData(mitkFiberBundle.GetPointer(), outFileName );
}
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/LocalDirectionalFiberPlausibility.cpp b/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
index bd42f2f931..326838cef7 100755
--- a/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
+++ b/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
@@ -1,300 +1,300 @@
/*===================================================================
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 <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <itkEvaluateDirectionImagesFilter.h>
#include <metaCommand.h>
#include "mitkCommandLineParser.h"
#include <itkTractsToVectorImageFilter.h>
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <fstream>
#include <itksys/SystemTools.hxx>
#include <mitkCoreObjectFactory.h>
#define _USE_MATH_DEFINES
#include <math.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Local Directional Fiber Plausibility");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription(" ");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference images:", "reference direction images", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::StringList, "Masks:", "mask images");
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("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
parser.addArgument("ignore", "n", mitkCommandLineParser::Bool, "Ignore:", "don't increase error for missing or too many directions");
parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
mitkCommandLineParser::StringContainerType referenceImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
mitkCommandLineParser::StringContainerType maskImages;
if (parsedArgs.count("mask"))
maskImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["mask"]);
string fibFile = us::any_cast<string>(parsedArgs["input"]);
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"]);
bool ignore = false;
if (parsedArgs.count("ignore"))
ignore = us::any_cast<bool>(parsedArgs["ignore"]);
string fileID = "";
if (parsedArgs.count("fileID"))
fileID = us::any_cast<string>(parsedArgs["fileID"]);
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;
typedef itk::EvaluateDirectionImagesFilter< float > EvaluationFilterType;
// load fiber bundle
- mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
// load reference directions
ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
for (unsigned int i=0; i<referenceImages.size(); i++)
{
try
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
}
catch(...){ std::cout << "could not load: " << referenceImages.at(i); }
}
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
itkMaskImage->SetSpacing( dirImg->GetSpacing() );
itkMaskImage->SetOrigin( dirImg->GetOrigin() );
itkMaskImage->SetDirection( dirImg->GetDirection() );
itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->Allocate();
itkMaskImage->FillBuffer(1);
// 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(true);
fOdfFilter->SetUseWorkingCopy(false);
fOdfFilter->Update();
ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
if (verbose)
{
// write vector field
- mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
+ mitk::FiberBundle::Pointer directions = fOdfFilter->GetOutputFiberBundle();
string outfilename = outRoot;
outfilename.append("_VECTOR_FIELD.fib");
mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
// 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();
}
// 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();
}
}
string logFile = outRoot;
logFile.append("_ANGULAR_ERROR.csv");
ofstream file;
file.open (logFile.c_str());
if (maskImages.size()>0)
{
for (unsigned int i=0; i<maskImages.size(); i++)
{
mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImages.at(i))->GetData());
mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
// evaluate directions
EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
evaluationFilter->SetImageSet(directionImageContainer);
evaluationFilter->SetReferenceImageSet(referenceImageContainer);
evaluationFilter->SetMaskImage(itkMaskImage);
evaluationFilter->SetIgnoreMissingDirections(ignore);
evaluationFilter->Update();
if (verbose)
{
EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_ERROR_IMAGE.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(angularErrorImage);
writer->Update();
}
string maskFileName = itksys::SystemTools::GetFilenameWithoutExtension(maskImages.at(i));
unsigned found = maskFileName.find_last_of("_");
string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
if (!fileID.empty())
sens = fileID;
sens.append(",");
sens.append(maskFileName.substr(found+1));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
sens.append(";\n");
file << sens;
}
}
else
{
// evaluate directions
EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
evaluationFilter->SetImageSet(directionImageContainer);
evaluationFilter->SetReferenceImageSet(referenceImageContainer);
evaluationFilter->SetMaskImage(itkMaskImage);
evaluationFilter->SetIgnoreMissingDirections(ignore);
evaluationFilter->Update();
if (verbose)
{
EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_ERROR_IMAGE.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(angularErrorImage);
writer->Update();
}
string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
if (!fileID.empty())
sens = fileID;
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
sens.append(";\n");
file << sens;
}
file.close();
}
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/MultishellMethods.cpp b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
index 0b99f56cae..368b967924 100644
--- a/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
+++ b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
@@ -1,216 +1,216 @@
/*===================================================================
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 <mitkImage.h>
#include <mitkQBallImage.h>
#include <mitkBaseData.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.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;
mitk::Image::Pointer dwi = mitk::IOUtil::LoadImage(inName);
if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dwi ) )
{
typedef itk::RadialMultishellToSingleshellImageFilter<short, short> FilterType;
typedef itk::DwiGradientLengthCorrectionFilter CorrectionFilterType;
CorrectionFilterType::Pointer roundfilter = CorrectionFilterType::New();
roundfilter->SetRoundingValue( 1000 );
roundfilter->SetReferenceBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
roundfilter->SetReferenceGradientDirectionContainer(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi));
roundfilter->Update();
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::DiffusionPropertyHelper::BValueMapType
&originalShellMap = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
mitk::DiffusionPropertyHelper::ImageType::Pointer vectorImage = mitk::DiffusionPropertyHelper::ImageType::New();
mitk::CastToItkImage(dwi, vectorImage);
const mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
gradientContainer = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
const unsigned int
&bValue = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
// filter call
vnl_vector<double> bValueList(originalShellMap.size()-1);
double targetBValue = bValueList.mean();
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::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::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::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/NetworkCreation.cpp b/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
index 197472997c..757326ccf5 100644
--- a/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
+++ b/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
@@ -1,138 +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.
===================================================================*/
// std includes
#include <string>
// CTK includes
#include "mitkCommandLineParser.h"
// MITK includes
#include "mitkConnectomicsNetworkCreator.h"
#include <mitkCoreObjectFactory.h>
#include <mitkIOUtil.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Network Creation");
parser.setCategory("Connectomics");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("fiberImage", "f", mitkCommandLineParser::InputFile, "Input image", "input fiber image (.fib)", us::Any(), false);
parser.addArgument("parcellation", "p", mitkCommandLineParser::InputFile, "Parcellation image", "parcellation image", us::Any(), false);
parser.addArgument("outputNetwork", "o", mitkCommandLineParser::String, "Output network", "where to save the output (.cnf)", us::Any(), false);
parser.addArgument("radius", "r", mitkCommandLineParser::Int, "Radius", "Search radius in mm", 15, true);
parser.addArgument("noCenterOfMass", "com", mitkCommandLineParser::Bool, "No center of mass", "Do not use center of mass for node positions");
parser.setCategory("Connectomics");
parser.setTitle("Network Creation");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
//default values
int searchRadius( 15 );
bool noCenterOfMass( false );
// parse command line arguments
std::string fiberFilename = us::any_cast<std::string>(parsedArgs["fiberImage"]);
std::string parcellationFilename = us::any_cast<std::string>(parsedArgs["parcellation"]);
std::string outputFilename = us::any_cast<std::string>(parsedArgs["outputNetwork"]);
if (parsedArgs.count("radius"))
searchRadius = us::any_cast<int>(parsedArgs["radius"]);
if (parsedArgs.count("noCenterOfMass"))
noCenterOfMass = us::any_cast<bool>(parsedArgs["noCenterOfMass"]);
try
{
const std::string s1="", s2="";
// load fiber image
std::vector<mitk::BaseData::Pointer> fiberInfile =
mitk::IOUtil::Load( fiberFilename);
if( fiberInfile.empty() )
{
std::string errorMessage = "Fiber Image at " + fiberFilename + " could not be read. Aborting.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
mitk::BaseData* fiberBaseData = fiberInfile.at(0);
- mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( fiberBaseData );
+ mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( fiberBaseData );
// load parcellation
std::vector<mitk::BaseData::Pointer> parcellationInFile =
mitk::IOUtil::Load( parcellationFilename);
if( parcellationInFile.empty() )
{
std::string errorMessage = "Parcellation at " + parcellationFilename + " could not be read. Aborting.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
mitk::BaseData* parcellationBaseData = parcellationInFile.at(0);
mitk::Image* parcellationImage = dynamic_cast<mitk::Image*>( parcellationBaseData );
// do creation
mitk::ConnectomicsNetworkCreator::Pointer connectomicsNetworkCreator = mitk::ConnectomicsNetworkCreator::New();
connectomicsNetworkCreator->SetSegmentation( parcellationImage );
connectomicsNetworkCreator->SetFiberBundle( fiberBundle );
if( !noCenterOfMass )
{
connectomicsNetworkCreator->CalculateCenterOfMass();
}
connectomicsNetworkCreator->SetEndPointSearchRadius( searchRadius );
connectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
mitk::ConnectomicsNetwork::Pointer network = connectomicsNetworkCreator->GetNetwork();
std::cout << "searching writer";
mitk::IOUtil::SaveBaseData(network.GetPointer(), outputFilename );
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 fcec556ffc..25145658c4 100755
--- a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
@@ -1,355 +1,355 @@
/*===================================================================
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 <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>
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 = mitk::IOUtil::LoadImage(imageName);
mitk::Image::Pointer mask = mitk::IOUtil::LoadImage(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();
+ mitk::FiberBundle::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/StreamlineTracking.cpp b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
index 607300171c..328d7d0528 100755
--- a/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
+++ b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
@@ -1,176 +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.
===================================================================*/
#include <mitkImageCast.h>
#include <mitkTensorImage.h>
#include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <itkStreamlineTrackingFilter.h>
#include <itkDiffusionTensor3D.h>
#include "mitkCommandLineParser.h"
#include <mitkCoreObjectFactory.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::StringList, "Input image", "input tensor image (.dti)", us::Any(), false);
parser.addArgument("seed", "si", mitkCommandLineParser::InputFile, "Seed image", "binary seed image", us::Any(), true);
parser.addArgument("mask", "mi", mitkCommandLineParser::InputFile, "Mask", "binary mask image", us::Any(), true);
parser.addArgument("faImage", "fai", mitkCommandLineParser::InputFile, "FA image", "FA image", us::Any(), true);
parser.addArgument("minFA", "fa", mitkCommandLineParser::Float, "Min. FA threshold", "minimum fractional anisotropy threshold", 0.15, true);
parser.addArgument("minCurv", "c", mitkCommandLineParser::Float, "Min. curvature radius", "minimum curvature radius in mm (default = 0.5*minimum-spacing)");
parser.addArgument("stepSize", "s", mitkCommandLineParser::Float, "Step size", "step size in mm (default = 0.1*minimum-spacing)");
parser.addArgument("tendf", "f", mitkCommandLineParser::Float, "Weight f", "Weighting factor between first eigenvector (f=1 equals FACT tracking) and input vector dependent direction (f=0).", 1.0, true);
parser.addArgument("tendg", "g", mitkCommandLineParser::Float, "Weight g", "Weighting factor between input vector (g=0) and tensor deflection (g=1 equals TEND tracking)", 0.0, true);
parser.addArgument("numSeeds", "n", mitkCommandLineParser::Int, "Seeds per voxel", "Number of seeds per voxel.", 1, true);
parser.addArgument("minLength", "l", mitkCommandLineParser::Float, "Min. fiber length", "minimum fiber length in mm", 20, true);
parser.addArgument("interpolate", "ip", mitkCommandLineParser::Bool, "Interpolate", "Use linear interpolation", false, true);
parser.addArgument("outFile", "o", mitkCommandLineParser::String, "Output file", "output fiber bundle (.fib)", us::Any(), false);
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setTitle("Streamline Tracking");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
mitkCommandLineParser::StringContainerType inputImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["input"]);
string dtiFileName;
string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
float minFA = 0.15;
float minCurv = -1;
float stepSize = -1;
float tendf = 1;
float tendg = 0;
float minLength = 20;
int numSeeds = 1;
bool interpolate = false;
if (parsedArgs.count("minCurv"))
minCurv = us::any_cast<float>(parsedArgs["minCurv"]);
if (parsedArgs.count("minFA"))
minFA = us::any_cast<float>(parsedArgs["minFA"]);
if (parsedArgs.count("stepSize"))
stepSize = us::any_cast<float>(parsedArgs["stepSize"]);
if (parsedArgs.count("tendf"))
tendf = us::any_cast<float>(parsedArgs["tendf"]);
if (parsedArgs.count("tendg"))
tendg = us::any_cast<float>(parsedArgs["tendg"]);
if (parsedArgs.count("minLength"))
minLength = us::any_cast<float>(parsedArgs["minLength"]);
if (parsedArgs.count("numSeeds"))
numSeeds = us::any_cast<int>(parsedArgs["numSeeds"]);
if (parsedArgs.count("interpolate"))
interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
try
{
typedef itk::StreamlineTrackingFilter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
mitk::Image::Pointer mitkImage = NULL;
std::cout << "Loading tensor images ...";
typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
dtiFileName = inputImages.at(0);
for (unsigned int i=0; i<inputImages.size(); i++)
{
try
{
mitkImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
mitk::TensorImage::Pointer img = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
mitk::CastToItkImage(img, itk_dti);
filter->SetInput(i, itk_dti);
}
catch(...){ std::cout << "could not load: " << inputImages.at(i); }
}
std::cout << "Loading seed image ...";
typedef itk::Image< unsigned char, 3 > ItkUCharImageType;
mitk::Image::Pointer mitkSeedImage = NULL;
if (parsedArgs.count("seed"))
mitkSeedImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["seed"]));
std::cout << "Loading mask image ...";
mitk::Image::Pointer mitkMaskImage = NULL;
if (parsedArgs.count("mask"))
mitkMaskImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["mask"]));
// instantiate tracker
filter->SetSeedsPerVoxel(numSeeds);
filter->SetFaThreshold(minFA);
filter->SetMinCurvatureRadius(minCurv);
filter->SetStepSize(stepSize);
filter->SetF(tendf);
filter->SetG(tendg);
filter->SetInterpolate(interpolate);
filter->SetMinTractLength(minLength);
if (mitkSeedImage.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(mitkSeedImage, mask);
filter->SetSeedImage(mask);
}
if (mitkMaskImage.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(mitkMaskImage, mask);
filter->SetMaskImage(mask);
}
filter->Update();
vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
if ( fiberBundle->GetNumberOfLines()==0 )
{
std::cout << "No fibers reconstructed. Check parametrization.";
return EXIT_FAILURE;
}
- mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberBundle);
+ mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
fib->SetReferenceGeometry(mitkImage->GetGeometry());
mitk::IOUtil::SaveBaseData(fib.GetPointer(), outFileName );
}
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/TractogramAngularError.cpp b/Modules/DiffusionImaging/MiniApps/TractogramAngularError.cpp
index aa2a25ef82..39fb8c85ef 100755
--- a/Modules/DiffusionImaging/MiniApps/TractogramAngularError.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TractogramAngularError.cpp
@@ -1,202 +1,202 @@
/*===================================================================
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 "MiniAppManager.h"
#include <mitkBaseDataIOFactory.h>
#include <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <mitkDiffusionCoreObjectFactory.h>
#include <mitkFiberTrackingObjectFactory.h>
#include <metaCommand.h>
#include "ctkCommandLineParser.h"
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <fstream>
#include <itkEvaluateTractogramDirectionsFilter.h>
#define _USE_MATH_DEFINES
#include <math.h>
int TractogramAngularError(int argc, char* argv[])
{
ctkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::String, "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
parser.addArgument("reference", "r", ctkCommandLineParser::StringList, "reference direction images", us::Any(), false);
parser.addArgument("out", "o", ctkCommandLineParser::String, "output root", us::Any(), false);
parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "output optional and intermediate calculation results");
parser.addArgument("ignore", "n", ctkCommandLineParser::Bool, "don't increase error for missing or too many directions");
parser.addArgument("trilinear", "t", ctkCommandLineParser::Bool, "use trilinear instead of nearest neighbor interpolation");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
ctkCommandLineParser::StringContainerType referenceImages = us::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
string fibFile = us::any_cast<string>(parsedArgs["input"]);
string maskImage("");
if (parsedArgs.count("mask"))
maskImage = us::any_cast<string>(parsedArgs["mask"]);
string outRoot = us::any_cast<string>(parsedArgs["out"]);
bool verbose = false;
if (parsedArgs.count("verbose"))
verbose = us::any_cast<bool>(parsedArgs["verbose"]);
bool ignore = false;
if (parsedArgs.count("ignore"))
ignore = us::any_cast<bool>(parsedArgs["ignore"]);
bool interpolate = false;
if (parsedArgs.count("interpolate"))
interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
try
{
RegisterDiffusionCoreObjectFactory();
RegisterFiberTrackingObjectFactory();
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image< itk::Vector< float, 3>, 3 > ItkDirectionImage3DType;
typedef itk::VectorContainer< int, ItkDirectionImage3DType::Pointer > ItkDirectionImageContainerType;
typedef itk::EvaluateTractogramDirectionsFilter< float > EvaluationFilterType;
// load fiber bundle
- mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
if (!inputTractogram)
return EXIT_FAILURE;
// load reference directions
ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
for (int i=0; i<referenceImages.size(); i++)
{
try
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
}
catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
}
// load/create mask image
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
if (maskImage.compare("")==0)
{
ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
itkMaskImage->SetSpacing( dirImg->GetSpacing() );
itkMaskImage->SetOrigin( dirImg->GetOrigin() );
itkMaskImage->SetDirection( dirImg->GetDirection() );
itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->Allocate();
itkMaskImage->FillBuffer(1);
}
else
{
mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
}
// evaluate directions
EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
evaluationFilter->SetTractogram(inputTractogram);
evaluationFilter->SetReferenceImageSet(referenceImageContainer);
evaluationFilter->SetMaskImage(itkMaskImage);
evaluationFilter->SetIgnoreMissingDirections(ignore);
evaluationFilter->SetUseInterpolation(interpolate);
evaluationFilter->Update();
if (verbose)
{
EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_ERROR_IMAGE.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(angularErrorImage);
writer->Update();
}
string logFile = outRoot;
logFile.append("_ANGULAR_ERROR.csv");
ofstream file;
file.open (logFile.c_str());
string sens = "Mean:";
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
sens.append(";\n");
sens.append("Median:");
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
sens.append(";\n");
sens.append("Maximum:");
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
sens.append(";\n");
sens.append("Minimum:");
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
sens.append(";\n");
sens.append("STDEV:");
sens.append(",");
sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
sens.append(";\n");
file << sens;
file.close();
}
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;
}
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(TractogramAngularError);
diff --git a/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp b/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
index 40033dd2fc..d37e7c3980 100755
--- a/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
@@ -1,414 +1,414 @@
/*===================================================================
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 <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <itkEvaluateDirectionImagesFilter.h>
#include <metaCommand.h>
#include "mitkCommandLineParser.h"
#include <itkTractsToVectorImageFilter.h>
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <fstream>
#include <itksys/SystemTools.hxx>
#include <mitkCoreObjectFactory.h>
#define _USE_MATH_DEFINES
#include <math.h>
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Tractometer Metrics");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("labels", "l", mitkCommandLineParser::StringList, "Label pairs:", "label pairs", false);
parser.addArgument("labelimage", "li", mitkCommandLineParser::String, "Label image:", "label image", false);
parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output valid, invalid and no connections as fiber bundles");
parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
mitkCommandLineParser::StringContainerType labelpairs = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["labels"]);
string fibFile = us::any_cast<string>(parsedArgs["input"]);
string labelImageFile = us::any_cast<string>(parsedArgs["labelimage"]);
string outRoot = us::any_cast<string>(parsedArgs["out"]);
string fileID = "";
if (parsedArgs.count("fileID"))
fileID = us::any_cast<string>(parsedArgs["fileID"]);
bool verbose = false;
if (parsedArgs.count("verbose"))
verbose = us::any_cast<bool>(parsedArgs["verbose"]);
try
{
typedef itk::Image<short, 3> ItkShortImgType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
// load fiber bundle
- mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(labelImageFile)->GetData());
typedef mitk::ImageToItk< ItkShortImgType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkShortImgType::Pointer labelImage = caster->GetOutput();
string path = itksys::SystemTools::GetFilenamePath(labelImageFile);
std::vector< bool > detected;
std::vector< std::pair< int, int > > labelsvector;
std::vector< ItkUcharImgType::Pointer > bundleMasks;
std::vector< ItkUcharImgType::Pointer > bundleMasksCoverage;
short max = 0;
for (unsigned int i=0; i<labelpairs.size()-1; i+=2)
{
std::pair< short, short > l;
l.first = boost::lexical_cast<short>(labelpairs.at(i));
l.second = boost::lexical_cast<short>(labelpairs.at(i+1));
std::cout << labelpairs.at(i);
std::cout << labelpairs.at(i+1);
if (l.first>max)
max=l.first;
if (l.second>max)
max=l.second;
labelsvector.push_back(l);
detected.push_back(false);
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK.nrrd")->GetData());
typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkUcharImgType::Pointer bundle = caster->GetOutput();
bundleMasks.push_back(bundle);
}
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK_COVERAGE.nrrd")->GetData());
typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkUcharImgType::Pointer bundle = caster->GetOutput();
bundleMasksCoverage.push_back(bundle);
}
}
vnl_matrix< unsigned char > matrix; matrix.set_size(max, max); matrix.fill(0);
vtkSmartPointer<vtkPolyData> polyData = inputTractogram->GetFiberPolyData();
int validConnections = 0;
int noConnection = 0;
int validBundles = 0;
int invalidBundles = 0;
int invalidConnections = 0;
ItkUcharImgType::Pointer coverage = ItkUcharImgType::New();
coverage->SetSpacing(labelImage->GetSpacing());
coverage->SetOrigin(labelImage->GetOrigin());
coverage->SetDirection(labelImage->GetDirection());
coverage->SetLargestPossibleRegion(labelImage->GetLargestPossibleRegion());
coverage->SetBufferedRegion( labelImage->GetLargestPossibleRegion() );
coverage->SetRequestedRegion( labelImage->GetLargestPossibleRegion() );
coverage->Allocate();
coverage->FillBuffer(0);
vtkSmartPointer<vtkPoints> noConnPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> noConnCells = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> invalidPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> invalidCells = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> validPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> validCells = vtkSmartPointer<vtkCellArray>::New();
boost::progress_display disp(inputTractogram->GetNumFibers());
for (int i=0; i<inputTractogram->GetNumFibers(); i++)
{
++disp;
vtkCell* cell = polyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
if (numPoints>1)
{
double* start = points->GetPoint(0);
itk::Point<float, 3> itkStart;
itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
itk::Index<3> idxStart;
labelImage->TransformPhysicalPointToIndex(itkStart, idxStart);
double* end = points->GetPoint(numPoints-1);
itk::Point<float, 3> itkEnd;
itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
itk::Index<3> idxEnd;
labelImage->TransformPhysicalPointToIndex(itkEnd, idxEnd);
if ( labelImage->GetPixel(idxStart)==0 || labelImage->GetPixel(idxEnd)==0 )
{
noConnection++;
if (verbose)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = noConnPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
noConnCells->InsertNextCell(container);
}
}
else
{
bool invalid = true;
for (unsigned int i=0; i<labelsvector.size(); i++)
{
bool outside = false;
ItkUcharImgType::Pointer bundle = bundleMasks.at(i);
std::pair< short, short > l = labelsvector.at(i);
if ( (labelImage->GetPixel(idxStart)==l.first && labelImage->GetPixel(idxEnd)==l.second) ||
(labelImage->GetPixel(idxStart)==l.second && labelImage->GetPixel(idxEnd)==l.first) )
{
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
bundle->TransformPhysicalPointToIndex(itkP, idx);
if ( !bundle->GetPixel(idx)>0 && bundle->GetLargestPossibleRegion().IsInside(idx) )
{
outside=true;
}
}
if (!outside)
{
validConnections++;
if (detected.at(i)==false)
validBundles++;
detected.at(i) = true;
invalid = false;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = validPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
coverage->TransformPhysicalPointToIndex(itkP, idx);
if ( coverage->GetLargestPossibleRegion().IsInside(idx) )
coverage->SetPixel(idx, 1);
}
validCells->InsertNextCell(container);
}
break;
}
}
if (invalid==true)
{
invalidConnections++;
int x = labelImage->GetPixel(idxStart)-1;
int y = labelImage->GetPixel(idxEnd)-1;
if (x>=0 && y>0 && x<matrix.cols() && y<matrix.rows() && (matrix[x][y]==0 || matrix[y][x]==0) )
{
invalidBundles++;
matrix[x][y]=1;
matrix[y][x]=1;
}
if (verbose)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = invalidPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
invalidCells->InsertNextCell(container);
}
}
}
}
}
if (verbose)
{
mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
vtkSmartPointer<vtkPolyData> noConnPolyData = vtkSmartPointer<vtkPolyData>::New();
noConnPolyData->SetPoints(noConnPoints);
noConnPolyData->SetLines(noConnCells);
- mitk::FiberBundleX::Pointer noConnFib = mitk::FiberBundleX::New(noConnPolyData);
+ mitk::FiberBundle::Pointer noConnFib = mitk::FiberBundle::New(noConnPolyData);
string ncfilename = outRoot;
ncfilename.append("_NC.fib");
mitk::IOUtil::SaveBaseData(noConnFib.GetPointer(), ncfilename );
vtkSmartPointer<vtkPolyData> invalidPolyData = vtkSmartPointer<vtkPolyData>::New();
invalidPolyData->SetPoints(invalidPoints);
invalidPolyData->SetLines(invalidCells);
- mitk::FiberBundleX::Pointer invalidFib = mitk::FiberBundleX::New(invalidPolyData);
+ mitk::FiberBundle::Pointer invalidFib = mitk::FiberBundle::New(invalidPolyData);
string icfilename = outRoot;
icfilename.append("_IC.fib");
mitk::IOUtil::SaveBaseData(invalidFib.GetPointer(), icfilename );
vtkSmartPointer<vtkPolyData> validPolyData = vtkSmartPointer<vtkPolyData>::New();
validPolyData->SetPoints(validPoints);
validPolyData->SetLines(validCells);
- mitk::FiberBundleX::Pointer validFib = mitk::FiberBundleX::New(validPolyData);
+ mitk::FiberBundle::Pointer validFib = mitk::FiberBundle::New(validPolyData);
string vcfilename = outRoot;
vcfilename.append("_VC.fib");
mitk::IOUtil::SaveBaseData(validFib.GetPointer(), vcfilename );
{
typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outRoot+"_ABC.nrrd");
writer->SetInput(coverage);
writer->Update();
}
}
// calculate coverage
int wmVoxels = 0;
int coveredVoxels = 0;
itk::ImageRegionIterator<ItkUcharImgType> it (coverage, coverage->GetLargestPossibleRegion());
while(!it.IsAtEnd())
{
bool wm = false;
for (unsigned int i=0; i<bundleMasksCoverage.size(); i++)
{
ItkUcharImgType::Pointer bundle = bundleMasksCoverage.at(i);
if (bundle->GetPixel(it.GetIndex())>0)
{
wm = true;
wmVoxels++;
break;
}
}
if (wm && it.Get()>0)
coveredVoxels++;
++it;
}
int numFibers = inputTractogram->GetNumFibers();
double nc = (double)noConnection/numFibers;
double vc = (double)validConnections/numFibers;
double ic = (double)invalidConnections/numFibers;
if (numFibers==0)
{
nc = 0.0;
vc = 0.0;
ic = 0.0;
}
int vb = validBundles;
int ib = invalidBundles;
double abc = (double)coveredVoxels/wmVoxels;
std::cout << "NC: " << nc;
std::cout << "VC: " << vc;
std::cout << "IC: " << ic;
std::cout << "VB: " << vb;
std::cout << "IB: " << ib;
std::cout << "ABC: " << abc;
string logFile = outRoot;
logFile.append("_TRACTOMETER.csv");
ofstream file;
file.open (logFile.c_str());
{
string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
if (!fileID.empty())
sens = fileID;
sens.append(",");
sens.append(boost::lexical_cast<string>(nc));
sens.append(",");
sens.append(boost::lexical_cast<string>(vc));
sens.append(",");
sens.append(boost::lexical_cast<string>(ic));
sens.append(",");
sens.append(boost::lexical_cast<string>(validBundles));
sens.append(",");
sens.append(boost::lexical_cast<string>(invalidBundles));
sens.append(",");
sens.append(boost::lexical_cast<string>(abc));
sens.append(";\n");
file << sens;
}
file.close();
}
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/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
index 210aa03fc6..45dc13083a 100644
--- a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
+++ b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
@@ -1,64 +1,61 @@
/*===================================================================
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::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/resources/FiberBundleX.png b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/FiberBundleX.png
deleted file mode 100644
index 76ee67c6e7..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/FiberBundleX.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
index 433010c36f..68ea118057 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
@@ -1,64 +1,64 @@
<RCC>
<qresource prefix="/QmitkDiffusionImaging">
<file>qball.png</file>
<file>tensor.png</file>
<file>dwi.png</file>
<file>dwiimport.png</file>
<file>quantification.png</file>
<file>reconodf.png</file>
<file>recontensor.png</file>
<file>texIntONIcon.png</file>
<file>texIntOFFIcon.png</file>
<file>vizControls.png</file>
<file>Refresh_48.png</file>
<file>QBallData24.png</file>
<file>glyphsoff_C.png</file>
<file>glyphsoff_S.png</file>
<file>glyphsoff_T.png</file>
<file>glyphson_C.png</file>
<file>glyphson_S.png</file>
<file>glyphson_T.png</file>
<file>FiberBundle.png</file>
- <file>FiberBundleX.png</file>
+ <file>FiberBundle.png</file>
<file>connectomics/ConnectomicsNetwork.png</file>
<file>connectomics/QmitkRandomParcellationIcon.png</file>
<file>rectangle.png</file>
<file>circle.png</file>
<file>polygon.png</file>
<file>color24.gif</file>
<file>color48.gif</file>
<file>color64.gif</file>
<file>crosshair.png</file>
<file>paint2.png</file>
<file>IVIM_48.png</file>
<file>reset.png</file>
<file>MapperEfx2D.png</file>
<file>refresh.xpm</file>
<file>odf.png</file>
<file>general_icons/download.ico</file>
<file>general_icons/play.ico</file>
<file>general_icons/plus.ico</file>
<file>general_icons/refresh.ico</file>
<file>general_icons/right.ico</file>
<file>general_icons/save.ico</file>
<file>general_icons/undo.ico</file>
<file>general_icons/upload.ico</file>
<file>general_icons/abort.ico</file>
<file>general_icons/copy1.ico</file>
<file>general_icons/copy2.ico</file>
<file>general_icons/cut.ico</file>
<file>general_icons/deny1.ico</file>
<file>general_icons/deny2.ico</file>
<file>general_icons/down.ico</file>
<file>general_icons/left.ico</file>
<file>general_icons/magn_minus.ico</file>
<file>general_icons/magn_plus.ico</file>
<file>general_icons/search.ico</file>
<file>general_icons/stop.ico</file>
<file>general_icons/up.ico</file>
<file>general_icons/help.ico</file>
<file>general_icons/pencil.ico</file>
<file>general_icons/edit.ico</file>
<file>denoisingicon.png</file>
</qresource>
</RCC>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
index 372a08f150..f25b4d7561 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
@@ -1,967 +1,967 @@
/*===================================================================
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 "QmitkTbssRoiAnalysisWidget.h"
#include "mitkImagePixelReadAccessor.h"
#include "mitkPixelTypeMultiplex.h"
#include <qwt_plot_marker.h>
#include <qwt_plot_picker.h>
#include <qwt_picker_machine.h>
#include <vtkCellArray.h>
QmitkTbssRoiAnalysisWidget::QmitkTbssRoiAnalysisWidget( QWidget * parent )
: QmitkPlotWidget(parent)
{
m_PlotPicker = new QwtPlotPicker(m_Plot->canvas());
m_PlotPicker->setStateMachine(new QwtPickerDragPointMachine());
m_PlotPicker->setTrackerMode(QwtPicker::ActiveOnly);
m_PlottingFiberBundle = false;
}
-void QmitkTbssRoiAnalysisWidget::DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
+void QmitkTbssRoiAnalysisWidget::DoPlotFiberBundles(mitk::FiberBundle *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
{
TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
// Now we have the resampled tracts. Next we should use these points to read out the values
mitkPixelTypeMultiplex3(PlotFiberBundles,img->GetImageDescriptor()->GetChannelTypeById(0),resampledTracts, img, avg);
m_CurrentTracts = resampledTracts;
}
-TractContainerType QmitkTbssRoiAnalysisWidget::CreateTracts(mitk::FiberBundleX *fib,
+TractContainerType QmitkTbssRoiAnalysisWidget::CreateTracts(mitk::FiberBundle *fib,
mitk::PlanarFigure *startRoi,
mitk::PlanarFigure *endRoi)
{
mitk::PlaneGeometry* startGeometry2D = const_cast<mitk::PlaneGeometry*>(startRoi->GetPlaneGeometry());
mitk::PlaneGeometry* endGeometry2D = const_cast<mitk::PlaneGeometry*>(endRoi->GetPlaneGeometry());
mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
- mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
- mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
+ mitk::FiberBundle::Pointer inStart = fib->ExtractFiberSubset(startRoi);
+ mitk::FiberBundle::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
int num = inBoth->GetNumFibers();
TractContainerType tracts;
vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
vtkCellArray* lines = fiberPolyData->GetLines();
lines->InitTraversal();
// Now find out for each fiber which ROI is encountered first. If this is the startRoi, the direction is ok
// Otherwise the plot should be in the reverse direction
for( int fiberID( 0 ); fiberID < num; fiberID++ )
{
vtkIdType numPointsInCell(0);
vtkIdType* pointsInCell(NULL);
lines->GetNextCell ( numPointsInCell, pointsInCell );
int startId = 0;
int endId = 0;
mitk::ScalarType minDistStart = std::numeric_limits<mitk::ScalarType>::max();
mitk::ScalarType minDistEnd = std::numeric_limits<mitk::ScalarType>::max();
for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
{
mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
mitk::Point3D point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
mitk::ScalarType distanceToStart = point.EuclideanDistanceTo(startCenter);
mitk::ScalarType distanceToEnd = point.EuclideanDistanceTo(endCenter);
if(distanceToStart < minDistStart)
{
minDistStart = distanceToStart;
startId = pointInCellID;
}
if(distanceToEnd < minDistEnd)
{
minDistEnd = distanceToEnd;
endId = pointInCellID;
}
}
/* We found the start and end points of of the part that should be plottet for
the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
must be reversed*/
TractType singleTract;
PointType point;
if(startId < endId)
{
// Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
mitk::Vector3D p1;
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0]; pStart[1] = p0[1]; pStart[2] = p0[2];
mitk::Point3D pSecond;
pSecond[0] = p1[0]; pSecond[1] = p1[1]; pSecond[2] = p1[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0]; onPlane[1] = startCenter[1]; onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId+1 lie on the same side of the plane, so we need
need startId-1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
}
mitk::ScalarType d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
if(! (secondOnPositive ^ startOnPositive) )
{
/* StartId and startId+1 lie on the same side of the plane
so startId is also part of the ROI*/
mitk::ScalarType *start = fiberPolyData->GetPoint( pointsInCell[startId] );
point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
singleTract.push_back(point);
}
for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
{
// push back point
mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
}
/* endId must be included if endId and endId-1 lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0]; pLast[1] = p0[1]; pLast[2] = p0[2];
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0]; pBeforeLast[1] = p1[1]; pBeforeLast[2] = p1[2];
normal = endGeometry2D->GetNormal();
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId-1 lie on the same side of the plane, so we need
need endId+1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure
endId is also part of the tract and can be inserted here */
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
}
else{
// Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
mitk::Vector3D p1;
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0]; pStart[1] = p0[1]; pStart[2] = p0[2];
mitk::Point3D pSecond;
pSecond[0] = p1[0]; pSecond[1] = p1[1]; pSecond[2] = p1[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0]; onPlane[1] = startCenter[1]; onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId+1 lie on the same side of the plane, so we need
need startId-1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
}
mitk::ScalarType d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
if(! (secondOnPositive ^ startOnPositive) )
{
/* StartId and startId+1 lie on the same side of the plane
so startId is also part of the ROI*/
mitk::ScalarType *start = fiberPolyData->GetPoint( pointsInCell[startId] );
point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
singleTract.push_back(point);
}
for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
{
// push back point
mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
}
/* endId must be included if endId and endI+1 lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0]; pLast[1] = p0[1]; pLast[2] = p0[2];
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0]; pBeforeLast[1] = p1[1]; pBeforeLast[2] = p1[2];
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
normal = endGeometry2D->GetNormal();
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId+1 lie on the same side of the plane, so we need
need endId-1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure
endId is also part of the tract and can be inserted here */
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
singleTract.push_back( point );
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
point[0] = d*newPoint[0] + p0[0];
point[1] = d*newPoint[1] + p0[1];
point[2] = d*newPoint[2] + p0[2];
singleTract.push_back(point);
}
tracts.push_back(singleTract);
}
return tracts;
}
-void QmitkTbssRoiAnalysisWidget::PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
+void QmitkTbssRoiAnalysisWidget::PlotFiberBetweenRois(mitk::FiberBundle *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
{
if(fib == NULL || img == NULL || startRoi == NULL || endRoi == NULL)
return;
m_Fib = fib;
m_CurrentImage = img;
m_CurrentStartRoi = startRoi;
m_CurrentEndRoi = endRoi;
DoPlotFiberBundles(fib, img, startRoi, endRoi, avg, number);
}
void QmitkTbssRoiAnalysisWidget::ModifyPlot(int number, bool avg)
{
if(m_Fib == NULL || m_CurrentTbssImage == NULL || m_CurrentStartRoi == NULL || m_CurrentEndRoi == NULL)
return;
if(m_PlottingFiberBundle)
{
DoPlotFiberBundles(m_Fib, m_CurrentImage, m_CurrentStartRoi, m_CurrentEndRoi, avg, number);
}
else
{
PlotFiber4D(m_CurrentTbssImage, m_Fib, m_CurrentStartRoi, m_CurrentEndRoi, number);
}
}
TractContainerType QmitkTbssRoiAnalysisWidget::ParameterizeTracts(TractContainerType tracts, int number)
{
TractContainerType resampledTracts;
for(TractContainerType::iterator it = tracts.begin(); it != tracts.end(); ++it)
{
TractType resampledTract;
TractType tract = *it;
// Calculate the total length
mitk::ScalarType totalLength = 0;
if(tract.size() < 2)
continue;
PointType p0 = tract.at(0);
for(unsigned int i = 1; i<tract.size(); i++)
{
PointType p1 = tract.at(i);
mitk::ScalarType length = p0.EuclideanDistanceTo(p1);
totalLength += length;
p0 = p1;
}
mitk::ScalarType stepSize = totalLength / number;
p0 = tract.at(0);
PointType p1 = tract.at(1);
unsigned int tractCounter = 2;
mitk::ScalarType distance = p0.EuclideanDistanceTo(p1);
mitk::ScalarType locationBetween = 0;
for(mitk::ScalarType position = 0;
position <= totalLength+0.001 && resampledTract.size() <= (number+1);
position+=stepSize)
{
/* In case we walked to far we need to find the next segment we are on and on what relative position on that
tract we are on. Small correction for rounding errors */
while(locationBetween > distance+0.001)
{
if(tractCounter == tract.size())
std::cout << "problem";
// Determine by what distance we are no on the next segment
locationBetween = locationBetween - distance;
p0 = p1;
p1 = tract.at(tractCounter);
tractCounter++;
distance = p0.EuclideanDistanceTo(p1);
}
// Direction
PointType::VectorType direction = p1-p0;
direction.Normalize();
PointType newSample = p0 + direction*locationBetween;
resampledTract.push_back(newSample);
locationBetween += stepSize;
}
resampledTracts.push_back(resampledTract);
}
return resampledTracts;
}
mitk::Point3D QmitkTbssRoiAnalysisWidget::GetPositionInWorld(int index)
{
mitk::ScalarType xSum = 0.0;
mitk::ScalarType ySum = 0.0;
mitk::ScalarType zSum = 0.0;
for(TractContainerType::iterator it = m_CurrentTracts.begin();
it!=m_CurrentTracts.end(); ++it)
{
TractType tract = *it;
PointType p = tract.at(index);
xSum += p[0];
ySum += p[1];
zSum += p[2];
}
int number = m_CurrentTracts.size();
mitk::ScalarType xPos = xSum / number;
mitk::ScalarType yPos = ySum / number;
mitk::ScalarType zPos = zSum / number;
mitk::Point3D pos;
pos[0] = xPos;
pos[1] = yPos;
pos[2] = zPos;
return pos;
}
std::vector< std::vector<mitk::ScalarType> > QmitkTbssRoiAnalysisWidget::CalculateGroupProfiles()
{
MITK_INFO << "make profiles!";
std::vector< std::vector<mitk::ScalarType> > profiles;
int size = m_Projections->GetVectorLength();
for(int s=0; s<size; s++)
{
// Iterate trough the roi
std::vector<mitk::ScalarType> profile;
RoiType::iterator it;
it = m_Roi.begin();
while(it != m_Roi.end())
{
itk::Index<3> ix = *it;
profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
it++;
}
profiles.push_back(profile);
}
m_IndividualProfiles = profiles;
// Calculate the averages
// Here a check could be build in to check whether all profiles have
// the same length, but this should normally be the case if the input
// data were corrected with the TBSS Module.
std::vector< std::vector<mitk::ScalarType> > groupProfiles;
std::vector< std::pair<std::string, int> >::iterator it;
it = m_Groups.begin();
int c = 0; //the current profile number
while(it != m_Groups.end() && profiles.size() > 0)
{
std::pair<std::string, int> p = *it;
int size = p.second;
//initialize a vector of the right length with zeroes
std::vector<mitk::ScalarType> averageProfile;
for(unsigned int i=0; i<profiles.at(0).size(); i++)
{
averageProfile.push_back(0.0);
}
// Average the right number of profiles
for(int i=0; i<size; i++)
{
for(unsigned int j=0; j<averageProfile.size(); ++j)
{
averageProfile.at(j) = averageProfile.at(j) + profiles.at(c).at(j);
}
c++;
}
// Divide by the number of profiles to get group average
for(unsigned int i=0; i<averageProfile.size(); i++)
{
averageProfile.at(i) = averageProfile.at(i) / size;
}
groupProfiles.push_back(averageProfile);
++it;
}
return groupProfiles;
}
void QmitkTbssRoiAnalysisWidget::DrawProfiles()
{
std::vector <std::vector<mitk::ScalarType> > groupProfiles = CalculateGroupProfiles();
Plot(groupProfiles);
}
void QmitkTbssRoiAnalysisWidget::Plot(std::vector <std::vector<mitk::ScalarType> > groupProfiles)
{
this->Clear();
m_Vals.clear();
std::vector<mitk::ScalarType> v1;
std::vector<mitk::ScalarType> xAxis;
for(unsigned int i=0; i<groupProfiles.at(0).size(); ++i)
{
xAxis.push_back((mitk::ScalarType)i);
}
// fill m_Vals. This might be used by the user to copy data to the clipboard
for(unsigned int i=0; i<groupProfiles.size(); i++)
{
v1.clear();
for(unsigned int j=0; j<groupProfiles.at(i).size(); j++)
{
v1.push_back(groupProfiles.at(i).at(j));
}
m_Vals.push_back(v1);
}
std::string title = m_Measure + " profiles on the ";
title.append(m_Structure);
this->SetPlotTitle( title.c_str() );
QPen pen( Qt::SolidLine );
pen.setWidth(2);
std::vector< std::pair<std::string, int> >::iterator it;
it = m_Groups.begin();
int c = 0; //the current profile number
QColor colors[4] = {Qt::green, Qt::blue, Qt::yellow, Qt::red};
while(it != m_Groups.end() && groupProfiles.size() > 0)
{
std::pair< std::string, int > group = *it;
pen.setColor(colors[c]);
int curveId = this->InsertCurve( group.first.c_str() );
this->SetCurveData( curveId, xAxis, groupProfiles.at(c) );
this->SetCurvePen( curveId, pen );
c++;
it++;
}
QwtLegend *legend = new QwtLegend;
this->SetLegend(legend, QwtPlot::RightLegend, 0.5);
std::cout << m_Measure << std::endl;
this->m_Plot->setAxisTitle(0, m_Measure.c_str());
this->m_Plot->setAxisTitle(3, "Position");
this->Replot();
}
std::vector< std::vector<mitk::ScalarType> > QmitkTbssRoiAnalysisWidget::CalculateGroupProfilesFibers(mitk::TbssImage::Pointer tbssImage,
- mitk::FiberBundleX *fib,
+ mitk::FiberBundle *fib,
mitk::PlanarFigure* startRoi,
mitk::PlanarFigure* endRoi,
int number)
{
TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
int nTracts = resampledTracts.size();
this->Clear();
// For every group we have m fibers * n subjects of profiles to fill
std::vector< std::vector<mitk::ScalarType> > profiles;
// calculate individual profiles by going through all n subjects
int size = m_Projections->GetVectorLength();
for(int s=0; s<size; s++)
{
// Iterate through all tracts
for(int t=0; t<nTracts; t++)
{
// Iterate trough the tract
std::vector<mitk::ScalarType> profile;
TractType::iterator it = resampledTracts[t].begin();
while(it != resampledTracts[t].end())
{
PointType p = *it;
PointType index;
tbssImage->GetGeometry()->WorldToIndex(p, index);
itk::Index<3> ix;
ix[0] = index[0];
ix[1] = index[1];
ix[2] = index[2];
// Get value from image
profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
it++;
}
profiles.push_back(profile);
}
}
m_IndividualProfiles = profiles;
// Now create the group averages (every group contains m fibers * n_i group members
std::vector< std::pair<std::string, int> >::iterator it;
it = m_Groups.begin();
int c = 0; //the current profile number
// Calculate the group averages
std::vector< std::vector<mitk::ScalarType> > groupProfiles;
while(it != m_Groups.end() && profiles.size() > 0)
{
std::pair<std::string, int> p = *it;
int size = p.second;
//initialize a vector of the right length with zeroes
std::vector<mitk::ScalarType> averageProfile;
for(unsigned int i=0; i<profiles.at(0).size(); i++)
{
averageProfile.push_back(0.0);
}
// Average the right number of profiles
for(int i=0; i<size*nTracts; i++)
{
for(unsigned int j=0; j<averageProfile.size(); ++j)
{
averageProfile.at(j) = averageProfile.at(j) + profiles.at(c).at(j);
}
c++;
}
// Divide by the number of profiles to get group average
for(unsigned int i=0; i<averageProfile.size(); i++)
{
averageProfile.at(i) = averageProfile.at(i) / (size*nTracts);
}
groupProfiles.push_back(averageProfile);
++it;
}
return groupProfiles;
}
void QmitkTbssRoiAnalysisWidget::PlotFiber4D(mitk::TbssImage::Pointer tbssImage,
- mitk::FiberBundleX *fib,
+ mitk::FiberBundle *fib,
mitk::PlanarFigure* startRoi,
mitk::PlanarFigure* endRoi,
int number)
{
m_PlottingFiberBundle = false;
m_Fib = fib;
m_CurrentStartRoi = startRoi;
m_CurrentEndRoi = endRoi;
m_CurrentTbssImage = tbssImage;
std::vector <std::vector<mitk::ScalarType> > groupProfiles = CalculateGroupProfilesFibers(tbssImage, fib, startRoi, endRoi, number);
Plot(groupProfiles);
}
template <typename T>
void QmitkTbssRoiAnalysisWidget::PlotFiberBundles(const mitk::PixelType ptype, TractContainerType tracts, mitk::Image *img, bool avg)
{
m_PlottingFiberBundle = true;
this->Clear();
std::vector<TractType>::iterator it = tracts.begin();
std::vector< std::vector <mitk::ScalarType > > profiles;
mitk::ImagePixelReadAccessor<T,3> imAccess(img,img->GetVolumeData(0));
it = tracts.begin();
while(it != tracts.end())
{
TractType tract = *it;
TractType::iterator tractIt = tract.begin();
std::vector<mitk::ScalarType> profile;
while(tractIt != tract.end())
{
PointType p = *tractIt;
// Get value from image
profile.push_back( (mitk::ScalarType) imAccess.GetPixelByWorldCoordinates(p) );
++tractIt;
}
profiles.push_back(profile);
std::cout << std::endl;
++it;
}
if(profiles.size() == 0)
return;
m_IndividualProfiles = profiles;
std::string title = "Fiber bundle plot";
this->SetPlotTitle( title.c_str() );
// initialize average profile
std::vector<mitk::ScalarType> averageProfile;
std::vector<mitk::ScalarType> profile = profiles.at(0); // can do this because we checked the size of profiles before
for(unsigned int i=0; i<profile.size(); ++i)
{
averageProfile.push_back(0.0);
}
std::vector< std::vector<mitk::ScalarType> >::iterator profit = profiles.begin();
int id=0;
while(profit != profiles.end())
{
std::vector<mitk::ScalarType> profile = *profit;
std::vector<mitk::ScalarType> xAxis;
for(unsigned int i=0; i<profile.size(); ++i)
{
xAxis.push_back((mitk::ScalarType)i);
averageProfile.at(i) += profile.at(i) / profiles.size();
}
int curveId = this->InsertCurve( "" );
this->SetCurveData( curveId, xAxis, profile );
++profit;
id++;
}
m_Average = averageProfile;
if(avg)
{
// Draw the average profile
std::vector<mitk::ScalarType> xAxis;
for(unsigned int i=0; i<averageProfile.size(); ++i)
{
xAxis.push_back((mitk::ScalarType)i);
}
int curveId = this->InsertCurve( "" );
this->SetCurveData( curveId, xAxis, averageProfile );
QPen pen( Qt::SolidLine );
pen.setWidth(3);
pen.setColor(Qt::red);
this->SetCurvePen( curveId, pen );
id++;
}
this->Replot();
}
void QmitkTbssRoiAnalysisWidget::drawBar(int x)
{
m_Plot->detachItems(QwtPlotItem::Rtti_PlotMarker, true);
QwtPlotMarker *mX = new QwtPlotMarker();
//mX->setLabel(QString::fromLatin1("selected point"));
mX->setLabelAlignment(Qt::AlignLeft | Qt::AlignBottom);
mX->setLabelOrientation(Qt::Vertical);
mX->setLineStyle(QwtPlotMarker::VLine);
mX->setLinePen(QPen(Qt::black, 0, Qt::SolidLine));
mX->setXValue(x);
mX->attach(m_Plot);
this->Replot();
}
QmitkTbssRoiAnalysisWidget::~QmitkTbssRoiAnalysisWidget()
{
delete m_PlotPicker;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
index 162ce829d8..8e020ed842 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
@@ -1,230 +1,230 @@
/*===================================================================
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 QmitkTbssRoiAnalysisWidget_H_
#define QmitkTbssRoiAnalysisWidget_H_
#include "QmitkPlotWidget.h"
#include <org_mitk_gui_qt_diffusionimaging_Export.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkTbssImage.h>
#include <itkVectorImage.h>
typedef itk::VectorImage<float,3> VectorImageType;
typedef std::vector< itk::Index<3> > RoiType;
typedef mitk::Point3D PointType;
typedef std::vector< PointType> TractType;
typedef std::vector< TractType > TractContainerType;
class QwtPlotPicker;
/**
* \brief Plot widget for TBSS Data
* This widget can plot regions of interest on TBSS projection data. The projection data is created by importing FSL TBSS subject data and
* completing it with patient data using the QmitkTractbasedSpatialStatisticsView.
* The region of interest is a vector of indices from which data for plotting should be obtained.
*/
class DIFFUSIONIMAGING_EXPORT QmitkTbssRoiAnalysisWidget : public QmitkPlotWidget
{
Q_OBJECT
public:
QmitkTbssRoiAnalysisWidget( QWidget * parent);
virtual ~QmitkTbssRoiAnalysisWidget();
/* \brief Set group information as a vector of pairs of group name and number of group members */
void SetGroups(std::vector< std::pair<std::string, int> > groups)
{
m_Groups = groups;
}
/* \brief Draws the group averaged profiles */
void DrawProfiles();
void PlotFiber4D(mitk::TbssImage::Pointer tbssImage,
- mitk::FiberBundleX *fib,
+ mitk::FiberBundle *fib,
mitk::PlanarFigure* startRoi,
mitk::PlanarFigure* endRoi,
int number);
template <typename T>
void PlotFiberBundles(const mitk::PixelType, TractContainerType tracts, mitk::Image* img, bool avg=false);
/* \brief Sets the projections of the individual subjects */
void SetProjections(VectorImageType::Pointer projections)
{
m_Projections = projections;
}
/* \brief Set the region of interest*/
void SetRoi(RoiType roi)
{
m_Roi = roi;
}
/* \brief Set structure information to display in the plot */
void SetStructure(std::string structure)
{
m_Structure = structure;
}
/* \brief Set measurement type for display in the plot */
void SetMeasure(std::string measure)
{
m_Measure = measure;
}
/* \brief Draws a bar to indicate were the user clicked in the plot */
void drawBar(int x);
/* \brief Returns the values of the group averaged profiles */
std::vector <std::vector<double> > GetVals()
{
return m_Vals;
}
/* \brief Returns the values of the individual subjects profiles */
std::vector <std::vector<double> > GetIndividualProfiles()
{
return m_IndividualProfiles;
}
std::vector<double> GetAverageProfile()
{
return m_Average;
}
void SetPlottingFiber(bool b)
{
m_PlottingFiberBundle = b;
}
bool IsPlottingFiber()
{
return m_PlottingFiberBundle;
}
- void PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
+ void PlotFiberBetweenRois(mitk::FiberBundle *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=-1, int number=25);
// Takes an index which is an x coordinate from the plot and finds the corresponding position in world space
mitk::Point3D GetPositionInWorld(int index);
void ModifyPlot(int number, bool avg);
QwtPlotPicker* m_PlotPicker;
protected:
- mitk::FiberBundleX* m_Fib;
+ mitk::FiberBundle* m_Fib;
std::vector< std::vector<double> > m_Vals;
std::vector< std::vector<double> > m_IndividualProfiles;
std::vector< double > m_Average;
std::vector< std::vector<double> > CalculateGroupProfiles();
std::vector< std::vector<double> > CalculateGroupProfilesFibers(mitk::TbssImage::Pointer tbssImage,
- mitk::FiberBundleX *fib,
+ mitk::FiberBundle *fib,
mitk::PlanarFigure* startRoi,
mitk::PlanarFigure* endRoi,
int number);
void Plot(std::vector <std::vector<double> > groupProfiles);
void Tokenize(const std::string& str,
std::vector<std::string>& tokens,
const std::string& delimiters = " ")
{
// Skip delimiters at beginning.
std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
// Find first "non-delimiter".
std::string::size_type pos = str.find_first_of(delimiters, lastPos);
while (std::string::npos != pos || std::string::npos != lastPos)
{
// Found a token, add it to the vector.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// Skip delimiters. Note the "not_of"
lastPos = str.find_first_not_of(delimiters, pos);
// Find next "non-delimiter"
pos = str.find_first_of(delimiters, lastPos);
}
}
std::vector< std::pair<std::string, int> > m_Groups;
VectorImageType::Pointer m_Projections;
RoiType m_Roi;
std::string m_Structure;
std::string m_Measure;
bool m_PlottingFiberBundle; // true when the plot results from a fiber tracking result (vtk .fib file)
// Resample a collection of tracts so that every tract contains #number equidistant samples
TractContainerType ParameterizeTracts(TractContainerType tracts, int number);
TractContainerType m_CurrentTracts;
mitk::Image* m_CurrentImage;
mitk::TbssImage* m_CurrentTbssImage;
mitk::PlanarFigure* m_CurrentStartRoi;
mitk::PlanarFigure* m_CurrentEndRoi;
- void DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
+ void DoPlotFiberBundles(mitk::FiberBundle *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=false, int number=25);
- /* \brief Creates tracts from a mitk::FiberBundleX and two planar figures indicating the start end end point */
- TractContainerType CreateTracts(mitk::FiberBundleX *fib, mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi);
+ /* \brief Creates tracts from a mitk::FiberBundle and two planar figures indicating the start end end point */
+ TractContainerType CreateTracts(mitk::FiberBundle *fib, mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi);
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
index ec259e9142..7a2eb21bfa 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
@@ -1,404 +1,404 @@
/*===================================================================
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 includes #######
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// ####### Qmitk includes #######
#include "QmitkConnectomicsDataView.h"
#include "QmitkStdMultiWidget.h"
// ####### Qt includes #######
#include <QMessageBox>
// ####### ITK includes #######
#include <itkRGBAPixel.h>
// ####### MITK includes #######
#include <mitkConnectomicsConstantsManager.h>
#include "mitkConnectomicsSyntheticNetworkGenerator.h"
#include "mitkConnectomicsSimulatedAnnealingManager.h"
#include "mitkConnectomicsSimulatedAnnealingPermutationModularity.h"
#include "mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h"
// Includes for image casting between ITK and MITK
#include "mitkImageCast.h"
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
const std::string QmitkConnectomicsDataView::VIEW_ID = "org.mitk.views.connectomicsdata";
QmitkConnectomicsDataView::QmitkConnectomicsDataView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_ConnectomicsNetworkCreator( mitk::ConnectomicsNetworkCreator::New() )
, m_demomode( false )
, m_currentIndex( 0 )
{
}
QmitkConnectomicsDataView::~QmitkConnectomicsDataView()
{
}
void QmitkConnectomicsDataView::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::QmitkConnectomicsDataViewControls;
m_Controls->setupUi( parent );
QObject::connect( m_Controls->networkifyPushButton, SIGNAL(clicked()), this, SLOT(OnNetworkifyPushButtonClicked()) );
QObject::connect( m_Controls->syntheticNetworkCreationPushButton, SIGNAL(clicked()), this, SLOT(OnSyntheticNetworkCreationPushButtonClicked()) );
QObject::connect( (QObject*)( m_Controls->syntheticNetworkComboBox ), SIGNAL(currentIndexChanged (int)), this, SLOT(OnSyntheticNetworkComboBoxCurrentIndexChanged(int)) );
}
// GUI is different for developer and demo mode
m_demomode = true;
if( m_demomode )
{
this->m_Controls->networkifyPushButton->show();
this->m_Controls->networkifyPushButton->setText( "Create Network" );
this->m_Controls->syntheticNetworkOptionsGroupBox->show();
//--------------------------- fill comboBox---------------------------
this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPosition, "Use label of end position of fibers");
this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPositionAvoidingWhiteMatter, "Extrapolate label");
}
else
{
this->m_Controls->networkifyPushButton->show();
this->m_Controls->networkifyPushButton->setText( "Networkify" );
this->m_Controls->syntheticNetworkOptionsGroupBox->show();
//--------------------------- fill comboBox---------------------------
this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
this->m_Controls->syntheticNetworkComboBox->insertItem(3,"Scale free network");
this->m_Controls->syntheticNetworkComboBox->insertItem(4,"Small world network");
this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPosition, "Use label of end position of fibers");
this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPositionAvoidingWhiteMatter, "Extrapolate label");
this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->JustEndPointVerticesNoLabel, "Use end position of fibers, no label");
}
this->WipeDisplay();
}
void QmitkConnectomicsDataView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkConnectomicsDataView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkConnectomicsDataView::WipeDisplay()
{
m_Controls->lblWarning->setVisible( true );
m_Controls->inputImageOneNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
m_Controls->inputImageOneNameLabel->setVisible( false );
m_Controls->inputImageOneLabel->setVisible( false );
m_Controls->inputImageTwoNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
m_Controls->inputImageTwoNameLabel->setVisible( false );
m_Controls->inputImageTwoLabel->setVisible( false );
}
void QmitkConnectomicsDataView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
this->WipeDisplay();
// Valid options are either
// 1 image (parcellation)
//
// 1 image (parcellation)
// 1 fiber bundle
//
// 1 network
if( nodes.size() > 2 )
{
return;
}
bool alreadyFiberBundleSelected( false ), alreadyImageSelected( false ), currentFormatUnknown( true );
// 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;
currentFormatUnknown = true;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
currentFormatUnknown = false;
if( alreadyImageSelected )
{
this->WipeDisplay();
return;
}
alreadyImageSelected = true;
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageOneNameLabel->setVisible( true );
m_Controls->inputImageOneLabel->setVisible( true );
}
- if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
+ if( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
{
currentFormatUnknown = false;
// a fiber bundle has to be in conjunction with a parcellation
if( nodes.size() != 2 || alreadyFiberBundleSelected )
{
this->WipeDisplay();
return;
}
alreadyFiberBundleSelected = true;
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageTwoNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageTwoNameLabel->setVisible( true );
m_Controls->inputImageTwoLabel->setVisible( true );
}
{ // network section
mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
if( node.IsNotNull() && network )
{
currentFormatUnknown = false;
if( nodes.size() != 1 )
{
// only valid option is a single network
this->WipeDisplay();
return;
}
m_Controls->lblWarning->setVisible( false );
m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
m_Controls->inputImageOneNameLabel->setVisible( true );
m_Controls->inputImageOneLabel->setVisible( true );
}
} // end network section
if ( currentFormatUnknown )
{
this->WipeDisplay();
return;
}
} // end for loop
}
void QmitkConnectomicsDataView::OnSyntheticNetworkComboBoxCurrentIndexChanged(int currentIndex)
{
m_currentIndex = currentIndex;
switch (m_currentIndex) {
case 0:
this->m_Controls->parameterOneLabel->setText( "Nodes per side" );
this->m_Controls->parameterTwoLabel->setText( "Internode distance" );
this->m_Controls->parameterOneSpinBox->setEnabled( true );
this->m_Controls->parameterOneSpinBox->setValue( 5 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 10.0 );
break;
case 1:
this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
this->m_Controls->parameterTwoLabel->setText( "Radius" );
this->m_Controls->parameterOneSpinBox->setEnabled( true );
this->m_Controls->parameterOneSpinBox->setValue( 1000 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 50.0 );
break;
case 2:
this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
this->m_Controls->parameterTwoLabel->setText( "Edge percentage" );
this->m_Controls->parameterOneSpinBox->setEnabled( true );
this->m_Controls->parameterOneSpinBox->setValue( 100 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 1.0 );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.5 );
break;
case 3:
//GenerateSyntheticScaleFreeNetwork( network, 1000 );
break;
case 4:
//GenerateSyntheticSmallWorldNetwork( network, 1000 );
break;
default:
this->m_Controls->parameterOneLabel->setText( "Parameter 1" );
this->m_Controls->parameterTwoLabel->setText( "Paramater 2" );
this->m_Controls->parameterOneSpinBox->setEnabled( false );
this->m_Controls->parameterOneSpinBox->setValue( 0 );
this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( false );
this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.0 );
}
}
void QmitkConnectomicsDataView::OnSyntheticNetworkCreationPushButtonClicked()
{
// warn if trying to create a very big network
// big network is a network with > 5000 nodes (estimate)
// this might fill up the memory to the point it freezes
int numberOfNodes( 0 );
switch (m_currentIndex) {
case 0:
numberOfNodes = this->m_Controls->parameterOneSpinBox->value()
* this->m_Controls->parameterOneSpinBox->value()
* this->m_Controls->parameterOneSpinBox->value();
break;
case 1:
numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
break;
case 2:
numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
break;
case 3:
// not implemented yet
break;
case 4:
// not implemented yet
break;
default:
break;
}
if( numberOfNodes > 5000 )
{
QMessageBox msgBox;
msgBox.setText("Trying to generate very large network.");
msgBox.setIcon( QMessageBox::Warning );
msgBox.setInformativeText("You are trying to generate a network with more than 5000 nodes, this is very resource intensive and might lead to program instability. Proceed with network generation?");
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::No);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Yes:
// continue
break;
case QMessageBox::No:
// stop
return;
break;
default:
// should never be reached
break;
}
}
// proceed
mitk::ConnectomicsSyntheticNetworkGenerator::Pointer generator = mitk::ConnectomicsSyntheticNetworkGenerator::New();
mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
int parameterOne = this->m_Controls->parameterOneSpinBox->value();
double parameterTwo = this->m_Controls->parameterTwoDoubleSpinBox->value();
//add network to datastorage
networkNode->SetData( generator->CreateSyntheticNetwork( m_currentIndex, parameterOne, parameterTwo ) );
networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
if( generator->WasGenerationSuccessfull() )
{
this->GetDefaultDataStorage()->Add( networkNode );
}
else
{
MITK_WARN << "Problem occured during synthetic network generation.";
}
mitk::RenderingManager::GetInstance()->InitializeViews(
networkNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
void QmitkConnectomicsDataView::OnNetworkifyPushButtonClicked()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if ( nodes.empty() )
{
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
return;
}
if (! ( nodes.size() == 2 ) )
{
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
return;
}
mitk::DataNode* firstNode = nodes.front();
mitk::DataNode* secondNode = nodes.at(1);
if (!firstNode)
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
return;
}
// here we have a valid mitk::DataNode
// a node itself is not very useful, we need its data item (the image)
mitk::BaseData* firstData = firstNode->GetData();
mitk::BaseData* secondData = secondNode->GetData();
if (firstData && secondData)
{
// test if this data item is an image or not (could also be a surface or something totally different)
mitk::Image* image = dynamic_cast<mitk::Image*>( firstData );
- mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( secondData );
+ mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( secondData );
// check whether order was switched
if (! (image && fiberBundle) )
{
image = dynamic_cast<mitk::Image*>( secondData );
- fiberBundle = dynamic_cast<mitk::FiberBundleX*>( firstData );
+ fiberBundle = dynamic_cast<mitk::FiberBundle*>( firstData );
}
if (image && fiberBundle)
{
mitk::ConnectomicsNetworkCreator::MappingStrategy mappingStrategy =
static_cast<mitk::ConnectomicsNetworkCreator::MappingStrategy>(this->m_Controls->mappingStrategyComboBox->currentIndex());
m_ConnectomicsNetworkCreator->SetSegmentation( image );
m_ConnectomicsNetworkCreator->SetFiberBundle( fiberBundle );
m_ConnectomicsNetworkCreator->CalculateCenterOfMass();
m_ConnectomicsNetworkCreator->SetEndPointSearchRadius( 15 );
m_ConnectomicsNetworkCreator->SetMappingStrategy( mappingStrategy );
m_ConnectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
//add network to datastorage
networkNode->SetData( m_ConnectomicsNetworkCreator->GetNetwork() );
networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
this->GetDefaultDataStorage()->Add( networkNode );
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
\ No newline at end of file
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 0ce6c56d4a..869cce17b8 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1036 +1,1036 @@
/*===================================================================
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 "mitkFiberBundle.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFiberBundleInteractor.h"
#include "mitkPlanarFigureInteractor.h"
#include <mitkQBallImage.h>
#include <mitkTensorImage.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 <QRgb>
#include <itkMultiThreader.h>
#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
using namespace berry;
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_FiberBundleObserveOpacityTag(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);
m_Controls->m_TSMenu->setMenu( m_MyMenu );
QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
#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_ScalingFrame->setVisible(false);
m_Controls->m_NormalizationFrame->setVisible(false);
}
}
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_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_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
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_LineWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(LineWidthChanged()));
connect((QObject*) m_Controls->m_TubeWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(TubeRadiusChanged()));
}
}
void QmitkControlVisualizationPropertiesView::Activated()
{
}
void QmitkControlVisualizationPropertiesView::Deactivated()
{
}
// set diffusion image channel to b0 volume
void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
{
mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
if (isDiffusionImage)
{
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::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 )
{
m_Controls->m_BundleControlsFrame->setVisible(false);
m_Controls->m_ImageControlsFrame->setVisible(false);
if (nodes.size()>1) // only do stuff if one node is selected
return;
m_Controls->m_NumberGlyphsFrame->setVisible(false);
m_Controls->m_GlyphFrame->setVisible(false);
m_Controls->m_TSMenu->setVisible(false);
m_SelectedNode = NULL;
int numOdfImages = 0;
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if(node.IsNull())
continue;
mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
m_SelectedNode = node;
- if (dynamic_cast<mitk::FiberBundleX*>(nodeData))
+ if (dynamic_cast<mitk::FiberBundle*>(nodeData))
{
// handle fiber bundle property observers
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 );
if (m_Opacity.IsNotNull())
m_Opacity->RemoveObserver(m_FiberBundleObserveOpacityTag);
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity );
m_Opacity = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("opacity", NULL));
if (m_Opacity.IsNotNull())
m_FiberBundleObserveOpacityTag = m_Opacity->AddObserver( itk::ModifiedEvent(), command2 );
m_Controls->m_BundleControlsFrame->setVisible(true);
// ???
if(m_CurrentPickingNode != 0 && node.GetPointer() != m_CurrentPickingNode)
m_Controls->m_Crosshair->setEnabled(false);
else
m_Controls->m_Crosshair->setEnabled(true);
int width;
node->GetIntProperty("LineWidth", width);
m_Controls->m_LineWidth->setValue(width);
float radius;
node->GetFloatProperty("TubeRadius", radius);
m_Controls->m_TubeWidth->setValue(radius);
float range;
node->GetFloatProperty("Fiber2DSliceThickness",range);
- mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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_Controls->m_FiberThicknessSlider->setMaximum(max * 10);
m_Controls->m_FiberThicknessSlider->setValue(range * 10);
m_Controls->m_FiberThicknessSlider->setFocus();
}
else if(dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData))
{
m_Controls->m_ImageControlsFrame->setVisible(true);
m_Controls->m_NumberGlyphsFrame->setVisible(true);
m_Controls->m_GlyphFrame->setVisible(true);
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);
int val;
node->GetIntProperty("ShowMaxNumber", val);
m_Controls->m_ShowMaxNumber->setValue(val);
m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
float fval;
node->GetFloatProperty("Scaling",fval);
m_Controls->m_ScalingFactor->setValue(fval);
m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
numOdfImages++;
}
else if(dynamic_cast<mitk::PlanarFigure*>(nodeData))
{
PlanarFigureFocus();
}
else if( dynamic_cast<mitk::Image*>(nodeData) )
{
m_Controls->m_ImageControlsFrame->setVisible(true);
m_Controls->m_TSMenu->setVisible(true);
}
}
if( nodes.empty() )
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*)) );
}
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);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
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);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
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);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
{
mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
if( currentImage == NULL )
{
MITK_ERROR << " Casting problems. Returning false";
return false;
}
mitk::Vector3D imageNormal0 = currentImage->GetSlicedGeometry()->GetAxisVector(0);
mitk::Vector3D imageNormal1 = currentImage->GetSlicedGeometry()->GetAxisVector(1);
mitk::Vector3D imageNormal2 = currentImage->GetSlicedGeometry()->GetAxisVector(2);
imageNormal0.Normalize();
imageNormal1.Normalize();
imageNormal2.Normalize();
double eps = 0.000001;
// 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::Vector3D normal = displayPlane->GetNormal();
normal.Normalize();
int test = 0;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps )
test++;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps )
test++;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps )
test++;
if (test==3)
return true;
}
{
mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow2()->GetRenderer()->GetCurrentWorldGeometry2D() );
if (displayPlane.IsNull()) return false;
mitk::Vector3D normal = displayPlane->GetNormal();
normal.Normalize();
int test = 0;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps )
test++;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps )
test++;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps )
test++;
if (test==3)
return true;
}
{
mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow3()->GetRenderer()->GetCurrentWorldGeometry2D() );
if (displayPlane.IsNull()) return false;
mitk::Vector3D normal = displayPlane->GetNormal();
normal.Normalize();
int test = 0;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps )
test++;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps )
test++;
if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps )
test++;
if (test==3)
return true;
}
return false;
}
void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
{
int maxNr = m_Controls->m_ShowMaxNumber->value();
if ( maxNr < 1 )
{
m_Controls->m_ShowMaxNumber->setValue( 1 );
maxNr = 1;
}
if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
m_SelectedNode->SetIntProperty("ShowMaxNumber", maxNr);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
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();
}
if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
m_SelectedNode->SetProperty("Normalization", normMeth.GetPointer());
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
{
if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
m_SelectedNode->SetFloatProperty("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();
}
if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
m_SelectedNode->SetProperty("Normalization", scaleBy.GetPointer());
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
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()) )
+ if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(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();
+ dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
{
- if (m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+ if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(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();
+ dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
{
QString label = "Range %1 mm";
label = label.arg(value * 0.1);
m_Controls->label_range->setText(label);
FiberSlicingThickness2D();
}
void QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity(const itk::EventObject& /*e*/)
{
if(m_SelectedNode)
{
- mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
fib->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
{
- if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+ if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
{
float color[3];
m_SelectedNode->GetColor(color);
- mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
fib->SetFiberColors(color[0]*255, color[1]*255, color[2]*255);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
{
- if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+ if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
{
- mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
fib->DoColorCodingOrientationBased();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
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::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::FiberBundleX*>(node->GetData());
+ 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 QmitkControlVisualizationPropertiesView::TubeRadiusChanged()
{
- if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+ if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
{
float newRadius = m_Controls->m_TubeWidth->value();
m_SelectedNode->SetFloatProperty("TubeRadius", newRadius);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::LineWidthChanged()
{
- if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+ if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(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())->RequestUpdate();
+ dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::Welcome()
{
berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
GetSite()->GetWorkbenchWindow(), false);
}
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 ff342de343..339079fe8e 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
@@ -1,499 +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 <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::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();
+ mitk::FiberBundle::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/QmitkFiberBundleDeveloperView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
index 021b60383f..3f78250193 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
@@ -1,1816 +1,1816 @@
/*===================================================================
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.
===================================================================*/
//=========FOR TESTING==========
//random generation, number of points equal requested points
// Blueberry application and interaction service
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberBundleDeveloperView.h"
#include <QmitkStdMultiWidget.h>
// Qt
#include <QTimer>
// MITK
#include <mitkPlanarCircle.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkGlobalInteraction.h>
//===needed when timeGeometry is null to invoke rendering mechansims ====
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include "mitkModuleRegistry.h"
// VTK
#include <vtkPointSource.h> //for randomized FiberStructure
#include <vtkPolyLine.h> //for fiberStructure
#include <vtkCellArray.h> //for fiberStructure
#include <vtkMatrix4x4.h> //for geometry
//ITK
#include <itkTimeProbe.h>
//==============================================
//======== W O R K E R S ____ S T A R T ========
//==============================================
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --generate FiberIDs--*/
QmitkFiberIDWorker::QmitkFiberIDWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberIDWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe*/
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
m_itemPackage.st_FBX->GenerateFiberIds();
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* -- extract fibers by given PlanarFigure --*/
QmitkFiberExtractorWorker::QmitkFiberExtractorWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberExtractorWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe*/
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerExtractFibers->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
std::vector<long> fibIds = m_itemPackage.st_FBX->ExtractFiberIdSubset(m_itemPackage.st_PlanarFigure);
//generate new fiberbundle by fiber iDs
vtkSmartPointer<vtkPolyData> newFBPolyData = m_itemPackage.st_FBX->GeneratePolyDataByIds(fibIds);
- // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
+ // call function to convert fiberstructure into FiberBundle and pass it to datastorage
(m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(newFBPolyData);
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerExtractFibers->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --set FA values to fiberbundle--*/
QmitkFiberColoringWorker::QmitkFiberColoringWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage)
, m_hostingThread(hostingThread)
{
}
void QmitkFiberColoringWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe*/
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerColorCoding->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
if(m_itemPackage.st_Controls->radioButton_ColorOrient->isChecked()) {
m_itemPackage.st_FBX->DoColorCodingOrientationBased();
} else if(m_itemPackage.st_Controls->radioButton_ColorFA->isChecked()) {
m_itemPackage.st_FBX->DoColorCodingFaBased();
} else if(m_itemPackage.st_Controls->radioButton_OpacityFA->isChecked()) {
// m_itemPackage.st_FBX->SetColorCoding("");
m_itemPackage.st_PassedDataNode->SetOpacity(0.999);
m_itemPackage.st_FBX->DoUseFaFiberOpacity();
} else if(m_itemPackage.st_Controls->radioButton_ColorCustom->isChecked()){
- m_itemPackage.st_FBX->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
+ m_itemPackage.st_FBX->SetColorCoding(mitk::FiberBundle::COLORCODING_CUSTOM);
}
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerColorCoding->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
QmitkFiberFeederFAWorker::QmitkFiberFeederFAWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberFeederFAWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe */
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerSetFA->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
mitk::Image::Pointer FAImg = dynamic_cast<mitk::Image*>(m_itemPackage.st_PassedDataNode->GetData());
if(FAImg.IsNotNull())
m_itemPackage.st_FBX->SetFAMap(FAImg);
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerSetFA->setText( QString::number(clock.GetTotal()) );
disconnect(m_itemPackage.st_FancyGUITimer1);
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --generate random fibers--*/
QmitkFiberGenerateRandomWorker::QmitkFiberGenerateRandomWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberGenerateRandomWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS */
//MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing, generateRandomFibers
int numOfFibers = m_itemPackage.st_Controls->boxFiberNumbers->value();
int distrRadius = m_itemPackage.st_Controls->boxDistributionRadius->value();
int numOfPoints = numOfFibers * distrRadius;
std::vector< std::vector<int> > fiberStorage;
for (int i=0; i<numOfFibers; ++i) {
std::vector<int> a;
fiberStorage.push_back( a );
}
/* Generate Point Cloud */
vtkSmartPointer<vtkPointSource> randomPoints = vtkSmartPointer<vtkPointSource>::New();
randomPoints->SetCenter(0.0, 0.0, 0.0);
randomPoints->SetNumberOfPoints(numOfPoints);
randomPoints->SetRadius(distrRadius);
randomPoints->Update();
vtkPoints* pnts = randomPoints->GetOutput()->GetPoints();
/* ASSIGN EACH POINT TO A RANDOM FIBER */
srand((unsigned)time(0)); // init randomizer
for (int i=0; i<pnts->GetNumberOfPoints(); ++i) {
//generate random number between 0 and numOfFibers-1
int random_integer;
random_integer = (rand()%numOfFibers);
//add current point to random fiber
fiberStorage.at(random_integer).push_back(i);
// MITK_INFO << "point" << i << " |" << pnts->GetPoint(random_integer)[0] << "|" << pnts->GetPoint(random_integer)[1]<< "|" << pnts->GetPoint(random_integer)[2] << "| into fiber" << random_integer;
}
// initialize accurate time measurement
itk::TimeProbe clock;
clock.Start();
/* GENERATE VTK POLYLINES OUT OF FIBERSTORAGE */
vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New(); // Host vtkPolyLines
linesCell->Allocate(pnts->GetNumberOfPoints()*2); //allocate for each cellindex also space for the pointId, e.g. [idx | pntID]
for (long i=0; i<fiberStorage.size(); ++i)
{
std::vector<int> singleFiber = fiberStorage.at(i);
vtkSmartPointer<vtkPolyLine> fiber = vtkSmartPointer<vtkPolyLine>::New();
fiber->GetPointIds()->SetNumberOfIds((int)singleFiber.size());
for (long si=0; si<singleFiber.size(); ++si)
{ //hopefully long to double works fine in VTK ;-)
fiber->GetPointIds()->SetId( si, singleFiber.at(si) );
}
linesCell->InsertNextCell(fiber);
}
/* checkpoint for cellarray allocation */
if ( (linesCell->GetSize()/pnts->GetNumberOfPoints()) != 2 ) //e.g. size: 12, number of points:6 .... each cell hosts point ids (6 ids) + cell index for each idPoint. 6 * 2 = 12
{
MITK_INFO << "RANDOM FIBER ALLOCATION CAN NOT BE TRUSTED ANYMORE! Correct leak or remove command: linesCell->Allocate(pnts->GetNumberOfPoints()*2) but be aware of possible loss in performance.";
}
/* HOSTING POLYDATA FOR RANDOM FIBERSTRUCTURE */
vtkSmartPointer<vtkPolyData> PDRandom = vtkSmartPointer<vtkPolyData>::New(); //could also be a standard pointer instead of smartpointer cuz ther is no need to delete because data is managed in datastorage.
PDRandom->SetPoints(pnts);
PDRandom->SetLines(linesCell);
// accurate timer measurement stop
clock.Stop();
//MITK_INFO << "=====Assambling random Fibers to Polydata======\nMean: " << clock.GetMean() << " Total: " << clock.GetTotal() << std::endl;
- // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
+ // call function to convert fiberstructure into FiberBundle and pass it to datastorage
(m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(PDRandom);
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --update GUI elements of thread monitor--
* implementation not thread safe, not needed so far because
* there exists only 1 thread for fiberprocessing
* for threadsafety, you need to implement checking mechanisms in methods "::threadFor...." */
QmitkFiberThreadMonitorWorker::QmitkFiberThreadMonitorWorker( QThread* hostingThread, Package4WorkingThread itemPackage )
: m_itemPackage(itemPackage)
, m_hostingThread(hostingThread)
, m_pixelstepper(10) //for next rendering call, move object 10px
, m_steppingDistance(220) //use only a multiple value of pixelstepper, x-axis border for fancy stuff
{
//set timers
m_thtimer_initMonitor = new QTimer;
m_thtimer_initMonitor->setInterval(10);
m_thtimer_initMonitorSetFinalPosition = new QTimer;
m_thtimer_initMonitorSetFinalPosition->setInterval(10);
m_thtimer_initMonitorSetMasks = new QTimer;
m_thtimer_initMonitorSetFinalPosition->setInterval(10);
m_thtimer_threadStarted = new QTimer;
m_thtimer_threadStarted->setInterval(50);
m_thtimer_threadFinished = new QTimer;
m_thtimer_threadFinished->setInterval(50);
m_thtimer_threadTerminated = new QTimer;
m_thtimer_threadTerminated->setInterval(50);
connect (m_thtimer_initMonitor, SIGNAL( timeout()), this, SLOT( fancyMonitorInitialization() ) );
connect ( m_thtimer_initMonitorSetFinalPosition, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationFinalPos() ) );
connect ( m_thtimer_initMonitorSetMasks, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationMask() ) );
connect (m_thtimer_threadStarted, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadStarted() ) );
connect (m_thtimer_threadFinished, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadFinished() ) );
connect (m_thtimer_threadTerminated, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadTerminated() ) );
//first, the current text shall turn transparent
m_decreaseOpacity_threadStarted = true;
m_decreaseOpacity_threadFinished = true;
m_decreaseOpacity_threadTerminated = true;
}
void QmitkFiberThreadMonitorWorker::run()
{
}
void QmitkFiberThreadMonitorWorker::initializeMonitor()
{
//fancy configuration of animation start
mitk::Point2D pntOpen;
pntOpen[0] = 118;
pntOpen[1] = 10;
mitk::Point2D headPos;
headPos[0] = 19;
headPos[1] = 10;
mitk::Point2D statusPos;
statusPos[0] = 105;
statusPos[1] = 23;
mitk::Point2D startedPos;
startedPos[0] = 68;
startedPos[1] = 10;
mitk::Point2D finishedPos;
finishedPos[0] = 143;
finishedPos[1] = 10;
mitk::Point2D terminatedPos;
terminatedPos[0] = 240;
terminatedPos[1] = 10;
m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntOpen);
m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
m_itemPackage.st_FBX_Monitor->setHeadingPosition(headPos);
m_itemPackage.st_FBX_Monitor->setMaskPosition(headPos);
m_itemPackage.st_FBX_Monitor->setStatusPosition(statusPos);
m_itemPackage.st_FBX_Monitor->setStartedPosition(startedPos);
m_itemPackage.st_FBX_Monitor->setFinishedPosition(finishedPos);
m_itemPackage.st_FBX_Monitor->setTerminatedPosition(terminatedPos);
m_thtimer_initMonitor->start();
}
void QmitkFiberThreadMonitorWorker::setThreadStatus(QString status)
{
m_itemPackage.st_FBX_Monitor->setStatus(status);
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
/* Methods to set status of running threads
* Following three methods are usually called
- before a thread starts and
- a thread is finished or terminated */
void QmitkFiberThreadMonitorWorker::threadForFiberProcessingStarted()
{
if(!m_thtimer_threadStarted->isActive()) {
m_thtimer_threadStarted->start();
} else {
//fast change without fancy stuff, needed to keep threaddebugger info up to date
int counter = m_itemPackage.st_FBX_Monitor->getStarted();
m_itemPackage.st_FBX_Monitor->setStarted(++counter);
}
}
void QmitkFiberThreadMonitorWorker::threadForFiberProcessingFinished()
{
if(!m_thtimer_threadFinished->isActive()) {
m_thtimer_threadFinished->start();
} else {
//fast change without fancy stuff
int counter = m_itemPackage.st_FBX_Monitor->getFinished();
m_itemPackage.st_FBX_Monitor->setFinished(++counter);
}
}
void QmitkFiberThreadMonitorWorker::threadForFiberProcessingTerminated()
{
if(!m_thtimer_threadTerminated->isActive()) {
m_thtimer_threadTerminated->start();
} else {
//fast change without fancy stuff
int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
}
}
/* Helper methods for fancy fading efx for thread monitor */
void QmitkFiberThreadMonitorWorker::fancyTextFading_threadStarted()
{
if (m_decreaseOpacity_threadStarted) {
int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
m_itemPackage.st_FBX_Monitor->setStartedOpacity( --startedOpacity );
if (startedOpacity == 0) {
int counter = m_itemPackage.st_FBX_Monitor->getStarted();
m_itemPackage.st_FBX_Monitor->setStarted(++counter);
m_decreaseOpacity_threadStarted = false;
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
} else {
int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
m_itemPackage.st_FBX_Monitor->setStartedOpacity( ++startedOpacity );
if (startedOpacity >= 10) {
m_thtimer_threadStarted->stop();
m_decreaseOpacity_threadStarted = true; //set back to true, cuz next iteration shall decrease opacity as well
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
}
void QmitkFiberThreadMonitorWorker::fancyTextFading_threadFinished()
{
if (m_decreaseOpacity_threadFinished) {
int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
m_itemPackage.st_FBX_Monitor->setFinishedOpacity( --finishedOpacity );
if (finishedOpacity == 0) {
int counter = m_itemPackage.st_FBX_Monitor->getFinished();
m_itemPackage.st_FBX_Monitor->setFinished(++counter);
m_decreaseOpacity_threadFinished = false;
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
} else {
int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
m_itemPackage.st_FBX_Monitor->setFinishedOpacity( ++finishedOpacity );
if (finishedOpacity >= 10) {
m_thtimer_threadFinished->stop();
m_decreaseOpacity_threadFinished = true; //set back to true, cuz next iteration shall decrease opacity as well
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
}
void QmitkFiberThreadMonitorWorker::fancyTextFading_threadTerminated()
{
if (m_decreaseOpacity_threadTerminated) {
int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( --terminatedOpacity );
if (terminatedOpacity == 0) {
int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
m_decreaseOpacity_threadTerminated = false;
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
} else {
int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( ++terminatedOpacity );
if (terminatedOpacity >= 10) {
m_thtimer_threadTerminated->stop();
m_decreaseOpacity_threadTerminated = true; //set back to true, cuz next iteration shall decrease opacity as well
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
}
void QmitkFiberThreadMonitorWorker::fancyMonitorInitialization()
{
mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition(); //possible bottleneck, set pntClose to member
mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition(); //possible bottleneck, set pntClose to member
pntClose[0] += m_pixelstepper;
pntOpen[0] -= m_pixelstepper;
//MITK_INFO << pntClose[0] << " " << pntOpen[0];
m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
int opacity = m_itemPackage.st_FBX_Monitor->getHeadingOpacity() + 1;
if (opacity > 10)
opacity = 10;
m_itemPackage.st_FBX_Monitor->setHeadingOpacity(opacity);
if (pntClose[0] >= m_steppingDistance)
{
if (m_itemPackage.st_FBX_Monitor->getHeadingOpacity() != 10 )
{
m_itemPackage.st_FBX_Monitor->setHeadingOpacity(10);
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
m_thtimer_initMonitor->stop();
//position them to obt y=25
m_thtimer_initMonitorSetFinalPosition->start();
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationFinalPos()
{
//get y pos of
mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition();
mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition();
mitk::Point2D pntHead = m_itemPackage.st_FBX_Monitor->getHeadingPosition();
pntClose[1] += 5;
pntOpen[1] += 5;
pntHead[1] += 5;
m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
m_itemPackage.st_FBX_Monitor->setHeadingPosition(pntHead);
if (pntClose[1] >= 35) { //35 = y position
m_thtimer_initMonitorSetFinalPosition->stop();
//now init mask of labels
m_thtimer_initMonitorSetMasks->start();
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationMask()
{
//increase opacity
int opacity = m_itemPackage.st_FBX_Monitor->getMaskOpacity();
opacity++;
m_itemPackage.st_FBX_Monitor->setMaskOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setStartedOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setFinishedOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setTerminatedOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setStatusOpacity(opacity);
if (opacity >=10) {
m_thtimer_initMonitorSetMasks->stop();
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
//==============================================
//======== W O R K E R S ________ E N D ========
//==============================================
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
// HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW IMPLEMENTATION
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
const std::string QmitkFiberBundleDeveloperView::VIEW_ID = "org.mitk.views.fiberbundledeveloper";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace berry;
QmitkFiberBundleDeveloperView::QmitkFiberBundleDeveloperView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_FiberIDGenerator( NULL)
, m_GeneratorFibersRandom( NULL )
, m_FiberFeederFASlave( NULL )
, m_FiberColoringSlave(NULL)
, m_FiberExtractor(NULL)
, m_fiberMonitorIsOn( false )
, m_CircleCounter( 0 )
, m_suppressSignal(false)
{
m_hostThread = new QThread;
m_threadInProgress = false;
}
// Destructor
QmitkFiberBundleDeveloperView::~QmitkFiberBundleDeveloperView()
{
- //m_FiberBundleX->Delete(); using weakPointer, therefore no delete necessary
+ //m_FiberBundle->Delete(); using weakPointer, therefore no delete necessary
delete m_hostThread;
}
void QmitkFiberBundleDeveloperView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done in QtDesigner, etc.
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberBundleDeveloperViewControls;
m_Controls->setupUi( parent );
/*=========INITIALIZE BUTTON CONFIGURATION ================*/
m_Controls->radioButton_directionX->setEnabled(false);
m_Controls->radioButton_directionY->setEnabled(false);
m_Controls->radioButton_directionZ->setEnabled(false);
m_Controls->buttonGenerateFiberIds->setEnabled(false);
m_Controls->buttonGenerateFibers->setEnabled(true);
m_Controls->buttonColorFibers->setEnabled(false);
m_Controls->ddAvailableColorcodings->setEnabled(false);
m_Controls->buttonExtractFibers->setEnabled(false);
m_Controls->button_FAMap->setEnabled(true);
m_Controls->buttonSMFibers->setEnabled(false);//not yet implemented
m_Controls->buttonVtkDecimatePro->setEnabled(false);//not yet implemented
m_Controls->buttonVtkSmoothPD->setEnabled(false);//not yet implemented
m_Controls->buttonGenerateTubes->setEnabled(false);//not yet implemented
connect( m_Controls->buttonGenerateFibers, SIGNAL(clicked()), this, SLOT(DoGenerateFibers()) );
connect( m_Controls->buttonGenerateFiberIds, SIGNAL(clicked()), this, SLOT(DoGenerateFiberIDs()) );
connect( m_Controls->button_FAMapExecute, SIGNAL(clicked()), this, SLOT(DoSetFAValues()) );
connect( m_Controls->button_FAMap, SIGNAL(clicked()), this, SLOT(DoSetFAMap()) );
connect( m_Controls->buttonExtractFibers, SIGNAL(clicked()), this, SLOT(DoExtractFibers()) );
connect( m_Controls->radioButton_directionRandom, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->radioButton_directionX, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->radioButton_directionY, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->radioButton_directionZ, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->toolBox, SIGNAL(currentChanged ( int ) ), this, SLOT(SelectionChangedToolBox(int)) );
connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( ActionDrawEllipseTriggered() ) );
connect( m_Controls->buttonColorFibers, SIGNAL(clicked()), this, SLOT(DoColorFibers()) );
// connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
connect( m_Controls->checkBoxMonitorFiberThreads, SIGNAL(stateChanged(int)), this, SLOT(DoMonitorFiberThreads(int)) );
}
// Checkpoint for fiber ORIENTATION
if ( m_DirectionRadios.empty() )
{
m_DirectionRadios.insert(0, m_Controls->radioButton_directionRandom);
m_DirectionRadios.insert(1, m_Controls->radioButton_directionX);
m_DirectionRadios.insert(2, m_Controls->radioButton_directionY);
m_DirectionRadios.insert(3, m_Controls->radioButton_directionZ);
}
// set GUI elements of FiberGenerator to according configuration
DoUpdateGenerateFibersWidget();
}
/* THIS METHOD UPDATES ALL GUI ELEMENTS OF QGroupBox DEPENDING ON CURRENTLY SELECTED
* RADIO BUTTONS
*/
void QmitkFiberBundleDeveloperView::DoUpdateGenerateFibersWidget()
{
//get selected radioButton
QString fibDirection; //stores the object_name of selected radiobutton
QVector<QRadioButton*>::const_iterator i;
for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
{
QRadioButton* rdbtn = *i;
if (rdbtn->isChecked())
fibDirection = rdbtn->objectName();
}
if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
// disable radiobuttons
if (m_Controls->boxFiberMinLength->isEnabled())
m_Controls->boxFiberMinLength->setEnabled(false);
if (m_Controls->labelFiberMinLength->isEnabled())
m_Controls->labelFiberMinLength->setEnabled(false);
if (m_Controls->boxFiberMaxLength->isEnabled())
m_Controls->boxFiberMaxLength->setEnabled(false);
if (m_Controls->labelFiberMaxLength->isEnabled())
m_Controls->labelFiberMaxLength->setEnabled(false);
//enable radiobuttons
if (!m_Controls->labelFibersTotal->isEnabled())
m_Controls->labelFibersTotal->setEnabled(true);
if (!m_Controls->boxFiberNumbers->isEnabled())
m_Controls->boxFiberNumbers->setEnabled(true);
if (!m_Controls->labelDistrRadius->isEnabled())
m_Controls->labelDistrRadius->setEnabled(true);
if (!m_Controls->boxDistributionRadius->isEnabled())
m_Controls->boxDistributionRadius->setEnabled(true);
} else {
// disable radiobuttons
if (m_Controls->labelDistrRadius->isEnabled())
m_Controls->labelDistrRadius->setEnabled(false);
if (m_Controls->boxDistributionRadius->isEnabled())
m_Controls->boxDistributionRadius->setEnabled(false);
//enable radiobuttons
if (!m_Controls->labelFibersTotal->isEnabled())
m_Controls->labelFibersTotal->setEnabled(true);
if (!m_Controls->boxFiberNumbers->isEnabled())
m_Controls->boxFiberNumbers->setEnabled(true);
if (!m_Controls->boxFiberMinLength->isEnabled())
m_Controls->boxFiberMinLength->setEnabled(true);
if (!m_Controls->labelFiberMinLength->isEnabled())
m_Controls->labelFiberMinLength->setEnabled(true);
if (!m_Controls->boxFiberMaxLength->isEnabled())
m_Controls->boxFiberMaxLength->setEnabled(true);
if (!m_Controls->labelFiberMaxLength->isEnabled())
m_Controls->labelFiberMaxLength->setEnabled(true);
}
}
void QmitkFiberBundleDeveloperView::DoGenerateFibers()
{
// GET SELECTED FIBER DIRECTION
QString fibDirection; //stores the object_name of selected radiobutton
QVector<QRadioButton*>::const_iterator i;
for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
{
QRadioButton* rdbtn = *i;
if (rdbtn->isChecked())
fibDirection = rdbtn->objectName();
}
// vtkPolyData* output; // FiberPD stores the generated PolyData... going to be generated in thread
if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
// build polydata with random lines and fibers
// output =
GenerateVtkFibersRandom();
} else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_X ) {
// build polydata with XDirection fibers
//output = GenerateVtkFibersDirectionX();
} else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Y ) {
// build polydata with YDirection fibers
// output = GenerateVtkFibersDirectionY();
} else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Z ) {
// build polydata with ZDirection fibers
// output = GenerateVtkFibersDirectionZ();
}
}
void QmitkFiberBundleDeveloperView::DoExtractFibers()
{
/* ===== TIMER CONFIGURATIONS for visual effect ======
* start and stop is called in Thread */
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateExtractFibersTimer()) );
struct Package4WorkingThread ItemPackageForExtractor;
- ItemPackageForExtractor.st_FBX = m_FiberBundleX;
+ ItemPackageForExtractor.st_FBX = m_FiberBundle;
ItemPackageForExtractor.st_Controls = m_Controls;
ItemPackageForExtractor.st_FancyGUITimer1 = localTimer;
ItemPackageForExtractor.st_host = this; //needed to access method "PutFibersToDataStorage()"
ItemPackageForExtractor.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
ItemPackageForExtractor.st_PlanarFigure = m_PlanarFigure;
//set element for thread monitoring
if (m_fiberMonitorIsOn)
ItemPackageForExtractor.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_FiberExtractor = new QmitkFiberExtractorWorker(m_hostThread, ItemPackageForExtractor);
m_FiberExtractor->moveToThread(m_hostThread);
//connections
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberExtraction() ));
connect(m_hostThread, SIGNAL(started()), m_FiberExtractor, SLOT( run() ));
connect(m_hostThread, SIGNAL(finished()), this, SLOT( AfterThread_FiberExtraction() ));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT( AfterThread_FiberExtraction() ));
m_hostThread->start(QThread::HighestPriority) ;
}
void QmitkFiberBundleDeveloperView::UpdateExtractFibersTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric! shall be done in beforeThreadstarted()
QString crntValue = m_Controls->infoTimerExtractFibers->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerExtractFibers->setText(QString::number(++tmpVal));
m_Controls->infoTimerExtractFibers->update();
}
void QmitkFiberBundleDeveloperView::BeforeThread_FiberExtraction()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
//m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
}
}
void QmitkFiberBundleDeveloperView::AfterThread_FiberExtraction()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
// disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
// m_FiberExtractor->disconnect();
delete m_FiberExtractor;
m_FiberBundleNode->Modified();
m_MultiWidget->RequestUpdate();
}
void QmitkFiberBundleDeveloperView::PutFibersToDataStorage( vtkSmartPointer<vtkPolyData> threadOutput)
{
MITK_INFO << "lines: " << threadOutput->GetNumberOfLines() << "pnts: " << threadOutput->GetNumberOfPoints();
//qthread mutex lock
- mitk::FiberBundleX::Pointer FB = mitk::FiberBundleX::New(threadOutput);
+ mitk::FiberBundle::Pointer FB = mitk::FiberBundle::New(threadOutput);
mitk::DataNode::Pointer FBNode;
FBNode = mitk::DataNode::New();
- FBNode->SetName("FiberBundleX");
+ FBNode->SetName("FiberBundle");
FBNode->SetData(FB);
FBNode->SetVisibility(true);
FBNode->SetOpacity(1.0);
GetDataStorage()->Add(FBNode);
FBNode->Modified();
const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
if (tsgeo == NULL) {
/* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
} else {
GetDataStorage()->Modified();
m_MultiWidget->RequestUpdate(); //necessary??
}
//qthread mutex unlock
}
void QmitkFiberBundleDeveloperView::PutFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name)
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
for(unsigned int i = 0; i < selectedNodes.size(); i++)
{
selectedNodes[i]->SetSelected(false);
}
newNode->SetSelected(true);
newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,0.0,0.0));
newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(2.0));
newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true));
newNode->AddProperty( "selected", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(false) );
newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(3.0) );
newNode->AddProperty( "planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
newNode->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(0.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
newNode->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(2.0));
newNode->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(2.0));
// figure drawn on the topmost layer / image
this->GetDataStorage()->Add(newNode);
}
/*
* Generate polydata of random fibers
*/
void QmitkFiberBundleDeveloperView::GenerateVtkFibersRandom()
{
/* ===== TIMER CONFIGURATIONS for visual effect ======
* start and stop is called in Thread */
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateGenerateRandomFibersTimer()) );
struct Package4WorkingThread ItemPackageForRandomGenerator;
- ItemPackageForRandomGenerator.st_FBX = m_FiberBundleX;
+ ItemPackageForRandomGenerator.st_FBX = m_FiberBundle;
ItemPackageForRandomGenerator.st_Controls = m_Controls;
ItemPackageForRandomGenerator.st_FancyGUITimer1 = localTimer;
ItemPackageForRandomGenerator.st_host = this; //needed to access method "PutFibersToDataStorage()"
ItemPackageForRandomGenerator.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
//set element for thread monitoring
if (m_fiberMonitorIsOn)
ItemPackageForRandomGenerator.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_GeneratorFibersRandom = new QmitkFiberGenerateRandomWorker(m_hostThread, ItemPackageForRandomGenerator);
m_GeneratorFibersRandom->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_GenerateFibersRandom()) );
connect(m_hostThread, SIGNAL(started()), m_GeneratorFibersRandom, SLOT(run()) );
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_GenerateFibersRandom()) );
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_GenerateFibersRandom()) );
m_hostThread->start(QThread::LowestPriority);
}
void QmitkFiberBundleDeveloperView::UpdateColorFibersTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric!
QString crntValue = m_Controls->infoTimerColorCoding->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerColorCoding->setText(QString::number(++tmpVal));
m_Controls->infoTimerColorCoding->update();
}
void QmitkFiberBundleDeveloperView::UpdateGenerateRandomFibersTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric!
QString crntValue = m_Controls->infoTimerGenerateFiberBundle->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerGenerateFiberBundle->setText(QString::number(++tmpVal));
m_Controls->infoTimerGenerateFiberBundle->update();
}
void QmitkFiberBundleDeveloperView::UpdateSetFAValuesTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric!
QString crntValue = m_Controls->infoTimerSetFA->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerSetFA->setText(QString::number(++tmpVal));
m_Controls->infoTimerSetFA->update();
}
void QmitkFiberBundleDeveloperView::BeforeThread_GenerateFibersRandom()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
//m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
}
}
void QmitkFiberBundleDeveloperView::AfterThread_GenerateFibersRandom()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
// disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
delete m_GeneratorFibersRandom;
}
vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionX()
{
int numOfFibers = m_Controls->boxFiberNumbers->value();
vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
//insert Origin point, this point has index 0 in point array
double originX = 0.0;
double originY = 0.0;
double originZ = 0.0;
//after each iteration the origin of the new fiber increases
//here you set which direction is affected.
double increaseX = 0.0;
double increaseY = 1.0;
double increaseZ = 0.0;
//walk along X axis
//length of fibers increases in each iteration
for (int i=0; i<numOfFibers; ++i) {
vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
newFiber->GetPointIds()->SetNumberOfIds(i+2);
//create starting point and add it to pointset
points->InsertNextPoint(originX + (double)i * increaseX , originY + (double)i * increaseY, originZ + (double)i * increaseZ);
//add starting point to fiber
newFiber->GetPointIds()->SetId(0,points->GetNumberOfPoints()-1);
//insert remaining points for fiber
for (int pj=0; pj<=i ; ++pj)
{ //generate next point on X axis
points->InsertNextPoint( originX + (double)pj+1 , originY + (double)i * increaseY, originZ + (double)i * increaseZ );
newFiber->GetPointIds()->SetId(pj+1,points->GetNumberOfPoints()-1);
}
linesCell->InsertNextCell(newFiber);
}
vtkSmartPointer<vtkPolyData> PDX = vtkSmartPointer<vtkPolyData>::New();
PDX->SetPoints(points);
PDX->SetLines(linesCell);
return PDX;
}
vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionY()
{
vtkSmartPointer<vtkPolyData> PDY = vtkSmartPointer<vtkPolyData>::New();
//todo
return PDY;
}
vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionZ()
{
vtkSmartPointer<vtkPolyData> PDZ = vtkSmartPointer<vtkPolyData>::New();
//todo
return PDZ;
}
void QmitkFiberBundleDeveloperView::DoSetFAValues()
{
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateSetFAValuesTimer() ) );
// pack items which are needed by thread processing
struct Package4WorkingThread ItemPackageToSetFAMap;
- ItemPackageToSetFAMap.st_FBX = m_FiberBundleX;
+ ItemPackageToSetFAMap.st_FBX = m_FiberBundle;
ItemPackageToSetFAMap.st_FancyGUITimer1 = localTimer;
ItemPackageToSetFAMap.st_PassedDataNode = m_FANode;
ItemPackageToSetFAMap.st_Controls = m_Controls;
if (m_fiberMonitorIsOn)
ItemPackageToSetFAMap.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_FiberFeederFASlave = new QmitkFiberFeederFAWorker(m_hostThread, ItemPackageToSetFAMap);
m_FiberFeederFASlave->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberSetFA()) );
connect(m_hostThread, SIGNAL(started()), m_FiberFeederFASlave, SLOT(run()) );
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberSetFA()));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberSetFA()));
m_hostThread->start(QThread::LowestPriority);
}
void QmitkFiberBundleDeveloperView::DoSetFAMap()
{
std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
if (nodes.empty())
{
m_Controls->lineEdit_FAMap->setText("N/A");
return;
}
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()))
{
// this node is what we want
m_FANode = node;
m_Controls->lineEdit_FAMap->setText(node->GetName().c_str());
return;
}
}
}
void QmitkFiberBundleDeveloperView::BeforeThread_FiberSetFA()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
}
}
void QmitkFiberBundleDeveloperView::AfterThread_FiberSetFA()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
//update renderer
m_FiberBundleNode->Modified();
m_MultiWidget->ForceImmediateUpdate();
//update QComboBox(dropDown menu) in view of available ColorCodings
this->DoGatherColorCodings();
delete m_FiberFeederFASlave;
}
void QmitkFiberBundleDeveloperView::DoColorFibers()
{
//
- MITK_INFO << "call fibercoloring in fiberBundleX";
+ MITK_INFO << "call fibercoloring in FiberBundle";
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateColorFibersTimer() ) );
// pack items which are needed by thread processing
struct Package4WorkingThread ItemPackageForFiberColoring;
- ItemPackageForFiberColoring.st_FBX = m_FiberBundleX;
+ ItemPackageForFiberColoring.st_FBX = m_FiberBundle;
ItemPackageForFiberColoring.st_PassedDataNode = m_FiberBundleNode;
ItemPackageForFiberColoring.st_FancyGUITimer1 = localTimer;
ItemPackageForFiberColoring.st_Controls = m_Controls; //needed to catch up some selections and set options in GUI
if (m_fiberMonitorIsOn)
ItemPackageForFiberColoring.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_FiberColoringSlave = new QmitkFiberColoringWorker(m_hostThread, ItemPackageForFiberColoring);
m_FiberColoringSlave->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberColorCoding()) );
connect(m_hostThread, SIGNAL(started()), m_FiberColoringSlave, SLOT(run()) );
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberColorCoding()));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberColorCoding()));
m_hostThread->start(QThread::LowestPriority);
}
void QmitkFiberBundleDeveloperView::BeforeThread_FiberColorCoding()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
}
}
void QmitkFiberBundleDeveloperView::AfterThread_FiberColorCoding()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
//update renderer
m_FiberBundleNode->Modified();
m_MultiWidget->ForceImmediateUpdate();
//update QComboBox(dropDown menu) in view of available ColorCodings
this->DoGatherColorCodings();
delete m_FiberColoringSlave;
}
void QmitkFiberBundleDeveloperView::DoGatherColorCodings()
{
- QStringList fbxColorCodings = m_FiberBundleX->GetAvailableColorCodings();
+ QStringList fbxColorCodings = m_FiberBundle->GetAvailableColorCodings();
//update dropDown Menu
//remove all items from menu
m_suppressSignal = true;
int ddItems = m_Controls->ddAvailableColorcodings->count();
for(int i=ddItems-1; i>=0; i--)
{ //note, after each item remove, index in QComboBox is updated. sending signal: index changed
m_Controls->ddAvailableColorcodings->removeItem(i);
}
//fill new data into menu
m_Controls->ddAvailableColorcodings->addItems(fbxColorCodings);
- m_Controls->ddAvailableColorcodings->addItem(m_FiberBundleX->COLORCODING_CUSTOM);
+ m_Controls->ddAvailableColorcodings->addItem(m_FiberBundle->COLORCODING_CUSTOM);
//highlight current colorcoding
- QString cc = m_FiberBundleX->GetCurrentColorCoding();
+ QString cc = m_FiberBundle->GetCurrentColorCoding();
MITK_INFO << cc.toStdString().c_str() << " is at idx: " << m_Controls->ddAvailableColorcodings->findText(cc);
m_Controls->ddAvailableColorcodings->setCurrentIndex( m_Controls->ddAvailableColorcodings->findText(cc) );
m_Controls->ddAvailableColorcodings->update();
m_suppressSignal = false;
}
void QmitkFiberBundleDeveloperView::SetCurrentColorCoding(int idx)
{
if(!m_suppressSignal){
QString selectedColorCoding = m_Controls->ddAvailableColorcodings->itemText(idx);
- m_FiberBundleX->SetColorCoding(selectedColorCoding.toStdString().c_str() ); //QString to char
+ m_FiberBundle->SetColorCoding(selectedColorCoding.toStdString().c_str() ); //QString to char
// update rendering
m_FiberBundleNode->Modified();
m_MultiWidget->ForceImmediateUpdate();
}
}
/* === OutSourcedMethod: THIS METHOD GENERATES ESSENTIAL GEOMETRY PARAMETERS FOR THE MITK FRAMEWORK ===
* WITHOUT, the rendering mechanism will ignore objects without valid Geometry
* for each object, MITK requires: ORIGIN, SPACING, TRANSFORM MATRIX, BOUNDING-BOX */
mitk::Geometry3D::Pointer QmitkFiberBundleDeveloperView::GenerateStandardGeometryForMITK()
{
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
// generate origin
mitk::Point3D origin;
origin[0] = 0;
origin[1] = 0;
origin[2] = 0;
geometry->SetOrigin(origin);
// generate spacing
float spacing[3] = {1,1,1};
geometry->SetSpacing(spacing);
// generate identity transform-matrix
vtkSmartPointer<vtkMatrix4x4> m = vtkSmartPointer<vtkMatrix4x4>::New();
geometry->SetIndexToWorldTransformByVtkMatrix(m);
// generate boundingbox
// for an usable bounding-box use gui parameters to estimate the boundingbox
float bounds[] = {500, 500, 500, -500, -500, -500};
// GET SELECTED FIBER DIRECTION
QString fibDirection; //stores the object_name of selected radiobutton
QVector<QRadioButton*>::const_iterator i;
for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
{
QRadioButton* rdbtn = *i;
if (rdbtn->isChecked())
fibDirection = rdbtn->objectName();
}
if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
// use information about distribution parameter to calculate bounding box
int distrRadius = m_Controls->boxDistributionRadius->value();
bounds[0] = distrRadius;
bounds[1] = distrRadius;
bounds[2] = distrRadius;
bounds[3] = -distrRadius;
bounds[4] = -distrRadius;
bounds[5] = -distrRadius;
} else {
// so far only X,Y,Z directions are available
MITK_INFO << "_______GEOMETRY ISSUE_____\n***BoundingBox for X, Y, Z fiber directions are not optimized yet!***";
int maxFibLength = m_Controls->boxFiberMaxLength->value();
bounds[0] = maxFibLength;
bounds[1] = maxFibLength;
bounds[2] = maxFibLength;
bounds[3] = -maxFibLength;
bounds[4] = -maxFibLength;
bounds[5] = -maxFibLength;
}
geometry->SetFloatBounds(bounds);
geometry->SetImageGeometry(true); //??
return geometry;
}
void QmitkFiberBundleDeveloperView::UpdateFiberIDTimer()
{
//MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
QString crntValue = m_Controls->infoTimerGenerateFiberIds->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerGenerateFiberIds->setText(QString::number(++tmpVal));
m_Controls->infoTimerGenerateFiberIds->update();
}
-/* Initialie ID dataset in FiberBundleX */
+/* Initialie ID dataset in FiberBundle */
void QmitkFiberBundleDeveloperView::DoGenerateFiberIDs()
{
/* ===== TIMER CONFIGURATIONS for visual effect ======
* start and stop is called in Thread */
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateFiberIDTimer()) );
// pack items which are needed by thread processing
struct Package4WorkingThread FiberIdPackage;
- FiberIdPackage.st_FBX = m_FiberBundleX;
+ FiberIdPackage.st_FBX = m_FiberBundle;
FiberIdPackage.st_FancyGUITimer1 = localTimer;
FiberIdPackage.st_Controls = m_Controls;
//set element for thread monitoring
if (m_fiberMonitorIsOn)
FiberIdPackage.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
// THREAD CONFIGURATION
m_FiberIDGenerator = new QmitkFiberIDWorker(m_hostThread, FiberIdPackage);
m_FiberIDGenerator->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_IdGenerate()) );
connect(m_hostThread, SIGNAL(started()), m_FiberIDGenerator, SLOT(run()));
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_IdGenerate()));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_IdGenerate()));
m_hostThread->start(QThread::LowestPriority);
// m_Controls->infoTimerGenerateFiberIds->setText(QString::number(clock.GetTotal()));
}
void QmitkFiberBundleDeveloperView::BeforeThread_IdGenerate()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
}
}
void QmitkFiberBundleDeveloperView::AfterThread_IdGenerate()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
delete m_FiberIDGenerator;
}
void QmitkFiberBundleDeveloperView::ResetFiberInfoWidget()
{
if (m_Controls->infoAnalyseNumOfFibers->isEnabled()) {
m_Controls->infoAnalyseNumOfFibers->setText("-");
m_Controls->infoAnalyseNumOfPoints->setText("-");
m_Controls->infoAnalyseNumOfFibers->setEnabled(false);
}
}
void QmitkFiberBundleDeveloperView::FeedFiberInfoWidget()
{
if (!m_Controls->infoAnalyseNumOfFibers->isEnabled())
m_Controls->infoAnalyseNumOfFibers->setEnabled(true);
QString numOfFibers;
- numOfFibers.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfLines() );
+ numOfFibers.setNum( m_FiberBundle->GetFiberPolyData()->GetNumberOfLines() );
QString numOfPoints;
- numOfPoints.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfPoints() );
+ numOfPoints.setNum( m_FiberBundle->GetFiberPolyData()->GetNumberOfPoints() );
m_Controls->infoAnalyseNumOfFibers->setText( numOfFibers );
m_Controls->infoAnalyseNumOfPoints->setText( numOfPoints );
}
void QmitkFiberBundleDeveloperView::SelectionChangedToolBox(int idx)
{
// show/reset items of selected toolbox page FiberInfo
if (m_Controls->page_FiberInfo->isVisible())
{
- if (m_FiberBundleX != NULL) {
+ if (m_FiberBundle != NULL) {
FeedFiberInfoWidget();
} else {
//if infolables are disabled: return
//else set info back to - and set label and info to disabled
ResetFiberInfoWidget();
}
}
// show/reset items of selected toolbox page FiberProcessing
if (m_Controls->page_FiberProcessing->isVisible())
{
- if (m_FiberBundleX.IsNotNull() && m_PlanarFigure.IsNotNull() )
+ if (m_FiberBundle.IsNotNull() && m_PlanarFigure.IsNotNull() )
{
//show fiber extraction button
m_Controls->buttonExtractFibers->setEnabled(true);
} else {
m_Controls->buttonExtractFibers->setEnabled(false);
}
- if (m_FiberBundleX.IsNotNull())
+ if (m_FiberBundle.IsNotNull())
{
//show button colorCoding
m_Controls->buttonColorFibers->setEnabled(true);
m_Controls->ddAvailableColorcodings->setEnabled(true);
m_Controls->buttonGenerateFiberIds->setEnabled(true);
// m_Controls->buttonSMFibers->setEnabled(true);
// m_Controls->buttonVtkDecimatePro->setEnabled(true);
// m_Controls->buttonVtkSmoothPD->setEnabled(true);
// m_Controls->buttonGenerateTubes->setEnabled(true);
} else {
m_Controls->buttonColorFibers->setEnabled(false);
m_Controls->ddAvailableColorcodings->setEnabled(false);
m_Controls->buttonGenerateFiberIds->setEnabled(false);
m_Controls->buttonSMFibers->setEnabled(false);
m_Controls->buttonVtkDecimatePro->setEnabled(false);
m_Controls->buttonVtkSmoothPD->setEnabled(false);
m_Controls->buttonGenerateTubes->setEnabled(true);
}
}
}
void QmitkFiberBundleDeveloperView::FBXDependendGUIElementsConfigurator()
{
// ==== FIBER PROCESSING ELEMENTS and ALL ELEMENTS WHICH NEED A FBX DATANODE======
// m_Controls->buttonGenerateFiberIds->setEnabled(isVisible); moved to selectionChangedToolBox
SelectionChangedToolBox(-1); //set gui elements with respect to active tab, widget, etc. -1 has no effect
}
void QmitkFiberBundleDeveloperView::DoMonitorFiberThreads(int checkStatus)
{
- //check if in datanode exists already a node of type mitkFiberBundleXThreadMonitor
+ //check if in datanode exists already a node of type mitkFiberBundleThreadMonitor
//if not then put node to datastorage
//if checkStatus is 1 then start qtimer using fading in starting text in datanode
//if checkStatus is 0 then fade out dataNode using qtimer
if (checkStatus)
{
m_fiberMonitorIsOn = true;
// Generate Node hosting thread information
- mitk::FiberBundleXThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleXThreadMonitor::New();
+ mitk::FiberBundleThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleThreadMonitor::New();
FBXThreadMonitor->SetGeometry(this->GenerateStandardGeometryForMITK());
m_MonitorNode = mitk::DataNode::New();
m_MonitorNode->SetName("FBX_threadMonitor");
m_MonitorNode->SetData(FBXThreadMonitor);
m_MonitorNode->SetVisibility(true);
m_MonitorNode->SetOpacity(1.0);
GetDataStorage()->Add(m_MonitorNode);
//following code is needed for rendering text in mitk! without geometry nothing is rendered
const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
if (tsgeo == NULL) {
/* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New( "includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
} else {
GetDataStorage()->Modified();
m_MultiWidget->RequestUpdate(); //necessary??
}
//__GEOMETRY FOR THREADMONITOR GENERATED
/* ====== initialize thread for managing fiberThread information ========= */
m_monitorThread = new QThread;
// the package needs datastorage, MonitorDatanode, standardmultiwidget,
struct Package4WorkingThread ItemPackageForThreadMonitor;
ItemPackageForThreadMonitor.st_DataStorage = GetDataStorage();
ItemPackageForThreadMonitor.st_ThreadMonitorDataNode = m_MonitorNode;
ItemPackageForThreadMonitor.st_MultiWidget = m_MultiWidget;
ItemPackageForThreadMonitor.st_FBX_Monitor = FBXThreadMonitor;
m_fiberThreadMonitorWorker = new QmitkFiberThreadMonitorWorker(m_monitorThread, ItemPackageForThreadMonitor);
m_fiberThreadMonitorWorker->moveToThread(m_monitorThread);
connect ( m_monitorThread, SIGNAL( started() ), m_fiberThreadMonitorWorker, SLOT( run() ) );
m_monitorThread->start(QThread::LowestPriority);
m_fiberThreadMonitorWorker->initializeMonitor();//do some init animation ;-)
} else {
m_fiberMonitorIsOn = false;
m_monitorThread->quit();
//think about outsourcing following lines to quit / terminate slot of thread
GetDataStorage()->Remove(m_MonitorNode);
GetDataStorage()->Modified();
m_MultiWidget->RequestUpdate(); //necessary??
}
}
void QmitkFiberBundleDeveloperView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkFiberBundleDeveloperView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
/* OnSelectionChanged is registered to SelectionService, therefore no need to
implement SelectionService Listener explicitly */
void QmitkFiberBundleDeveloperView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
if (nodes.empty())
return;
- /* ==== reset everyhing related to FiberBundleX ======
- * - variable m_FiberBundleX
+ /* ==== reset everyhing related to FiberBundle ======
+ * - variable m_FiberBundle
* - visualization of analysed fiberbundle
*/
m_FiberBundleNode = NULL;
- m_FiberBundleX = NULL; //reset pointer, so that member does not point to depricated locations
+ m_FiberBundle = NULL; //reset pointer, so that member does not point to depricated locations
m_PlanarFigure = NULL;
ResetFiberInfoWidget();
//timer reset only when no thread is in progress
if (!m_threadInProgress) {
m_Controls->infoTimerGenerateFiberIds->setText("-"); //set GUI representation of timer to -
m_Controls->infoTimerGenerateFiberBundle->setText( "-" );
m_Controls->infoTimerColorCoding->setText( "-" );
}
//====================================================
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
/* CHECKPOINT: FIBERBUNDLE*/
- if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
+ if( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
{
m_FiberBundleNode = node;
- m_FiberBundleX = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
- if (m_FiberBundleX.IsNull()){
- MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundleX to FiberBundleDeveloper-plugin \n";
+ m_FiberBundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
+ if (m_FiberBundle.IsNull()){
+ MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundle to FiberBundleDeveloper-plugin \n";
m_FiberBundleNode = NULL;
}
// ==== FIBERBUNDLE_INFO ELEMENTS ====
if ( m_Controls->page_FiberInfo->isVisible() )
FeedFiberInfoWidget();
- // enable FiberBundleX related Gui Elements, such as buttons etc.
+ // enable FiberBundle related Gui Elements, such as buttons etc.
this->FBXDependendGUIElementsConfigurator();
this->DoGatherColorCodings();
}
/* CHECKPOINT: PLANARFIGURE */
else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarFigure*>(node->GetData()) )
{
m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
MITK_INFO << "PF selected";
if (m_PlanarFigure.IsNull())
MITK_INFO << "========ATTENTION=========\n unable to load selected Planarfigure to FiberBundleDeveloper-plugin \n";
}
}
//update gui elements depending on given nodes
FBXDependendGUIElementsConfigurator(); //every gui element which needs a FBX for processing is disabled
}
void QmitkFiberBundleDeveloperView::ActionDrawEllipseTriggered()
{
// bool checked = m_Controls->m_CircleButton->isChecked();
mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
this->PutFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
MITK_INFO << "PlanarCircle created ...";
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
mitk::PlanarFigure* figureP = 0;
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figureP)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->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( node );
}
}
}
}
void QmitkFiberBundleDeveloperView::Activated()
{
MITK_INFO << "FB DevelopersV ACTIVATED()";
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h
index bc65c9e735..75d0d9e2f6 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h
@@ -1,382 +1,382 @@
/*===================================================================
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 QmitkFiberBundleDeveloperView_h
#define QmitkFiberBundleDeveloperView_h
#include <berryISelectionListener.h>
#include <berryIStructuredSelection.h>
#include <QmitkFunctionality.h>
#include "ui_QmitkFiberBundleDeveloperViewControls.h"
#include <mitkDataStorage.h>
#include <mitkDataStorageSelection.h>
#include <mitkWeakPointer.h>
-#include <mitkFiberBundleXThreadMonitor.h>
+#include <mitkFiberBundleThreadMonitor.h>
// Qt
#include <QVector>
#include <QRadioButton>
#include <QString>
// VTK
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <QTimer>
#include <QThread>
class QmitkFiberThreadMonitorWorker; //include needed for struct element
class QmitkFiberBundleDeveloperView; //this include is needed for the struct element, especially for functors to QmitkFiberBundleDeveloperView
/* ==== THIS STRUCT CONTAINS ALL NECESSARY VARIABLES
* TO EXECUTE AND UPDATE GUI ELEMENTS DURING PROCESSING OF A THREAD
* why? either you add tons of friendclasses (e.g. FiberWorker objects), or you create a package containing all items needed. Otherwise you have to set all members etc. to public!
*/
struct Package4WorkingThread
{
- mitk::FiberBundleX* st_FBX;
+ mitk::FiberBundle* st_FBX;
QTimer* st_FancyGUITimer1;
Ui::QmitkFiberBundleDeveloperViewControls* st_Controls;
//functors to outdoor methods
QmitkFiberBundleDeveloperView* st_host;
void (QmitkFiberBundleDeveloperView::*st_pntr_to_Method_PutFibersToDataStorage) (vtkSmartPointer<vtkPolyData>);
//==DO NOT TOUCH THIS SECTION=== you might extend this section, but do NOT shorten it! hai capito!
//host MITK I/O elements, especially needed for thread monitoring
QmitkFiberThreadMonitorWorker *st_fiberThreadMonitorWorker;
- mitk::FiberBundleXThreadMonitor::Pointer st_FBX_Monitor; //needed for direct access do animation/fancy methods
+ mitk::FiberBundleThreadMonitor::Pointer st_FBX_Monitor; //needed for direct access do animation/fancy methods
mitk::DataNode::Pointer st_ThreadMonitorDataNode; //needed for renderer to recognize node modifications
mitk::DataNode::Pointer st_PassedDataNode; //put an extra node if needed
mitk::DataStorage::Pointer st_DataStorage; //well that is discussable if needed ;-) probably not
QmitkStdMultiWidget* st_MultiWidget; //needed for rendering update
mitk::PlanarFigure::Pointer st_PlanarFigure; //needed for fiberextraction
};
// ====================================================================
// ============= WORKER WHICH IS PASSED TO THREAD =====================
// ====================================================================
//## Documentation
//## This class does the actual work for generating fiber ids.
class QmitkFiberIDWorker : public QObject
{
Q_OBJECT
public:
QmitkFiberIDWorker( QThread*, Package4WorkingThread );
public slots:
void run();
private:
Package4WorkingThread m_itemPackage;
QThread* m_hostingThread;
};
// ====================================================================
// ============= WORKER WHICH IS PASSED TO THREAD =====================
// ====================================================================
//## Documentation
//## This class does the actual work for colorcoding fibers.
class QmitkFiberColoringWorker : public QObject
{
Q_OBJECT
public:
QmitkFiberColoringWorker( QThread*, Package4WorkingThread );
public slots:
void run();
private:
Package4WorkingThread m_itemPackage;
QThread* m_hostingThread;
};
// ====================================================================
// ============= WORKER WHICH IS PASSED TO THREAD =====================
// ====================================================================
class QmitkFiberGenerateRandomWorker : public QObject
{
Q_OBJECT
public:
QmitkFiberGenerateRandomWorker( QThread*, Package4WorkingThread );
public slots:
void run();
private:
Package4WorkingThread m_itemPackage;
QThread* m_hostingThread;
};
// ====================================================================
// ============= WORKER WHICH IS PASSED TO THREAD =====================
// ====================================================================
class QmitkFiberFeederFAWorker : public QObject
{
Q_OBJECT
public:
QmitkFiberFeederFAWorker( QThread*, Package4WorkingThread );
public slots:
void run();
private:
Package4WorkingThread m_itemPackage;
QThread* m_hostingThread;
};
// ====================================================================
// ============= WORKER WHICH IS PASSED TO THREAD =====================
// ====================================================================
class QmitkFiberExtractorWorker : public QObject
{
Q_OBJECT
public:
QmitkFiberExtractorWorker( QThread*, Package4WorkingThread );
public slots:
void run();
private:
Package4WorkingThread m_itemPackage;
QThread* m_hostingThread;
};
// ====================================================================
// ============= WORKER WHICH IS PASSED TO THREAD =====================
// ====================================================================
class QmitkFiberThreadMonitorWorker : public QObject
{
Q_OBJECT
public:
QmitkFiberThreadMonitorWorker( QThread*, Package4WorkingThread );
void initializeMonitor();
void threadForFiberProcessingStarted();
void threadForFiberProcessingFinished();
void threadForFiberProcessingTerminated();
void setThreadStatus(QString);
public slots:
void run();
void fancyMonitorInitialization();
void fancyMonitorInitializationFinalPos();
void fancyMonitorInitializationMask();
void fancyTextFading_threadStarted();
void fancyTextFading_threadFinished();
void fancyTextFading_threadTerminated();
private:
Package4WorkingThread m_itemPackage;
QThread* m_hostingThread;
QTimer* m_thtimer_initMonitor;
QTimer* m_thtimer_initMonitorSetFinalPosition;
QTimer* m_thtimer_initMonitorSetMasks;
QTimer* m_thtimer_threadStarted;
QTimer* m_thtimer_threadFinished;
QTimer* m_thtimer_threadTerminated;
// flags for fancy fading
bool m_decreaseOpacity_threadStarted;
bool m_decreaseOpacity_threadFinished;
bool m_decreaseOpacity_threadTerminated;
// members for fancy animation
int m_pixelstepper;
int m_steppingDistance;
};
// strings to display fiber_thread monitor
const QString FBX_STATUS_IDLE = "idle";
const QString FBX_STATUS_STARTED = "starting";
const QString FBX_STATUS_RUNNING = "running";
// ========= HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW =======
const QString FIB_RADIOBUTTON_DIRECTION_RANDOM = "radioButton_directionRandom";
const QString FIB_RADIOBUTTON_DIRECTION_X = "radioButton_directionX";
const QString FIB_RADIOBUTTON_DIRECTION_Y = "radioButton_directionY";
const QString FIB_RADIOBUTTON_DIRECTION_Z = "radioButton_directionZ";
/*!
\brief QmitkFiberBundleView
\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 QmitkFiberBundleDeveloperView : 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;
QmitkFiberBundleDeveloperView();
virtual ~QmitkFiberBundleDeveloperView();
virtual void CreateQtPartControl(QWidget *parent);
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
virtual void Activated();
protected slots:
void DoGenerateFibers();
void DoGenerateFiberIDs();
void DoExtractFibers();
void DoUpdateGenerateFibersWidget();
void SelectionChangedToolBox(int);
void DoMonitorFiberThreads(int);
void DoSetFAValues();
void DoSetFAMap();
void DoColorFibers();
void DoGatherColorCodings();
void SetCurrentColorCoding(int);
void ActionDrawEllipseTriggered();
//SLOTS FOR THREADS
void BeforeThread_IdGenerate();
void AfterThread_IdGenerate();
void BeforeThread_GenerateFibersRandom();
void AfterThread_GenerateFibersRandom();
void BeforeThread_FiberSetFA();
void AfterThread_FiberSetFA();
void BeforeThread_FiberColorCoding();
void AfterThread_FiberColorCoding();
void BeforeThread_FiberExtraction();
void AfterThread_FiberExtraction();
//SLOTS FOR TIMERS
void UpdateFiberIDTimer();
void UpdateGenerateRandomFibersTimer();
void UpdateColorFibersTimer();
void UpdateExtractFibersTimer();
void UpdateSetFAValuesTimer();
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkFiberBundleDeveloperViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
private:
/* METHODS GENERATING FIBERSTRUCTURES */
void GenerateVtkFibersRandom();
vtkSmartPointer<vtkPolyData> GenerateVtkFibersDirectionX();
vtkSmartPointer<vtkPolyData> GenerateVtkFibersDirectionY();
vtkSmartPointer<vtkPolyData> GenerateVtkFibersDirectionZ();
void PutFibersToDataStorage( vtkSmartPointer<vtkPolyData> );
void PutFigureToDataStorage(mitk::PlanarFigure* , const QString& );
/* METHODS FOR FIBER PROCESSING OR PREPROCESSING */
/* HELPERMETHODS */
mitk::Geometry3D::Pointer GenerateStandardGeometryForMITK();
void ResetFiberInfoWidget();
void FeedFiberInfoWidget();
void FBXDependendGUIElementsConfigurator();
void SetGeneratedFBX();
//contains the selected FiberBundle, PlanarFigure
mitk::DataNode::Pointer m_FiberBundleNode;
- mitk::WeakPointer<mitk::FiberBundleX> m_FiberBundleX;
+ mitk::WeakPointer<mitk::FiberBundle> m_FiberBundle;
mitk::PlanarFigure::Pointer m_PlanarFigure;
// radiobutton groups
QVector< QRadioButton* > m_DirectionRadios;
QVector< QRadioButton* > m_FARadios;
QVector< QRadioButton* > m_GARadios;
// Thread based Workers which do some processing of fibers
QmitkFiberIDWorker* m_FiberIDGenerator;
QmitkFiberGenerateRandomWorker* m_GeneratorFibersRandom;
QmitkFiberFeederFAWorker* m_FiberFeederFASlave;
QmitkFiberColoringWorker* m_FiberColoringSlave;
QmitkFiberExtractorWorker* m_FiberExtractor;
QThread* m_hostThread;
QThread* m_monitorThread;
bool m_threadInProgress;
mitk::DataNode::Pointer m_MonitorNode;
QmitkFiberThreadMonitorWorker *m_fiberThreadMonitorWorker;
bool m_fiberMonitorIsOn;
// counters for ROI nodes
int m_CircleCounter;
mitk::DataNode::Pointer m_FANode;
// flag to bypass signal from qcombobox "index changed(int)"
bool m_suppressSignal;
};
#endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
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 e116a924b7..c26ea6b4ae 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
@@ -1,1487 +1,1487 @@
/*===================================================================
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 <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;
}
case 4:
{
WeightFibers();
break;
}
}
}
void QmitkFiberProcessingView::WeightFibers()
{
float weight = this->m_Controls->m_BundleWeightBox->value();
for (int i=0; i<m_SelectedFB.size(); i++)
{
- mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
fib->SetFiberWeights(weight);
}
}
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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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();
+ mitk::FiberBundle::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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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);
+ mitk::FiberBundle::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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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);
+ mitk::FiberBundle::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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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_BundleWeightFrame->setVisible(false);
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;
case 4:
m_Controls->m_BundleWeightFrame->setVisible(true);
}
// 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()) )
+ if ( dynamic_cast<mitk::FiberBundle*>(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()))
+ if (dynamic_cast<mitk::FiberBundle*>(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::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(fiberBundles.at(i)->GetData());
mitk::BaseData::Pointer roi = planarFigure->GetData();
- mitk::FiberBundleX::Pointer extFB = fib->ExtractFiberSubset(roi);
+ mitk::FiberBundle::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());
+ mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(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()));
+ newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(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()));
+ newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
fib->ColorFibersByScalarMap(dynamic_cast<mitk::Image*>(m_Controls->m_ColorMapBox->GetSelectedNode()->GetData()), m_Controls->m_FiberOpacityBox->isChecked());
}
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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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/QmitkFiberProcessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
index 24d0569311..f94facd239 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
@@ -1,189 +1,189 @@
/*===================================================================
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 QmitkFiberProcessingView_h
#define QmitkFiberProcessingView_h
#include <QmitkFunctionality.h>
#include "ui_QmitkFiberProcessingViewControls.h"
#include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkSurface.h>
#include <itkCastImageFilter.h>
#include <itkVTKImageImport.h>
#include <itkVTKImageExport.h>
#include <itkRegionOfInterestImageFilter.h>
#include <vtkLinearExtrusionFilter.h>
#include <vtkPolyDataToImageStencil.h>
#include <vtkSelectEnclosedPoints.h>
#include <vtkImageImport.h>
#include <vtkImageExport.h>
#include <vtkImageStencil.h>
#include <vtkSmartPointer.h>
#include <vtkSelection.h>
#include <vtkSelectionNode.h>
#include <vtkExtractSelectedThresholds.h>
#include <vtkFloatArray.h>
/*!
\brief View to process fiber bundles. Supplies methods to extract fibers from the bundle, join and subtract bundles and much more.
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkFiberProcessingView : 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 itk::Image< unsigned char, 3 > itkUCharImageType;
static const std::string VIEW_ID;
QmitkFiberProcessingView();
virtual ~QmitkFiberProcessingView();
virtual void CreateQtPartControl(QWidget *parent);
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
virtual void Activated();
protected slots:
void OnDrawCircle(); ///< add circle interactors etc.
void OnDrawPolygon(); ///< add circle interactors etc.
void GenerateAndComposite();
void GenerateOrComposite();
void GenerateNotComposite();
void JoinBundles(); ///< merge selected fiber bundles
void SubstractBundles(); ///< subtract bundle A from bundle B. Not commutative! Defined by order of selection.
void GenerateRoiImage(); ///< generate binary image of selected planar figures.
void Remove();
void Extract();
void Modify();
void UpdateGui(); ///< update button activity etc. dpending on current datamanager selection
virtual void AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *propertyKey = NULL, mitk::BaseProperty *property = NULL );
protected:
void MirrorFibers(); ///< mirror bundle on the specified plane
void ResampleSelectedBundles(); ///< smooth fiber bundle using the specified number of sampling points per cm.
void DoImageColorCoding(); ///< color fibers by selected scalar image
void CompressSelectedBundles(); ///< remove points below certain error threshold
void WeightFibers();
void RemoveWithMask(bool removeInside);
void RemoveDir();
void ApplyCurvatureThreshold(); ///< remove/split fibers with a too high curvature threshold
void PruneBundle(); ///< remove too short/too long fibers
void ExtractWithMask(bool onlyEnds, bool invert);
void ExtractWithPlanarFigure();
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkFiberProcessingViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
/** Connection from VTK to ITK */
template <typename VTK_Exporter, typename ITK_Importer>
void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
{
importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
importer->SetSpacingCallback(exporter->GetSpacingCallback());
importer->SetOriginCallback(exporter->GetOriginCallback());
importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
importer->SetCallbackUserData(exporter->GetCallbackUserData());
}
template <typename ITK_Exporter, typename VTK_Importer>
void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
{
importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
importer->SetSpacingCallback(exporter->GetSpacingCallback());
importer->SetOriginCallback(exporter->GetOriginCallback());
importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
importer->SetCallbackUserData(exporter->GetCallbackUserData());
}
template < typename TPixel, unsigned int VImageDimension >
void InternalCalculateMaskFromPlanarFigure(
itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName );
template < typename TPixel, unsigned int VImageDimension >
void InternalReorientImagePlane(
const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex );
int m_CircleCounter; ///< used for data node naming
int m_PolygonCounter; ///< used for data node naming
std::vector<mitk::DataNode::Pointer> m_SelectedFB; ///< selected fiber bundle nodes
std::vector<mitk::DataNode::Pointer> m_SelectedPF; ///< selected planar figure nodes
std::vector<mitk::Surface::Pointer> m_SelectedSurfaces;
mitk::Image::Pointer m_SelectedImage;
mitk::Image::Pointer m_InternalImage;
mitk::PlanarFigure::Pointer m_PlanarFigure;
itkUCharImageType::Pointer m_InternalImageMask3D;
itkUCharImageType::Pointer m_PlanarFigureImage;
float m_UpsamplingFactor; ///< upsampling factor for all image generations
mitk::DataNode::Pointer m_MaskImageNode;
void AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfc, mitk::DataNode::Pointer parentNode=NULL);
void debugPFComposition(mitk::PlanarFigureComposite::Pointer , int );
void WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image);
- mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute);
- mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib);
- mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib);
- mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib);
+ mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute);
+ mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundle::Pointer fib);
+ mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib);
+ mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib);
void NodeAdded( const mitk::DataNode* node );
void NodeRemoved(const mitk::DataNode* node);
};
#endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
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 e12f09e205..67114abb21 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
@@ -1,442 +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 <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());
+ mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(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::FiberBundle::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()) )
+ if ( dynamic_cast<mitk::FiberBundle*>(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 (node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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()))
+ if (node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()))
{
- mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(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::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsPointSet(mitk::FiberBundle::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)
+mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsImage(mitk::FiberBundle::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)
+mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateColorHeatmap(mitk::FiberBundle::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)
+mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateTractDensityImage(mitk::FiberBundle::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/QmitkFiberQuantificationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
index a8197d688b..b616fe62c9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
@@ -1,150 +1,150 @@
/*===================================================================
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 QmitkFiberQuantificationView_h
#define QmitkFiberQuantificationView_h
#include <QmitkFunctionality.h>
#include "ui_QmitkFiberQuantificationViewControls.h"
#include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkSurface.h>
#include <itkCastImageFilter.h>
#include <itkVTKImageImport.h>
#include <itkVTKImageExport.h>
#include <itkRegionOfInterestImageFilter.h>
#include <vtkLinearExtrusionFilter.h>
#include <vtkPolyDataToImageStencil.h>
#include <vtkSelectEnclosedPoints.h>
#include <vtkImageImport.h>
#include <vtkImageExport.h>
#include <vtkImageStencil.h>
#include <vtkSmartPointer.h>
#include <vtkSelection.h>
#include <vtkSelectionNode.h>
#include <vtkExtractSelectedThresholds.h>
#include <vtkFloatArray.h>
/*!
\brief View to process fiber bundles. Supplies methods to generate images from the selected bundle and much more.
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkFiberQuantificationView : 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 itk::Image< unsigned char, 3 > itkUCharImageType;
static const std::string VIEW_ID;
QmitkFiberQuantificationView();
virtual ~QmitkFiberQuantificationView();
virtual void CreateQtPartControl(QWidget *parent);
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
virtual void Activated();
protected slots:
void ProcessSelectedBundles(); ///< start selected operation on fiber bundle (e.g. tract density image generation)
void CalculateFiberDirections(); ///< Calculate main fiber directions from tractogram
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
Ui::QmitkFiberQuantificationViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
/** Connection from VTK to ITK */
template <typename VTK_Exporter, typename ITK_Importer>
void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
{
importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
importer->SetSpacingCallback(exporter->GetSpacingCallback());
importer->SetOriginCallback(exporter->GetOriginCallback());
importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
importer->SetCallbackUserData(exporter->GetCallbackUserData());
}
template <typename ITK_Exporter, typename VTK_Importer>
void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
{
importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
importer->SetSpacingCallback(exporter->GetSpacingCallback());
importer->SetOriginCallback(exporter->GetOriginCallback());
importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
importer->SetCallbackUserData(exporter->GetCallbackUserData());
}
template < typename TPixel, unsigned int VImageDimension >
void InternalCalculateMaskFromPlanarFigure(
itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName );
template < typename TPixel, unsigned int VImageDimension >
void InternalReorientImagePlane(
const itk::Image< TPixel, VImageDimension > *image, mitk::Geometry3D* planegeo3D, int additionalIndex );
void GenerateStats(); ///< generate statistics of selected fiber bundles
void UpdateGui(); ///< update button activity etc. dpending on current datamanager selection
std::vector<mitk::DataNode::Pointer> m_SelectedFB; ///< selected fiber bundle nodes
mitk::Image::Pointer m_SelectedImage;
float m_UpsamplingFactor; ///< upsampling factor for all image generations
std::vector<mitk::Surface::Pointer> m_SelectedSurfaces;
- mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute);
- mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib);
- mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib);
- mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib);
+ mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute);
+ mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundle::Pointer fib);
+ mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib);
+ mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib);
};
#endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
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 fd750f32f1..78a4210658 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2694 +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 <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::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 = 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::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::FiberBundle>::Pointer isFiberBundle = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
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() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))) // use parameters of selected DWI
{
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::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() || !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::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()) )
+ if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(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()) )
+ if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(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::FiberBundle::Pointer bundle = mitk::FiberBundle::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()))
+ if(dynamic_cast<mitk::FiberBundle*>((*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() );
+ m_SelectedBundles.at(i)->SetData( mitk::FiberBundle::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();
+ vector< mitk::FiberBundle::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)
{
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::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(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());
+ mitk::FiberBundle::Pointer fiberBundle = dynamic_cast<mitk::FiberBundle*>(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() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
{
bool first = true;
bool ok = true;
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( 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();
}
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()) )
+ if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>((*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();
+ mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>((*it)->GetData());
+ mitk::FiberBundle::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());
+ mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>((*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()));
+ newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundle*>((*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() && 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()) )
+ else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(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());
+ mitk::FiberBundle::Pointer newFib = dynamic_cast<mitk::FiberBundle*>(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()) )
+ if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(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()))
+ if (dynamic_cast<FiberBundle*>(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 edff70dd72..4e08a03627 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
@@ -1,214 +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 <mitkFiberBundle.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 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/QmitkGibbsTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
index 5de6996c71..b131d32f75 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
@@ -1,768 +1,768 @@
/*===================================================================
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 "QmitkGibbsTrackingView.h"
#include <QmitkStdMultiWidget.h>
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QDir>
// MITK
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <mitkImageAccessByItk.h>
#include <mitkProgressBar.h>
#include <mitkIOUtil.h>
// ITK
#include <itkGibbsTrackingFilter.h>
#include <itkResampleImageFilter.h>
#include <itksys/SystemTools.hxx>
// MISC
#include <tinyxml.h>
QmitkTrackingWorker::QmitkTrackingWorker(QmitkGibbsTrackingView* view)
: m_View(view)
{
}
void QmitkTrackingWorker::run()
{
m_View->m_GlobalTracker = QmitkGibbsTrackingView::GibbsTrackingFilterType::New();
m_View->m_GlobalTracker->SetQBallImage(m_View->m_ItkQBallImage);
m_View->m_GlobalTracker->SetTensorImage(m_View->m_ItkTensorImage);
m_View->m_GlobalTracker->SetMaskImage(m_View->m_MaskImage);
m_View->m_GlobalTracker->SetStartTemperature((float)m_View->m_Controls->m_StartTempSlider->value()/100);
m_View->m_GlobalTracker->SetEndTemperature((float)m_View->m_Controls->m_EndTempSlider->value()/10000);
m_View->m_GlobalTracker->SetIterations(m_View->m_Iterations);
m_View->m_GlobalTracker->SetParticleWeight((float)m_View->m_Controls->m_ParticleWeightSlider->value()/10000);
m_View->m_GlobalTracker->SetParticleWidth((float)(m_View->m_Controls->m_ParticleWidthSlider->value())/10);
m_View->m_GlobalTracker->SetParticleLength((float)(m_View->m_Controls->m_ParticleLengthSlider->value())/10);
m_View->m_GlobalTracker->SetInexBalance((float)m_View->m_Controls->m_InExBalanceSlider->value()/10);
m_View->m_GlobalTracker->SetMinFiberLength(m_View->m_Controls->m_FiberLengthSlider->value());
m_View->m_GlobalTracker->SetCurvatureThreshold(cos((float)m_View->m_Controls->m_CurvatureThresholdSlider->value()*M_PI/180));
m_View->m_GlobalTracker->SetRandomSeed(m_View->m_Controls->m_RandomSeedSlider->value());
try{
m_View->m_GlobalTracker->Update();
}
catch( mitk::Exception e )
{
MITK_ERROR << "Internal error occured: " << e.what() << "\nAborting";
}
m_View->m_TrackingThread.quit();
}
const std::string QmitkGibbsTrackingView::VIEW_ID = "org.mitk.views.gibbstracking";
QmitkGibbsTrackingView::QmitkGibbsTrackingView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget(NULL)
, m_FiberBundle(NULL)
, m_MaskImage(NULL)
, m_TensorImage(NULL)
, m_QBallImage(NULL)
, m_ItkQBallImage(NULL)
, m_ItkTensorImage(NULL)
, m_ImageNode(NULL)
, m_MaskImageNode(NULL)
, m_FiberBundleNode(NULL)
, m_ThreadIsRunning(false)
, m_ElapsedTime(0)
, m_Iterations(10000000)
, m_LastStep(0)
, m_GlobalTracker(NULL)
, m_TrackingWorker(this)
, m_TrackingNode(NULL)
{
m_TrackingWorker.moveToThread(&m_TrackingThread);
connect(&m_TrackingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
connect(&m_TrackingThread, SIGNAL(started()), &m_TrackingWorker, SLOT(run()));
connect(&m_TrackingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
connect(&m_TrackingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
m_TrackingTimer = new QTimer(this);
}
QmitkGibbsTrackingView::~QmitkGibbsTrackingView()
{
if (m_GlobalTracker.IsNull())
return;
m_GlobalTracker->SetAbortTracking(true);
m_TrackingThread.wait();
}
// update tracking status and generate fiber bundle
void QmitkGibbsTrackingView::TimerUpdate()
{
int currentStep = m_GlobalTracker->GetCurrentStep();
mitk::ProgressBar::GetInstance()->Progress(currentStep-m_LastStep);
UpdateTrackingStatus();
GenerateFiberBundle();
m_LastStep = currentStep;
}
// tell global tractography filter to stop after current step
void QmitkGibbsTrackingView::StopGibbsTracking()
{
if (m_GlobalTracker.IsNull())
return;
//mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
m_GlobalTracker->SetAbortTracking(true);
m_Controls->m_TrackingStop->setEnabled(false);
m_Controls->m_TrackingStop->setText("Stopping Tractography ...");
m_TrackingNode = NULL;
}
// update gui elements and generate fiber bundle after tracking is finished
void QmitkGibbsTrackingView::AfterThread()
{
m_ThreadIsRunning = false;
m_TrackingTimer->stop();
mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
UpdateGUI();
if( !m_GlobalTracker->GetIsInValidState() )
{
QMessageBox::critical( NULL, "Gibbs Tracking", "An internal error occured. Tracking aborted.\n Please check the log for details." );
m_FiberBundleNode = NULL;
return;
}
UpdateTrackingStatus();
if(m_Controls->m_ParticleWeightSlider->value()==0)
{
m_Controls->m_ParticleWeightLabel->setText(QString::number(m_GlobalTracker->GetParticleWeight()));
m_Controls->m_ParticleWeightSlider->setValue(m_GlobalTracker->GetParticleWeight()*10000);
}
if(m_Controls->m_ParticleWidthSlider->value()==0)
{
m_Controls->m_ParticleWidthLabel->setText(QString::number(m_GlobalTracker->GetParticleWidth()));
m_Controls->m_ParticleWidthSlider->setValue(m_GlobalTracker->GetParticleWidth()*10);
}
if(m_Controls->m_ParticleLengthSlider->value()==0)
{
m_Controls->m_ParticleLengthLabel->setText(QString::number(m_GlobalTracker->GetParticleLength()));
m_Controls->m_ParticleLengthSlider->setValue(m_GlobalTracker->GetParticleLength()*10);
}
GenerateFiberBundle();
m_FiberBundleNode = 0;
m_GlobalTracker = 0;
// images not needed anymore ( relevant only for computation )
// we need to release them to remove the memory access block created through CastToItk<> calls
this->m_ItkQBallImage = 0;
this->m_ItkTensorImage = 0;
}
// start tracking timer and update gui elements before tracking is started
void QmitkGibbsTrackingView::BeforeThread()
{
m_ThreadIsRunning = true;
m_TrackingTime = QTime::currentTime();
m_ElapsedTime = 0;
m_TrackingTimer->start(1000);
m_LastStep = 0;
UpdateGUI();
}
// setup gui elements and signal/slot connections
void QmitkGibbsTrackingView::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::QmitkGibbsTrackingViewControls;
m_Controls->setupUi( parent );
AdvancedSettings();
connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
connect( m_Controls->m_TrackingStop, SIGNAL(clicked()), this, SLOT(StopGibbsTracking()) );
connect( m_Controls->m_TrackingStart, SIGNAL(clicked()), this, SLOT(StartGibbsTracking()) );
connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
connect( m_Controls->m_SaveTrackingParameters, SIGNAL(clicked()), this, SLOT(SaveTrackingParameters()) );
connect( m_Controls->m_LoadTrackingParameters, SIGNAL(clicked()), this, SLOT(LoadTrackingParameters()) );
connect( m_Controls->m_IterationsSlider, SIGNAL(valueChanged(int)), this, SLOT(SetIterations(int)) );
connect( m_Controls->m_ParticleWidthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWidth(int)) );
connect( m_Controls->m_ParticleLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleLength(int)) );
connect( m_Controls->m_InExBalanceSlider, SIGNAL(valueChanged(int)), this, SLOT(SetInExBalance(int)) );
connect( m_Controls->m_FiberLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetFiberLength(int)) );
connect( m_Controls->m_ParticleWeightSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWeight(int)) );
connect( m_Controls->m_StartTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetStartTemp(int)) );
connect( m_Controls->m_EndTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetEndTemp(int)) );
connect( m_Controls->m_CurvatureThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(SetCurvatureThreshold(int)) );
connect( m_Controls->m_RandomSeedSlider, SIGNAL(valueChanged(int)), this, SLOT(SetRandomSeed(int)) );
connect( m_Controls->m_OutputFileButton, SIGNAL(clicked()), this, SLOT(SetOutputFile()) );
}
}
void QmitkGibbsTrackingView::SetInExBalance(int value)
{
m_Controls->m_InExBalanceLabel->setText(QString::number((float)value/10));
}
void QmitkGibbsTrackingView::SetFiberLength(int value)
{
m_Controls->m_FiberLengthLabel->setText(QString::number(value)+"mm");
}
void QmitkGibbsTrackingView::SetRandomSeed(int value)
{
if (value>=0)
m_Controls->m_RandomSeedLabel->setText(QString::number(value));
else
m_Controls->m_RandomSeedLabel->setText("auto");
}
void QmitkGibbsTrackingView::SetParticleWeight(int value)
{
if (value>0)
m_Controls->m_ParticleWeightLabel->setText(QString::number((float)value/10000));
else
m_Controls->m_ParticleWeightLabel->setText("auto");
}
void QmitkGibbsTrackingView::SetStartTemp(int value)
{
m_Controls->m_StartTempLabel->setText(QString::number((float)value/100));
}
void QmitkGibbsTrackingView::SetEndTemp(int value)
{
m_Controls->m_EndTempLabel->setText(QString::number((float)value/10000));
}
void QmitkGibbsTrackingView::SetParticleWidth(int value)
{
if (value>0)
m_Controls->m_ParticleWidthLabel->setText(QString::number((float)value/10)+" mm");
else
m_Controls->m_ParticleWidthLabel->setText("auto");
}
void QmitkGibbsTrackingView::SetParticleLength(int value)
{
if (value>0)
m_Controls->m_ParticleLengthLabel->setText(QString::number((float)value/10)+" mm");
else
m_Controls->m_ParticleLengthLabel->setText("auto");
}
void QmitkGibbsTrackingView::SetCurvatureThreshold(int value)
{
m_Controls->m_CurvatureThresholdLabel->setText(QString::number(value)+"°");
}
void QmitkGibbsTrackingView::SetIterations(int value)
{
switch(value)
{
case 0:
m_Controls->m_IterationsLabel->setText("Iterations: 1x10^4");
m_Iterations = 10000;
break;
case 1:
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
m_Iterations = 50000;
break;
case 2:
m_Controls->m_IterationsLabel->setText("Iterations: 1x10^5");
m_Iterations = 100000;
break;
case 3:
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
m_Iterations = 500000;
break;
case 4:
m_Controls->m_IterationsLabel->setText("Iterations: 1x10^6");
m_Iterations = 1000000;
break;
case 5:
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
m_Iterations = 5000000;
break;
case 6:
m_Controls->m_IterationsLabel->setText("Iterations: 1x10^7");
m_Iterations = 10000000;
break;
case 7:
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
m_Iterations = 50000000;
break;
case 8:
m_Controls->m_IterationsLabel->setText("Iterations: 1x10^8");
m_Iterations = 100000000;
break;
case 9:
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
m_Iterations = 500000000;
break;
}
}
void QmitkGibbsTrackingView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkGibbsTrackingView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
// called if datamanager selection changes
void QmitkGibbsTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
if (m_ThreadIsRunning)
return;
m_ImageNode = NULL;
m_MaskImageNode = NULL;
// iterate all selected objects
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::QBallImage*>(node->GetData()) )
m_ImageNode = node;
else if( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
m_ImageNode = node;
else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(node->GetData());
if (img->GetPixelType().GetPixelType()==itk::ImageIOBase::SCALAR)
m_MaskImageNode = node;
}
}
UpdateGUI();
}
void QmitkGibbsTrackingView::NodeRemoved(const mitk::DataNode * node)
{
if (m_ThreadIsRunning)
{
if (node==m_TrackingNode.GetPointer())
{
StopGibbsTracking();
}
}
}
// update gui elements displaying trackings status
void QmitkGibbsTrackingView::UpdateTrackingStatus()
{
if (m_GlobalTracker.IsNull())
return;
m_ElapsedTime += m_TrackingTime.elapsed()/1000;
m_TrackingTime.restart();
unsigned long hours = m_ElapsedTime/3600;
unsigned long minutes = (m_ElapsedTime%3600)/60;
unsigned long seconds = m_ElapsedTime%60;
m_Controls->m_ProposalAcceptance->setText(QString::number(m_GlobalTracker->GetProposalAcceptance()*100)+"%");
m_Controls->m_TrackingTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
m_Controls->m_NumConnectionsLabel->setText( QString::number(m_GlobalTracker->GetNumConnections()) );
m_Controls->m_NumParticlesLabel->setText( QString::number(m_GlobalTracker->GetNumParticles()) );
m_Controls->m_CurrentStepLabel->setText( QString::number(100*(float)(m_GlobalTracker->GetCurrentStep()-1)/m_GlobalTracker->GetSteps())+"%" );
m_Controls->m_AcceptedFibersLabel->setText( QString::number(m_GlobalTracker->GetNumAcceptedFibers()) );
}
// update gui elements (enable/disable elements and set tooltips)
void QmitkGibbsTrackingView::UpdateGUI()
{
if (m_ImageNode.IsNotNull())
{
m_Controls->m_QballImageLabel->setText(m_ImageNode->GetName().c_str());
m_Controls->m_DataFrame->setTitle("Input Data");
}
else
{
m_Controls->m_QballImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_DataFrame->setTitle("Please Select Input Data");
}
if (m_MaskImageNode.IsNotNull())
m_Controls->m_MaskImageLabel->setText(m_MaskImageNode->GetName().c_str());
else
m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
if (!m_ThreadIsRunning && m_ImageNode.IsNotNull())
{
m_Controls->m_TrackingStop->setEnabled(false);
m_Controls->m_TrackingStart->setEnabled(true);
m_Controls->m_LoadTrackingParameters->setEnabled(true);
m_Controls->m_IterationsSlider->setEnabled(true);
m_Controls->m_AdvancedFrame->setEnabled(true);
m_Controls->m_TrackingStop->setText("Stop Tractography");
m_Controls->m_TrackingStart->setToolTip("Start tractography. No further change of parameters possible.");
m_Controls->m_TrackingStop->setToolTip("");
}
else if (!m_ThreadIsRunning)
{
m_Controls->m_TrackingStop->setEnabled(false);
m_Controls->m_TrackingStart->setEnabled(false);
m_Controls->m_LoadTrackingParameters->setEnabled(true);
m_Controls->m_IterationsSlider->setEnabled(true);
m_Controls->m_AdvancedFrame->setEnabled(true);
m_Controls->m_TrackingStop->setText("Stop Tractography");
m_Controls->m_TrackingStart->setToolTip("No Q-Ball image selected.");
m_Controls->m_TrackingStop->setToolTip("");
}
else
{
m_Controls->m_TrackingStop->setEnabled(true);
m_Controls->m_TrackingStart->setEnabled(false);
m_Controls->m_LoadTrackingParameters->setEnabled(false);
m_Controls->m_IterationsSlider->setEnabled(false);
m_Controls->m_AdvancedFrame->setEnabled(false);
m_Controls->m_AdvancedFrame->setVisible(false);
m_Controls->m_AdvancedSettingsCheckbox->setChecked(false);
m_Controls->m_TrackingStart->setToolTip("Tracking in progress.");
m_Controls->m_TrackingStop->setToolTip("Stop tracking and display results.");
}
}
// show/hide advanced settings frame
void QmitkGibbsTrackingView::AdvancedSettings()
{
m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
}
// set mask image data node
void QmitkGibbsTrackingView::SetMask()
{
std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
if (nodes.empty())
{
m_MaskImageNode = NULL;
m_Controls->m_MaskImageLabel->setText("-");
return;
}
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()))
{
m_MaskImageNode = node;
m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
return;
}
}
}
// check for mask and qbi and start tracking thread
void QmitkGibbsTrackingView::StartGibbsTracking()
{
if(m_ThreadIsRunning)
{
MITK_WARN("QmitkGibbsTrackingView")<<"Thread already running!";
return;
}
m_GlobalTracker = NULL;
if (m_ImageNode.IsNull())
{
QMessageBox::information( NULL, "Warning", "Please load and select a qball image before starting image processing.");
return;
}
if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()))
m_QBallImage = dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData());
else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()))
m_TensorImage = dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData());
if (m_QBallImage.IsNull() && m_TensorImage.IsNull())
return;
// cast qbi to itk
m_TrackingNode = m_ImageNode;
m_ItkTensorImage = NULL;
m_ItkQBallImage = NULL;
m_MaskImage = NULL;
if (m_QBallImage.IsNotNull())
{
m_ItkQBallImage = ItkQBallImgType::New();
mitk::CastToItkImage(m_QBallImage, m_ItkQBallImage);
}
else
{
m_ItkTensorImage = ItkTensorImage::New();
mitk::CastToItkImage(m_TensorImage, m_ItkTensorImage);
}
// mask image found?
// catch exceptions thrown by the itkAccess macros
try{
if(m_MaskImageNode.IsNotNull())
{
if (dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()))
mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()), m_MaskImage);
}
}
catch(...){};
unsigned int steps = m_Iterations/10000;
if (steps<10)
steps = 10;
m_LastStep = 1;
mitk::ProgressBar::GetInstance()->AddStepsToDo(steps);
// start worker thread
m_TrackingThread.start(QThread::LowestPriority);
}
// generate mitkFiberBundle from tracking filter output
void QmitkGibbsTrackingView::GenerateFiberBundle()
{
if (m_GlobalTracker.IsNull() || (!(m_Controls->m_VisualizationCheckbox->isChecked() || m_Controls->m_VisualizeOnceButton->isChecked()) && m_ThreadIsRunning))
return;
if (m_Controls->m_VisualizeOnceButton->isChecked())
m_Controls->m_VisualizeOnceButton->setChecked(false);
vtkSmartPointer<vtkPolyData> fiberBundle = m_GlobalTracker->GetFiberBundle();
if ( m_GlobalTracker->GetNumAcceptedFibers()==0 )
return;
- m_FiberBundle = mitk::FiberBundleX::New(fiberBundle);
+ m_FiberBundle = mitk::FiberBundle::New(fiberBundle);
m_FiberBundle->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_ImageNode->GetData())->GetGeometry());
if (m_FiberBundleNode.IsNotNull()){
GetDefaultDataStorage()->Remove(m_FiberBundleNode);
m_FiberBundleNode = 0;
}
m_FiberBundleNode = mitk::DataNode::New();
m_FiberBundleNode->SetData(m_FiberBundle);
QString name("FiberBundle_");
name += m_ImageNode->GetName().c_str();
name += "_Gibbs";
m_FiberBundleNode->SetName(name.toStdString());
m_FiberBundleNode->SetVisibility(true);
if (!m_OutputFileName.isEmpty() && !m_ThreadIsRunning)
{
try
{
mitk::IOUtil::Save(m_FiberBundle.GetPointer(),m_OutputFileName.toStdString());
QMessageBox::information(NULL, "Fiber bundle saved to", m_OutputFileName);
}
catch (itk::ExceptionObject &ex)
{
QMessageBox::information(NULL, "Fiber bundle could not be saved", 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()));
}
}
if(m_ImageNode.IsNull())
GetDataStorage()->Add(m_FiberBundleNode);
else
GetDataStorage()->Add(m_FiberBundleNode, m_ImageNode);
}
void QmitkGibbsTrackingView::SetOutputFile()
{
// SELECT FOLDER DIALOG
m_OutputFileName = QFileDialog::getSaveFileName(0,
tr("Set file name"),
QDir::currentPath()+"/FiberBundle.fib",
tr("Fiber Bundle (*.fib)") );
if (m_OutputFileName.isEmpty())
m_Controls->m_OutputFileLabel->setText("N/A");
else
m_Controls->m_OutputFileLabel->setText(m_OutputFileName);
}
// save current tracking paramters as xml file (.gtp)
void QmitkGibbsTrackingView::SaveTrackingParameters()
{
TiXmlDocument documentXML;
TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
documentXML.LinkEndChild( declXML );
TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
mainXML->SetAttribute("file_version", "0.1");
documentXML.LinkEndChild(mainXML);
TiXmlElement* paramXML = new TiXmlElement("parameter_set");
paramXML->SetAttribute("iterations", QString::number(m_Iterations).toStdString());
paramXML->SetAttribute("particle_length", QString::number((float)m_Controls->m_ParticleLengthSlider->value()/10).toStdString());
paramXML->SetAttribute("particle_width", QString::number((float)m_Controls->m_ParticleWidthSlider->value()/10).toStdString());
paramXML->SetAttribute("particle_weight", QString::number((float)m_Controls->m_ParticleWeightSlider->value()/10000).toStdString());
paramXML->SetAttribute("temp_start", QString::number((float)m_Controls->m_StartTempSlider->value()/100).toStdString());
paramXML->SetAttribute("temp_end", QString::number((float)m_Controls->m_EndTempSlider->value()/10000).toStdString());
paramXML->SetAttribute("inexbalance", QString::number((float)m_Controls->m_InExBalanceSlider->value()/10).toStdString());
paramXML->SetAttribute("fiber_length", QString::number(m_Controls->m_FiberLengthSlider->value()).toStdString());
paramXML->SetAttribute("curvature_threshold", QString::number(m_Controls->m_CurvatureThresholdSlider->value()).toStdString());
mainXML->LinkEndChild(paramXML);
QString filename = QFileDialog::getSaveFileName(
0,
tr("Save Parameters"),
QDir::currentPath()+"/param.gtp",
tr("Global Tracking Parameters (*.gtp)") );
if(filename.isEmpty() || filename.isNull())
return;
if(!filename.endsWith(".gtp"))
filename += ".gtp";
documentXML.SaveFile( filename.toStdString() );
}
void QmitkGibbsTrackingView::UpdateIteraionsGUI(unsigned long iterations)
{
switch(iterations)
{
case 10000:
m_Controls->m_IterationsSlider->setValue(0);
m_Controls->m_IterationsLabel->setText("Iterations: 10^4");
break;
case 50000:
m_Controls->m_IterationsSlider->setValue(1);
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
break;
case 100000:
m_Controls->m_IterationsSlider->setValue(2);
m_Controls->m_IterationsLabel->setText("Iterations: 10^5");
break;
case 500000:
m_Controls->m_IterationsSlider->setValue(3);
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
break;
case 1000000:
m_Controls->m_IterationsSlider->setValue(4);
m_Controls->m_IterationsLabel->setText("Iterations: 10^6");
break;
case 5000000:
m_Controls->m_IterationsSlider->setValue(5);
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
break;
case 10000000:
m_Controls->m_IterationsSlider->setValue(6);
m_Controls->m_IterationsLabel->setText("Iterations: 10^7");
break;
case 50000000:
m_Controls->m_IterationsSlider->setValue(7);
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
break;
case 100000000:
m_Controls->m_IterationsSlider->setValue(8);
m_Controls->m_IterationsLabel->setText("Iterations: 10^8");
break;
case 500000000:
m_Controls->m_IterationsSlider->setValue(9);
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
break;
case 1000000000:
m_Controls->m_IterationsSlider->setValue(10);
m_Controls->m_IterationsLabel->setText("Iterations: 10^9");
break;
case 5000000000:
m_Controls->m_IterationsSlider->setValue(11);
m_Controls->m_IterationsLabel->setText("Iterations: 5x10^9");
break;
}
}
// load current tracking paramters from xml file (.gtp)
void QmitkGibbsTrackingView::LoadTrackingParameters()
{
QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Global Tracking Parameters (*.gtp)") );
if(filename.isEmpty() || filename.isNull())
return;
TiXmlDocument doc( filename.toStdString() );
doc.LoadFile();
TiXmlHandle hDoc(&doc);
TiXmlElement* pElem;
TiXmlHandle hRoot(0);
pElem = hDoc.FirstChildElement().Element();
hRoot = TiXmlHandle(pElem);
pElem = hRoot.FirstChildElement("parameter_set").Element();
QString iterations(pElem->Attribute("iterations"));
m_Iterations = iterations.toULong();
UpdateIteraionsGUI(m_Iterations);
QString particleLength(pElem->Attribute("particle_length"));
float pLength = particleLength.toFloat();
QString particleWidth(pElem->Attribute("particle_width"));
float pWidth = particleWidth.toFloat();
if (pLength==0)
m_Controls->m_ParticleLengthLabel->setText("auto");
else
m_Controls->m_ParticleLengthLabel->setText(particleLength+" mm");
if (pWidth==0)
m_Controls->m_ParticleWidthLabel->setText("auto");
else
m_Controls->m_ParticleWidthLabel->setText(particleWidth+" mm");
m_Controls->m_ParticleWidthSlider->setValue(pWidth*10);
m_Controls->m_ParticleLengthSlider->setValue(pLength*10);
QString partWeight(pElem->Attribute("particle_weight"));
m_Controls->m_ParticleWeightSlider->setValue(partWeight.toFloat()*10000);
m_Controls->m_ParticleWeightLabel->setText(partWeight);
QString startTemp(pElem->Attribute("temp_start"));
m_Controls->m_StartTempSlider->setValue(startTemp.toFloat()*100);
m_Controls->m_StartTempLabel->setText(startTemp);
QString endTemp(pElem->Attribute("temp_end"));
m_Controls->m_EndTempSlider->setValue(endTemp.toFloat()*10000);
m_Controls->m_EndTempLabel->setText(endTemp);
QString inExBalance(pElem->Attribute("inexbalance"));
m_Controls->m_InExBalanceSlider->setValue(inExBalance.toFloat()*10);
m_Controls->m_InExBalanceLabel->setText(inExBalance);
QString fiberLength(pElem->Attribute("fiber_length"));
m_Controls->m_FiberLengthSlider->setValue(fiberLength.toInt());
m_Controls->m_FiberLengthLabel->setText(fiberLength+"mm");
QString curvThres(pElem->Attribute("curvature_threshold"));
m_Controls->m_CurvatureThresholdSlider->setValue(curvThres.toInt());
m_Controls->m_CurvatureThresholdLabel->setText(curvThres+"°");
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
index 5cebd39bb4..a9294e9ca7 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
@@ -1,167 +1,167 @@
/*===================================================================
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 QmitkGibbsTrackingView_h
#define QmitkGibbsTrackingView_h
#include <berryISelectionListener.h>
#include <QmitkFunctionality.h>
#include "ui_QmitkGibbsTrackingViewControls.h"
#include <mitkQBallImage.h>
#include <QThread>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <QTime>
#include <itkImage.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <itkDiffusionTensor3D.h>
#include <mitkTensorImage.h>
class QmitkGibbsTrackingView;
class QmitkTrackingWorker : public QObject
{
Q_OBJECT
public:
QmitkTrackingWorker(QmitkGibbsTrackingView* view);
public slots:
void run();
private:
QmitkGibbsTrackingView* m_View;
};
/*!
\brief View for global fiber tracking (Gibbs tracking)
\sa QmitkFunctionality
\ingroup Functionalities
*/
typedef itk::Image< float, 3 > FloatImageType;
namespace itk
{
template<class X>
class GibbsTrackingFilter;
}
class QmitkGibbsTrackingView : 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 itk::Image<float,3> ItkFloatImageType;
typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType, 3> ItkQBallImgType;
typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
typedef itk::GibbsTrackingFilter< ItkQBallImgType > GibbsTrackingFilterType;
static const std::string VIEW_ID;
QmitkGibbsTrackingView();
virtual ~QmitkGibbsTrackingView();
virtual void CreateQtPartControl(QWidget *parent);
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
signals:
protected slots:
void StartGibbsTracking();
void StopGibbsTracking();
void AfterThread(); ///< update gui etc. after tracking has finished
void BeforeThread(); ///< start timer etc.
void TimerUpdate();
void SetMask();
void AdvancedSettings(); ///< show/hide advanced tracking options
void SaveTrackingParameters(); ///< save tracking parameters to xml file
void LoadTrackingParameters(); ///< load tracking parameters from xml file
/** update labels if parameters have changed */
void SetIterations(int value);
void SetParticleWidth(int value);
void SetParticleLength(int value);
void SetInExBalance(int value);
void SetFiberLength(int value);
void SetParticleWeight(int value);
void SetStartTemp(int value);
void SetEndTemp(int value);
void SetCurvatureThreshold(int value);
void SetRandomSeed(int value);
void SetOutputFile();
private:
// Visualization & GUI
void GenerateFiberBundle(); ///< generate fiber bundle from tracking output and add to datanode
void UpdateGUI(); ///< update button activity etc. dpending on current datamanager selection
void UpdateTrackingStatus(); ///< update textual status display of the tracking process
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
/// \brief called when DataNode is removed to stop gibbs tracking after node is removed
virtual void NodeRemoved(const mitk::DataNode * node);
void UpdateIteraionsGUI(unsigned long iterations); ///< update iterations label text
Ui::QmitkGibbsTrackingViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
/** data objects */
mitk::DataNode::Pointer m_TrackingNode; ///< actual node that is tracked
- mitk::FiberBundleX::Pointer m_FiberBundle; ///< tracking output
+ mitk::FiberBundle::Pointer m_FiberBundle; ///< tracking output
ItkFloatImageType::Pointer m_MaskImage; ///< used to reduce the algorithms search space. tracking only inside of the mask.
mitk::TensorImage::Pointer m_TensorImage; ///< actual image that is tracked
mitk::QBallImage::Pointer m_QBallImage; ///< actual image that is tracked
ItkQBallImgType::Pointer m_ItkQBallImage; ///< actual image that is tracked
ItkTensorImage::Pointer m_ItkTensorImage; ///< actual image that is tracked
/** data nodes */
mitk::DataNode::Pointer m_ImageNode;
mitk::DataNode::Pointer m_MaskImageNode;
mitk::DataNode::Pointer m_FiberBundleNode;
/** flags etc. */
bool m_ThreadIsRunning;
QTimer* m_TrackingTimer;
QTime m_TrackingTime;
unsigned long m_ElapsedTime;
unsigned long m_Iterations;
int m_LastStep;
QString m_OutputFileName;
/** global tracker and friends */
itk::SmartPointer<GibbsTrackingFilterType> m_GlobalTracker;
QmitkTrackingWorker m_TrackingWorker;
QThread m_TrackingThread;
friend class QmitkTrackingWorker;
};
#endif // _QMITKGibbsTrackingVIEW_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 c928cfe266..15fd3e614c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
@@ -1,778 +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 <mitkFiberBundle.h>
#include <mitkImage.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();
+ mitk::FiberBundle::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();
+ mitk::FiberBundle::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();
+ mitk::FiberBundle::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();
+ mitk::FiberBundle::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();
+ mitk::FiberBundle::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/QmitkStochasticFiberTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
index a5ccce623d..738e29bf18 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
@@ -1,295 +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 <mitkFiberBundle.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()) )
{
bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
if ( isDiffusionImage )
{
m_DiffusionImageNode = node;
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 */
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, static_cast<mitk::FloatProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
}
}
/* define measurement frame (identity-matrix 3x3) */
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( 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(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);
+ mitk::FiberBundle::Pointer fib = mitk::FiberBundle::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/QmitkStreamlineTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
index 6c60f8db19..da8fb53113 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
@@ -1,286 +1,286 @@
/*===================================================================
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 "QmitkStreamlineTrackingView.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
// MITK
#include <mitkImageToItk.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
#include <mitkImageCast.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateDimension.h>
// VTK
#include <vtkPolyData.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkSmartPointer.h>
#include <vtkPolyLine.h>
#include <vtkCellData.h>
const std::string QmitkStreamlineTrackingView::VIEW_ID = "org.mitk.views.streamlinetracking";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace berry;
QmitkStreamlineTrackingView::QmitkStreamlineTrackingView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_MaskImage( NULL )
, m_SeedRoi( NULL )
{
}
// Destructor
QmitkStreamlineTrackingView::~QmitkStreamlineTrackingView()
{
}
void QmitkStreamlineTrackingView::CreateQtPartControl( QWidget *parent )
{
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkStreamlineTrackingViewControls;
m_Controls->setupUi( parent );
m_Controls->m_FaImageBox->SetDataStorage(this->GetDataStorage());
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImagePredicate = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New( isBinaryPredicate );
mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New( isImagePredicate, isNotBinaryPredicate );
mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
m_Controls->m_FaImageBox->SetPredicate( mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, dimensionPredicate) );
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_MinTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMinTractLengthChanged(int)) );
connect( m_Controls->m_FaThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(OnFaThresholdChanged(int)) );
connect( m_Controls->m_AngularThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAngularThresholdChanged(int)) );
connect( m_Controls->m_StepsizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnStepsizeChanged(int)) );
connect( m_Controls->m_fSlider, SIGNAL(valueChanged(int)), this, SLOT(OnfChanged(int)) );
connect( m_Controls->m_gSlider, SIGNAL(valueChanged(int)), this, SLOT(OngChanged(int)) );
}
}
void QmitkStreamlineTrackingView::OnfChanged(int value)
{
m_Controls->m_fLabel->setText(QString("f: ")+QString::number((float)value/100));
}
void QmitkStreamlineTrackingView::OngChanged(int value)
{
m_Controls->m_gLabel->setText(QString("g: ")+QString::number((float)value/100));
}
void QmitkStreamlineTrackingView::OnAngularThresholdChanged(int value)
{
if (value<0)
m_Controls->m_AngularThresholdLabel->setText(QString("Min. Curvature Radius: auto"));
else
m_Controls->m_AngularThresholdLabel->setText(QString("Min. Curvature Radius: ")+QString::number((float)value/10)+QString("mm"));
}
void QmitkStreamlineTrackingView::OnSeedsPerVoxelChanged(int value)
{
m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
}
void QmitkStreamlineTrackingView::OnMinTractLengthChanged(int value)
{
m_Controls->m_MinTractLengthLabel->setText(QString("Min. Tract Length: ")+QString::number(value)+QString("mm"));
}
void QmitkStreamlineTrackingView::OnFaThresholdChanged(int value)
{
m_Controls->m_FaThresholdLabel->setText(QString("FA Threshold: ")+QString::number((float)value/100));
}
void QmitkStreamlineTrackingView::OnStepsizeChanged(int value)
{
if (value==0)
m_Controls->m_StepsizeLabel->setText(QString("Stepsize: auto"));
else
m_Controls->m_StepsizeLabel->setText(QString("Stepsize: ")+QString::number((float)value/10)+QString("mm"));
}
void QmitkStreamlineTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkStreamlineTrackingView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkStreamlineTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_TensorImageNodes.clear();
m_TensorImages.clear();
m_SeedRoi = NULL;
m_MaskImage = NULL;
m_Controls->m_TensorImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_RoiImageLabel->setText("<font color='grey'>optional</font>");
m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</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::TensorImage*>(node->GetData()) )
{
m_TensorImageNodes.push_back(node);
m_TensorImages.push_back(dynamic_cast<mitk::TensorImage*>(node->GetData()));
}
else
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary && m_SeedRoi.IsNull())
{
m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
}
else if (isBinary)
{
m_MaskImage = dynamic_cast<mitk::Image*>(node->GetData());
m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
}
}
}
}
if(!m_TensorImageNodes.empty())
{
if (m_TensorImageNodes.size()>1)
m_Controls->m_TensorImageLabel->setText(m_TensorImageNodes.size()+" tensor images selected");
else
m_Controls->m_TensorImageLabel->setText(m_TensorImageNodes.at(0)->GetName().c_str());
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 QmitkStreamlineTrackingView::DoFiberTracking()
{
if (m_TensorImages.empty())
return;
typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
typedef mitk::ImageToItk<TensorImageType> CastType;
typedef mitk::ImageToItk<ItkUCharImageType> CastType2;
typedef itk::StreamlineTrackingFilter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
for (int i=0; i<(int)m_TensorImages.size(); i++)
{
CastType::Pointer caster = CastType::New();
caster->SetInput(m_TensorImages.at(i));
caster->Update();
filter->SetInput(i, caster->GetOutput());
}
if (m_Controls->m_UseFaImage->isChecked())
{
mitk::ImageToItk<ItkFloatImageType>::Pointer floatCast = mitk::ImageToItk<ItkFloatImageType>::New();
floatCast->SetInput(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()));
floatCast->Update();
filter->SetFaImage(floatCast->GetOutput());
}
//filter->SetNumberOfThreads(1);
filter->SetSeedsPerVoxel(m_Controls->m_SeedsPerVoxelSlider->value());
filter->SetFaThreshold((float)m_Controls->m_FaThresholdSlider->value()/100);
filter->SetMinCurvatureRadius((float)m_Controls->m_AngularThresholdSlider->value()/10);
filter->SetStepSize((float)m_Controls->m_StepsizeSlider->value()/10);
filter->SetF((float)m_Controls->m_fSlider->value()/100);
filter->SetG((float)m_Controls->m_gSlider->value()/100);
filter->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
filter->SetMinTractLength(m_Controls->m_MinTractLengthSlider->value());
if (m_SeedRoi.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(m_SeedRoi, mask);
filter->SetSeedImage(mask);
}
if (m_MaskImage.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(m_MaskImage, mask);
filter->SetMaskImage(mask);
}
filter->Update();
vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
if ( fiberBundle->GetNumberOfLines()==0 )
{
QMessageBox warnBox;
warnBox.setWindowTitle("Warning");
warnBox.setText("No fiberbundle was generated!");
warnBox.setDetailedText("No fibers were generated using the parameters: \n\n" + m_Controls->m_FaThresholdLabel->text() + "\n" + m_Controls->m_AngularThresholdLabel->text() + "\n" + m_Controls->m_fLabel->text() + "\n" + m_Controls->m_gLabel->text() + "\n" + m_Controls->m_StepsizeLabel->text() + "\n" + m_Controls->m_MinTractLengthLabel->text() + "\n" + m_Controls->m_SeedsPerVoxelLabel->text() + "\n\nPlease check your parametersettings.");
warnBox.setIcon(QMessageBox::Warning);
warnBox.exec();
return;
}
- mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberBundle);
+ mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_TensorImageNodes.at(0)->GetData())->GetGeometry());
if (m_Controls->m_ResampleFibersBox->isChecked())
fib->Compress(m_Controls->m_FiberErrorBox->value());
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(fib);
QString name("FiberBundle_");
name += m_TensorImageNodes.at(0)->GetName().c_str();
name += "_Streamline";
node->SetName(name.toStdString());
node->SetVisibility(true);
GetDataStorage()->Add(node, m_TensorImageNodes.at(0));
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
index 7de3c7fdef..efc75ed8e0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
@@ -1,1137 +1,1137 @@
/*===================================================================
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 "QmitkTractbasedSpatialStatisticsView.h"
#include "QmitkStdMultiWidget.h"
#include "mitkDataNodeObject.h"
#include <itkCastImageFilter.h>
// Qt
#include <QMessageBox>
#include <QInputDialog>
#include <QClipboard>
#include <qwt_plot_picker.h>
#include <mitkTractAnalyzer.h>
#include <mitkTbssImporter.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarFigureInteractor.h>
#include "vtkPoints.h"
#include <vtkCellArray.h>
#include <vtkPolyLine.h>
const std::string QmitkTractbasedSpatialStatisticsView::VIEW_ID = "org.mitk.views.tractbasedspatialstatistics";
using namespace berry;
QmitkTractbasedSpatialStatisticsView::QmitkTractbasedSpatialStatisticsView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
}
QmitkTractbasedSpatialStatisticsView::~QmitkTractbasedSpatialStatisticsView()
{
}
void QmitkTractbasedSpatialStatisticsView::PerformChange()
{
m_Controls->m_RoiPlotWidget->ModifyPlot(m_Controls->m_Segments->value(), m_Controls->m_Average->isChecked());
}
void QmitkTractbasedSpatialStatisticsView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
{
//datamanager selection changed
if (!this->IsActivated())
return;
// Check which datatypes are selected in the datamanager and enable/disable widgets accordingly
bool foundTbssRoi = false;
bool foundTbss = false;
bool found3dImage = false;
bool found4dImage = false;
bool foundFiberBundle = false;
bool foundStartRoi = false;
bool foundEndRoi = false;
mitk::TbssRoiImage* roiImage;
mitk::TbssImage* image;
mitk::Image* img;
- mitk::FiberBundleX* fib;
+ mitk::FiberBundle* fib;
mitk::PlanarFigure* start;
mitk::PlanarFigure* end;
m_CurrentStartRoi = NULL;
m_CurrentEndRoi = NULL;
for ( int i=0; i<nodes.size(); i++ )
{
// only look at interesting types
// check for valid data
mitk::BaseData* nodeData = nodes[i]->GetData();
if( nodeData )
{
if(QString("TbssRoiImage").compare(nodeData->GetNameOfClass())==0)
{
foundTbssRoi = true;
roiImage = static_cast<mitk::TbssRoiImage*>(nodeData);
}
else if (QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
{
foundTbss = true;
image = static_cast<mitk::TbssImage*>(nodeData);
}
else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
{
img = static_cast<mitk::Image*>(nodeData);
if(img->GetDimension() == 3)
{
found3dImage = true;
}
else if(img->GetDimension() == 4)
{
found4dImage = true;
}
}
- else if (QString("FiberBundleX").compare(nodeData->GetNameOfClass())==0)
+ else if (QString("FiberBundle").compare(nodeData->GetNameOfClass())==0)
{
foundFiberBundle = true;
- fib = static_cast<mitk::FiberBundleX*>(nodeData);
+ fib = static_cast<mitk::FiberBundle*>(nodeData);
this->m_CurrentFiberNode = nodes[i];
}
if(QString("PlanarCircle").compare(nodeData->GetNameOfClass())==0)
{
if(!foundStartRoi)
{
start = dynamic_cast<mitk::PlanarFigure*>(nodeData);
this->m_CurrentStartRoi = nodes[i];
foundStartRoi = true;
}
else
{
end = dynamic_cast<mitk::PlanarFigure*>(nodeData);
this->m_CurrentEndRoi = nodes[i];
foundEndRoi = true;
}
}
}
}
this->m_Controls->m_CreateRoi->setEnabled(found3dImage);
this->m_Controls->m_ImportFsl->setEnabled(found4dImage);
if(foundTbss && foundTbssRoi)
{
this->Plot(image, roiImage);
}
else if(found3dImage && foundFiberBundle && foundStartRoi && foundEndRoi)
{
this->PlotFiberBundle(fib, img, start, end);
}
else if(found3dImage && foundFiberBundle)
{
this->PlotFiberBundle(fib, img);
}
else if(foundTbss && foundStartRoi && foundEndRoi && foundFiberBundle)
{
this->PlotFiber4D(image, fib, start, end);
}
if(found3dImage)
{
this->InitPointsets();
}
this->m_Controls->m_Cut->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi);
this->m_Controls->m_SegmentLabel->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && (found3dImage || foundTbss));
this->m_Controls->m_Segments->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && (found3dImage || foundTbss));
this->m_Controls->m_Average->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
}
void QmitkTractbasedSpatialStatisticsView::InitPointsets()
{
// Check if PointSetStart exsits, if not create it.
m_P1 = this->GetDefaultDataStorage()->GetNamedNode("PointSetNode");
if (m_PointSetNode)
{
//m_PointSetNode = dynamic_cast<mitk::PointSet*>(m_P1->GetData());
return;
}
if ((!m_P1) || (!m_PointSetNode))
{
// create new ones
m_PointSetNode = mitk::PointSet::New();
m_P1 = mitk::DataNode::New();
m_P1->SetData( m_PointSetNode );
m_P1->SetProperty( "name", mitk::StringProperty::New( "PointSet" ) );
m_P1->SetProperty( "opacity", mitk::FloatProperty::New( 1 ) );
m_P1->SetProperty( "helper object", mitk::BoolProperty::New(true) ); // CHANGE if wanted
m_P1->SetProperty( "pointsize", mitk::FloatProperty::New( 0.1 ) );
m_P1->SetColor( 1.0, 0.0, 0.0 );
this->GetDefaultDataStorage()->Add(m_P1);
m_Controls->m_PointWidget->SetPointSetNode(m_P1);
m_Controls->m_PointWidget->SetMultiWidget(GetActiveStdMultiWidget());
}
}
void QmitkTractbasedSpatialStatisticsView::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::QmitkTractbasedSpatialStatisticsViewControls;
m_Controls->setupUi( parent );
this->CreateConnections();
}
// Table for the FSL TBSS import
m_GroupModel = new QmitkTbssTableModel();
m_Controls->m_GroupInfo->setModel(m_GroupModel);
}
void QmitkTractbasedSpatialStatisticsView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkTractbasedSpatialStatisticsView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkTractbasedSpatialStatisticsView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_CreateRoi), SIGNAL(clicked()), this, SLOT(CreateRoi()) );
connect( (QObject*)(m_Controls->m_ImportFsl), SIGNAL(clicked()), this, SLOT(TbssImport()) );
connect( (QObject*)(m_Controls->m_AddGroup), SIGNAL(clicked()), this, SLOT(AddGroup()) );
connect( (QObject*)(m_Controls->m_RemoveGroup), SIGNAL(clicked()), this, SLOT(RemoveGroup()) );
connect( (QObject*)(m_Controls->m_Clipboard), SIGNAL(clicked()), this, SLOT(CopyToClipboard()) );
connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(selected(const QPointF&)), SLOT(Clicked(const QPointF&) ) );
connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(moved(const QPointF&)), SLOT(Clicked(const QPointF&) ) );
connect( (QObject*)(m_Controls->m_Cut), SIGNAL(clicked()), this, SLOT(Cut()) );
connect( (QObject*)(m_Controls->m_Average), SIGNAL(stateChanged(int)), this, SLOT(PerformChange()) );
connect( (QObject*)(m_Controls->m_Segments), SIGNAL(valueChanged(int)), this, SLOT(PerformChange()) );
}
}
void QmitkTractbasedSpatialStatisticsView::CopyToClipboard()
{
if(m_Controls->m_RoiPlotWidget->IsPlottingFiber())
{
// Working with fiber bundles
std::vector <std::vector<double> > profiles = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
QString clipboardText;
for (std::vector<std::vector<double> >::iterator it = profiles.begin(); it
!= profiles.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"));
}
if(m_Controls->m_Average->isChecked())
{
std::vector<double> averages = m_Controls->m_RoiPlotWidget->GetAverageProfile();
clipboardText.append(QString("\nAverage\n"));
for (std::vector<double>::iterator it2 = averages.begin(); it2 !=
averages.end(); ++it2)
{
clipboardText.append(QString("%1 \t").arg(*it2));
}
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
else{
// Working with TBSS Data
if(m_Controls->m_Average->isChecked())
{
std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetVals();
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));
double d = *it2;
std::cout << d <<std::endl;
}
clipboardText.append(QString("\n"));
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
else
{
std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
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));
double d = *it2;
std::cout << d <<std::endl;
}
clipboardText.append(QString("\n"));
}
QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
}
}
}
void QmitkTractbasedSpatialStatisticsView::RemoveGroup()
{
QTableView *temp = static_cast<QTableView*>(m_Controls->m_GroupInfo);
QItemSelectionModel *selectionModel = temp->selectionModel();
QModelIndexList indices = selectionModel->selectedRows();
QModelIndex index;
foreach(index, indices)
{
int row = index.row();
m_GroupModel->removeRows(row, 1, QModelIndex());
}
}
void QmitkTractbasedSpatialStatisticsView::AddGroup()
{
QString group("Group");
int number = 0;
QPair<QString, int> pair(group, number);
QList< QPair<QString, int> >list = m_GroupModel->getList();
if(!list.contains(pair))
{
m_GroupModel->insertRows(0, 1, QModelIndex());
QModelIndex index = m_GroupModel->index(0, 0, QModelIndex());
m_GroupModel->setData(index, group, Qt::EditRole);
index = m_GroupModel->index(0, 1, QModelIndex());
m_GroupModel->setData(index, number, Qt::EditRole);
}
}
void QmitkTractbasedSpatialStatisticsView::TbssImport()
{
// Read groups from the interface
mitk::TbssImporter::Pointer importer = mitk::TbssImporter::New();
QList< QPair<QString, int> >list = m_GroupModel->getList();
if(list.size() == 0)
{
QMessageBox msgBox;
msgBox.setText("No study group information has been set yet.");
msgBox.exec();
return;
}
std::vector < std::pair<std::string, int> > groups;
for(int i=0; i<list.size(); i++)
{
QPair<QString, int> pair = list.at(i);
std::string s = pair.first.toStdString();
int n = pair.second;
std::pair<std::string, int> p;
p.first = s;
p.second = n;
groups.push_back(p);
}
importer->SetGroupInfo(groups);
std::string minfo = m_Controls->m_MeasurementInfo->text().toStdString();
importer->SetMeasurementInfo(minfo);
std::string name = "";
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
for ( int i=0; i<nodes.size(); i++ )
{
if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
{
mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
if(img->GetDimension() == 4)
{
importer->SetImportVolume(img);
name = nodes[i]->GetName();
}
}
}
mitk::TbssImage::Pointer tbssImage;
tbssImage = importer->Import();
name += "_tbss";
AddTbssToDataStorage(tbssImage, name);
}
void QmitkTractbasedSpatialStatisticsView::AddTbssToDataStorage(mitk::Image* image, std::string name)
{
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( image );
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
levWinProp->SetLevelWindow( levelwindow );
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty( "name", mitk::StringProperty::New(name) );
result->SetData( image );
result->SetProperty( "levelwindow", levWinProp );
// add new image to data storage and set as active to ease further processing
GetDefaultDataStorage()->Add( result );
// show the results
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkTractbasedSpatialStatisticsView::Clicked(const QPointF& pos)
{
int index = (int)pos.x();
if(m_Roi.size() > 0 && m_CurrentGeometry != NULL && !m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
{
index = std::min( (int)m_Roi.size()-1, std::max(0, index) );
itk::Index<3> ix = m_Roi.at(index);
mitk::Vector3D i;
i[0] = ix[0];
i[1] = ix[1];
i[2] = ix[2];
mitk::Vector3D w;
m_CurrentGeometry->IndexToWorld(i, w);
mitk::Point3D origin = m_CurrentGeometry->GetOrigin();
mitk::Point3D p;
p[0] = w[0] + origin[0];
p[1] = w[1] + origin[1];
p[2] = w[2] + origin[2];
m_MultiWidget->MoveCrossToPosition(p);
m_Controls->m_RoiPlotWidget->drawBar(index);
}
else if(m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
{
mitk::Point3D point = m_Controls->m_RoiPlotWidget->GetPositionInWorld(index);
m_MultiWidget->MoveCrossToPosition(point);
}
}
void QmitkTractbasedSpatialStatisticsView::Cut()
{
mitk::BaseData* fibData = m_CurrentFiberNode->GetData();
- mitk::FiberBundleX* fib = static_cast<mitk::FiberBundleX*>(fibData);
+ mitk::FiberBundle* fib = static_cast<mitk::FiberBundle*>(fibData);
mitk::BaseData* startData = m_CurrentStartRoi->GetData();
mitk::PlanarFigure* startRoi = static_cast<mitk::PlanarFigure*>(startData);
mitk::PlaneGeometry* startGeometry2D = const_cast<mitk::PlaneGeometry*>(startRoi->GetPlaneGeometry());
mitk::BaseData* endData = m_CurrentEndRoi->GetData();
mitk::PlanarFigure* endRoi = static_cast<mitk::PlanarFigure*>(endData);
mitk::PlaneGeometry* endGeometry2D = const_cast<mitk::PlaneGeometry*>(endRoi->GetPlaneGeometry());
mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
- mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
- mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
+ mitk::FiberBundle::Pointer inStart = fib->ExtractFiberSubset(startRoi);
+ mitk::FiberBundle::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
int num = inBoth->GetNumFibers();
vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
vtkCellArray* lines = fiberPolyData->GetLines();
lines->InitTraversal();
// initialize new vtk polydata
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
int pointIndex=0;
// find start and endpoint
for( int fiberID( 0 ); fiberID < num; fiberID++ )
{
vtkIdType numPointsInCell(0);
vtkIdType* pointsInCell(NULL);
lines->GetNextCell ( numPointsInCell, pointsInCell );
int startId = 0;
int endId = 0;
float minDistStart = std::numeric_limits<float>::max();
float minDistEnd = std::numeric_limits<float>::max();
vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
int lineIndex=0;
for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
{
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
mitk::Point3D point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
float distanceToStart = point.EuclideanDistanceTo(startCenter);
float distanceToEnd = point.EuclideanDistanceTo(endCenter);
if(distanceToStart < minDistStart)
{
minDistStart = distanceToStart;
startId = pointInCellID;
}
if(distanceToEnd < minDistEnd)
{
minDistEnd = distanceToEnd;
endId = pointInCellID;
}
}
/* We found the start and end points of of the part that should be plottet for
the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
must be reversed*/
if(startId < endId)
{
double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0];
p0[1] = p[1];
p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
mitk::Vector3D p1;
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0];
pStart[1] = p0[1];
pStart[2] = p0[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
mitk::Point3D pSecond;
pSecond[0] = p1[0];
pSecond[1] = p1[1];
pSecond[2] = p1[2];
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
// Calculate intersection with the plane
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0];
onPlane[1] = startCenter[1];
onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId+1 lie on the same side of the plane, so we need
need startId-1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
}
double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
double insertPoint[3];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
// First insert the intersection with the start roi
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
if(! (secondOnPositive ^ startOnPositive) )
{
/* StartId and startId+1 lie on the same side of the plane
so startId is also part of the ROI*/
double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
points->InsertNextPoint(start);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// Insert the rest up and to including endId-1
for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
{
// create new polyline for new polydata
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
points->InsertNextPoint(p);
// add point to line
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
/* endId must be included if endId and endId-1 lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0]; p0[1] = p[1]; p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
p1[0] = p[0]; p1[1] = p[1]; p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0]; pLast[1] = p0[1]; pLast[2] = p0[2];
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0]; pBeforeLast[1] = p1[1]; pBeforeLast[2] = p1[2];
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
normal = endGeometry2D->GetNormal();
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId-1 lie on the same side of the plane, so we need
need endId+1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure
endId is part of the roi so can also be included here*/
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
points->InsertNextPoint(end);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
//Insert the Last Point (intersection with the end roi)
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// Need to reverse walking order
else{
double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
mitk::Vector3D p0;
p0[0] = p[0];
p0[1] = p[1];
p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
mitk::Vector3D p1;
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
// Check if p and p2 are both on the same side of the plane
mitk::Vector3D normal = startGeometry2D->GetNormal();
mitk::Point3D pStart;
pStart[0] = p0[0];
pStart[1] = p0[1];
pStart[2] = p0[2];
bool startOnPositive = startGeometry2D->IsAbove(pStart);
mitk::Point3D pSecond;
pSecond[0] = p1[0];
pSecond[1] = p1[1];
pSecond[2] = p1[2];
bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
// Calculate intersection with the plane
mitk::Vector3D onPlane;
onPlane[0] = startCenter[0];
onPlane[1] = startCenter[1];
onPlane[2] = startCenter[2];
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId-1 lie on the same side of the plane, so we need
need startId+1 to calculate the intersection with the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
}
double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
mitk::Vector3D newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
double insertPoint[3];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
// First insert the intersection with the start roi
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
if(! (secondOnPositive ^ startOnPositive) )
{
/* startId and startId-1 lie on the same side of the plane
so endId is also part of the ROI*/
double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
points->InsertNextPoint(start);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// Insert the rest up and to including endId-1
for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
{
// create new polyline for new polydata
double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
points->InsertNextPoint(p);
// add point to line
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
/* startId must be included if startId and startId+ lie on the same side of the
plane defined by endRoi*/
p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
p0[0] = p[0];
p0[1] = p[1];
p0[2] = p[2];
p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
mitk::Point3D pLast;
pLast[0] = p0[0];
pLast[1] = p0[1];
pLast[2] = p0[2];
bool lastOnPositive = endGeometry2D->IsAbove(pLast);
mitk::Point3D pBeforeLast;
pBeforeLast[0] = p1[0];
pBeforeLast[1] = p1[1];
pBeforeLast[2] = p1[2];
bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
onPlane[0] = endCenter[0];
onPlane[1] = endCenter[1];
onPlane[2] = endCenter[2];
if(! (lastOnPositive ^ secondLastOnPositive) )
{
/* endId and endId+1 lie on the same side of the plane, so we need
need endId-1 to calculate the intersection with the planar figure.
this should exist since we know that the fiber crosses the planar figure*/
p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
p1[0] = p[0];
p1[1] = p[1];
p1[2] = p[2];
/* endId and endId+1 lie on the same side of the plane
so startId is also part of the ROI*/
double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
points->InsertNextPoint(end);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
newPoint = (p0-p1);
newPoint[0] = d*newPoint[0] + p0[0];
newPoint[1] = d*newPoint[1] + p0[1];
newPoint[2] = d*newPoint[2] + p0[2];
insertPoint[0] = newPoint[0];
insertPoint[1] = newPoint[1];
insertPoint[2] = newPoint[2];
//Insert the Last Point (intersection with the end roi)
points->InsertNextPoint(insertPoint);
polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
lineIndex++;
pointIndex++;
}
// add polyline to vtk cell array
cells->InsertNextCell(polyLine);
}
// Add the points to the dataset
polyData->SetPoints(points);
// Add the lines to the dataset
polyData->SetLines(cells);
- mitk::FiberBundleX::Pointer cutBundle = mitk::FiberBundleX::New(polyData);
+ mitk::FiberBundle::Pointer cutBundle = mitk::FiberBundle::New(polyData);
mitk::DataNode::Pointer cutNode = mitk::DataNode::New();
cutNode->SetData(cutBundle);
std::string name = "fiberCut";
cutNode->SetName(name);
GetDataStorage()->Add(cutNode);
}
void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkTractbasedSpatialStatisticsView::CreateRoi()
{
bool ok;
double threshold = QInputDialog::getDouble(m_Controls->m_CreateRoi, tr("Set an FA threshold"),
tr("Threshold:"), 0.2, 0.0, 1.0, 2, &ok);
if(!ok)
return;
mitk::Image::Pointer image;
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
for ( int i=0; i<nodes.size(); i++ )
{
if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
{
mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
if(img->GetDimension() == 3)
{
image = img;
}
}
}
if(image.IsNull())
{
return;
}
mitk::TractAnalyzer analyzer;
analyzer.SetInputImage(image);
analyzer.SetThreshold(threshold);
m_PointSetNode = this->m_Controls->m_PointWidget->GetPointSet();
// Set Pointset to analyzer
analyzer.SetPointSet(m_PointSetNode);
// Run Analyzer
try
{
analyzer.MakeRoi();
}
catch (const mitk::Exception& e)
{
QMessageBox msgBox;
msgBox.setText(QString::fromStdString(e.what()));
msgBox.exec();
}
// Obtain tbss roi image from analyzer
mitk::TbssRoiImage::Pointer tbssRoi = analyzer.GetRoiImage();
tbssRoi->SetStructure(m_Controls->m_Structure->text().toStdString());
// get path description and set to interface
std::string pathDescription = analyzer.GetPathDescription();
m_Controls->m_PathTextEdit->setPlainText(QString(pathDescription.c_str()));
// Add roi image to datastorage
AddTbssToDataStorage(tbssRoi, m_Controls->m_RoiName->text().toStdString());
}
void QmitkTractbasedSpatialStatisticsView::PlotFiber4D(mitk::TbssImage* image,
- mitk::FiberBundleX* fib,
+ mitk::FiberBundle* fib,
mitk::PlanarFigure* startRoi,
mitk::PlanarFigure* endRoi)
{
if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
{
m_CurrentGeometry = image->GetGeometry();
m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
m_Controls->m_RoiPlotWidget->PlotFiber4D(image, fib, startRoi, endRoi, m_Controls->m_Segments->value());
}
}
-void QmitkTractbasedSpatialStatisticsView:: PlotFiberBundle(mitk::FiberBundleX *fib, mitk::Image* img,
+void QmitkTractbasedSpatialStatisticsView:: PlotFiberBundle(mitk::FiberBundle *fib, mitk::Image* img,
mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi)
{
bool avg = m_Controls->m_Average->isChecked();
int segments = m_Controls->m_Segments->value();
m_Controls->m_RoiPlotWidget->PlotFiberBetweenRois(fib, img, startRoi ,endRoi, avg, segments);
m_Controls->m_RoiPlotWidget->SetPlottingFiber(true);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkTractbasedSpatialStatisticsView::Plot(mitk::TbssImage* image, mitk::TbssRoiImage* roiImage)
{
if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
{
std::vector< itk::Index<3> > roi = roiImage->GetRoi();
m_Roi = roi;
m_CurrentGeometry = image->GetGeometry();
std::string structure = roiImage->GetStructure();
m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
m_Controls->m_RoiPlotWidget->SetRoi(roi);
m_Controls->m_RoiPlotWidget->SetStructure(structure);
m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
m_Controls->m_RoiPlotWidget->DrawProfiles();
}
m_Controls->m_RoiPlotWidget->SetPlottingFiber(false);
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
index ff17a225a3..bd78730a44 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
@@ -1,177 +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 QmitkTractbasedSpatialStatisticsView_h
#define QmitkTractbasedSpatialStatisticsView_h
#include <QmitkFunctionality.h>
#include "ui_QmitkTractbasedSpatialStatisticsViewControls.h"
#include <QListWidgetItem>
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
#include <itkDiffusionTensor3D.h>
#include <mitkTbssImage.h>
#include <mitkTbssRoiImage.h>
#include "QmitkTbssTableModel.h"
#include "QmitkTbssMetaTableModel.h"
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
// Image types
typedef short DiffusionPixelType;
typedef itk::Image<char, 3> CharImageType;
typedef itk::Image<unsigned char, 3> UCharImageType;
typedef itk::Image<float, 4> Float4DImageType;
typedef itk::Image<float, 3> FloatImageType;
typedef itk::VectorImage<float, 3> VectorImageType;
// Readers/Writers
typedef itk::ImageFileReader< CharImageType > CharReaderType;
typedef itk::ImageFileReader< UCharImageType > UCharReaderType;
typedef itk::ImageFileWriter< CharImageType > CharWriterType;
typedef itk::ImageFileReader< FloatImageType > FloatReaderType;
typedef itk::ImageFileWriter< FloatImageType > FloatWriterType;
typedef itk::ImageFileReader< Float4DImageType > Float4DReaderType;
typedef itk::ImageFileWriter< Float4DImageType > Float4DWriterType;
/*!
* \brief This plugin provides an extension for Tract-based spatial statistics (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024)
* TBSS enables analyzing the brain by a pipeline of registration, skeletonization, and projection that results in a white matter skeleton
* for all subjects that are analyzed statistically in a whole-brain manner.
* This plugin provides functionality to select single tracts and analyze them separately.
*
* Prerequisites: the mean_FA_skeleton and all_FA_skeletonised datasets produced by the FSL TBSS pipeline: http://fsl.fmrib.ox.ac.uk/fsl/fsl4.0/tbss/index
*/
class QmitkTractbasedSpatialStatisticsView : public QmitkFunctionality
{
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkTractbasedSpatialStatisticsView();
virtual ~QmitkTractbasedSpatialStatisticsView();
virtual void CreateQtPartControl(QWidget *parent);
/// \brief Creation of the connections of main and control widget
virtual void CreateConnections();
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
virtual void StdMultiWidgetNotAvailable();
/// \brief Called when the functionality is activated
virtual void Activated();
virtual void Deactivated();
protected slots:
// Creates Roi
void CreateRoi();
void Clicked(const QPointF& pos);
// Import of FSL TBSS data
void TbssImport();
// Add a group as metadata. This metadata is required by the plotting functionality
void AddGroup();
// Remove a group
void RemoveGroup();
// Copies the values displayed in the plot widget to clipboard, i.e. exports the data
void CopyToClipboard();
// Method to cut away parts of fiber bundles that should not be plotted.
void Cut();
// Adjust plot widget
void PerformChange();
protected:
/// \brief called by QmitkFunctionality when DataManager's selection has changed
virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
// Creates a plot using a 4D image containing the projections of all subjects and a region of interest
void Plot(mitk::TbssImage*, mitk::TbssRoiImage*);
- void PlotFiberBundle(mitk::FiberBundleX* fib, mitk::Image* img, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
+ void PlotFiberBundle(mitk::FiberBundle* fib, mitk::Image* img, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
- void PlotFiber4D(mitk::TbssImage*, mitk::FiberBundleX* fib, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
+ void PlotFiber4D(mitk::TbssImage*, mitk::FiberBundle* fib, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
// Create a point set. This point set defines the points through which a region of interest should go
void InitPointsets();
// Pointset and DataNode to contain the PointSet used in ROI creation
mitk::PointSet::Pointer m_PointSetNode;
mitk::DataNode::Pointer m_P1;
// GUI widgets
Ui::QmitkTractbasedSpatialStatisticsViewControls* m_Controls;
/* A pointer to the QmitkStdMultiWidget. Used for interaction with the plot widget
(clicking in the plot widget makes the image cross jump to the corresponding location
on the skeleton).*/
QmitkStdMultiWidget* m_MultiWidget;
// Used to save the region of interest in a vector of itk::index.
std::vector< itk::Index<3> > m_Roi;
- mitk::FiberBundleX* m_Fib;
+ mitk::FiberBundle* m_Fib;
mitk::BaseGeometry* m_CurrentGeometry;
// A table model for saving group information in a name,number pair.
QmitkTbssTableModel* m_GroupModel;
// Convenience function for adding a new image to the datastorage and giving it a name.
void AddTbssToDataStorage(mitk::Image* image, std::string name);
mitk::DataNode::Pointer m_CurrentFiberNode; // needed for the index property when interacting with the plot widget
// needed when a plot should only show values between a start end end roi
mitk::DataNode::Pointer m_CurrentStartRoi;
mitk::DataNode::Pointer m_CurrentEndRoi;
};
#endif // _QMITKTRACTBASEDSPATIALSTATISTICSVIEW_H_INCLUDED