diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
index 6150e1beca..e1dd2ebe39 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
@@ -1,689 +1,689 @@
/*===================================================================
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 "mitkConnectomicsNetwork.h"
#include <boost/graph/clustering_coefficient.hpp>
#include <boost/graph/betweenness_centrality.hpp>
/* Constructor and Destructor */
mitk::ConnectomicsNetwork::ConnectomicsNetwork()
: m_IsModified( false )
{
}
mitk::ConnectomicsNetwork::~ConnectomicsNetwork()
{
}
/* Wrapper methods */
bool mitk::ConnectomicsNetwork::EdgeExists(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB ) const
{
return boost::edge(vertexA, vertexB, m_Network ).second;
}
void mitk::ConnectomicsNetwork::IncreaseEdgeWeight(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB )
{
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight++;
SetIsModified( true );
}
void mitk::ConnectomicsNetwork::AddEdge(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
mitk::ConnectomicsNetwork::VertexDescriptorType vertexB
)
{
AddEdge(vertexA, vertexB, m_Network[ vertexA ].id, m_Network[ vertexB ].id );
}
void mitk::ConnectomicsNetwork::AddEdge(
mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
mitk::ConnectomicsNetwork::VertexDescriptorType vertexB,
int sourceID, int targetID, int weight )
{
boost::add_edge( vertexA, vertexB, m_Network );
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].sourceId = sourceID;
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].targetId = targetID;
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight = weight;
m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].edge_weight = 1.0;
SetIsModified( true );
}
mitk::ConnectomicsNetwork::VertexDescriptorType mitk::ConnectomicsNetwork::AddVertex( int id )
{
VertexDescriptorType vertex = boost::add_vertex( m_Network );
m_Network[vertex].id = id;
SetIsModified( true );
return vertex;
}
void mitk::ConnectomicsNetwork::SetLabel(
mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::string inLabel )
{
m_Network[vertex].label = inLabel;
SetIsModified( true );
}
void mitk::ConnectomicsNetwork::SetCoordinates(
mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::vector< float > inCoordinates )
{
m_Network[vertex].coordinates = inCoordinates;
SetIsModified( true );
}
void mitk::ConnectomicsNetwork::clear()
{
m_Network.clear();
SetIsModified( true );
}
/* Superclass methods, that need to be implemented */
void mitk::ConnectomicsNetwork::UpdateOutputInformation()
{
}
void mitk::ConnectomicsNetwork::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::ConnectomicsNetwork::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::ConnectomicsNetwork::VerifyRequestedRegion()
{
return true;
}
void mitk::ConnectomicsNetwork::SetRequestedRegion( itk::DataObject *data )
{
}
std::vector< mitk::ConnectomicsNetwork::NetworkNode >
mitk::ConnectomicsNetwork::GetVectorOfAllNodes() const
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::vertices( m_Network );
std::vector< NetworkNode > vectorOfNodes;
for ( ; iterator != end; ++iterator)
{
NetworkNode tempNode;
// the value of an iterator is a descriptor
tempNode = m_Network[ *iterator ];
vectorOfNodes.push_back( tempNode );
}
return vectorOfNodes;
}
std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
mitk::ConnectomicsNetwork::GetVectorOfAllVertexDescriptors() const
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::vertices( m_Network );
std::vector< VertexDescriptorType > vectorOfDescriptors;
for ( ; iterator != end; ++iterator)
{
vectorOfDescriptors.push_back( *iterator );
}
return vectorOfDescriptors;
}
std::vector< std::pair<
std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >
, mitk::ConnectomicsNetwork::NetworkEdge > >
mitk::ConnectomicsNetwork::GetVectorOfAllEdges() const
{
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::edges( m_Network );
std::vector<
std::pair<
std::pair< NetworkNode, NetworkNode >
, NetworkEdge
>
> vectorOfEdges;
for ( ; iterator != end; ++iterator)
{
NetworkNode sourceNode, targetNode;
NetworkEdge tempEdge;
// the value of an iterator is a descriptor
tempEdge = m_Network[ *iterator ];
sourceNode = m_Network[ boost::source( *iterator, m_Network ) ];
targetNode = m_Network[ boost::target( *iterator, m_Network ) ];
std::pair< NetworkNode, NetworkNode > nodePair( sourceNode, targetNode );
std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > edgePair( nodePair, tempEdge);
vectorOfEdges.push_back( edgePair );
}
return vectorOfEdges;
}
int mitk::ConnectomicsNetwork::GetNumberOfVertices() const
{
return boost::num_vertices( m_Network );
}
int mitk::ConnectomicsNetwork::GetNumberOfEdges() const
{
return boost::num_edges( m_Network );
}
int mitk::ConnectomicsNetwork::GetMaximumWeight() const
{
int maxWeight( 0 );
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::edges( m_Network );
for ( ; iterator != end; ++iterator)
{
int tempWeight;
// the value of an iterator is a descriptor
tempWeight = m_Network[ *iterator ].weight;
if( tempWeight > maxWeight )
{
maxWeight = tempWeight;
}
}
return maxWeight;
}
int mitk::ConnectomicsNetwork::GetNumberOfSelfLoops()
{
int noOfSelfLoops( 0 );
std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > >
edgeVector = GetVectorOfAllEdges();
for( int index = 0; index < edgeVector.size() ; index++ )
{
double sourceX, sourceY, sourceZ, targetX, targetY, targetZ;
sourceX = edgeVector[ index ].first.first.coordinates[0] ;
sourceY = edgeVector[ index ].first.first.coordinates[1] ;
sourceZ = edgeVector[ index ].first.first.coordinates[2] ;
targetX = edgeVector[ index ].first.second.coordinates[0] ;
targetY = edgeVector[ index ].first.second.coordinates[1] ;
targetZ = edgeVector[ index ].first.second.coordinates[2] ;
// if the coordinates are the same
if(
sourceX > ( targetX - 0.01 ) &&
sourceX < ( targetX + 0.01 ) &&
sourceY > ( targetY - 0.01 ) &&
sourceY < ( targetY + 0.01 ) &&
sourceZ > ( targetZ - 0.01 ) &&
sourceZ < ( targetZ + 0.01 )
)
{
noOfSelfLoops++;
}
}
return noOfSelfLoops;
}
double mitk::ConnectomicsNetwork::GetAverageDegree()
{
double vertices = (double) GetNumberOfVertices();
double edges = (double) GetNumberOfEdges();
return ( ( edges * 2.0 ) / vertices );
}
double mitk::ConnectomicsNetwork::GetConnectionDensity()
{
double vertices = (double) GetNumberOfVertices();
double edges = (double) GetNumberOfEdges();
double numberOfPossibleEdges = vertices * ( vertices - 1 ) / 2 ;
return ( edges / numberOfPossibleEdges );
}
std::vector< int > mitk::ConnectomicsNetwork::GetDegreeOfNodes( ) const
{
std::vector< int > vectorOfDegree;
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// sets iterator to start end end to end
boost::tie( iterator, end ) = boost::vertices( m_Network );
vectorOfDegree.resize( this->GetNumberOfVertices() );
for ( ; iterator != end; ++iterator)
{
// the value of an iterator is a descriptor
vectorOfDegree[ m_Network[ *iterator ].id ] = GetVectorOfAdjacentNodes( *iterator ).size();
}
return vectorOfDegree;
}
std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
mitk::ConnectomicsNetwork::GetVectorOfAdjacentNodes( mitk::ConnectomicsNetwork::VertexDescriptorType vertex ) const
{
std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > vectorOfAdjacentNodes;
boost::graph_traits<NetworkType>::adjacency_iterator adjIter, adjEnd;
boost::tie( adjIter, adjEnd ) = boost::adjacent_vertices( vertex, m_Network);
for ( ; adjIter != adjEnd; ++adjIter)
{
vectorOfAdjacentNodes.push_back( *adjIter );
}
return vectorOfAdjacentNodes;
}
int mitk::ConnectomicsNetwork::GetMaximumDegree() const
{
int maximumDegree( 0 );
std::vector< int > vectorOfDegree = GetDegreeOfNodes();
for( int index( 0 ); index < vectorOfDegree.size(); ++index )
{
if( maximumDegree < vectorOfDegree[ index ] )
{
maximumDegree = vectorOfDegree[ index ];
}
}
return maximumDegree;
}
std::vector< double > mitk::ConnectomicsNetwork::GetLocalClusteringCoefficients( ) const
{
std::vector< double > vectorOfClusteringCoefficients;
typedef boost::graph_traits<NetworkType>::vertex_iterator vertexIter;
vectorOfClusteringCoefficients.resize( this->GetNumberOfVertices() );
std::pair<vertexIter, vertexIter> vertexPair;
//for every vertex calculate the clustering coefficient
for (vertexPair = vertices(m_Network); vertexPair.first != vertexPair.second; ++vertexPair.first)
{
vectorOfClusteringCoefficients[ m_Network[ *vertexPair.first ].id ] =
boost::clustering_coefficient(m_Network,*vertexPair.first) ;
}
return vectorOfClusteringCoefficients;
}
std::vector< double > mitk::ConnectomicsNetwork::GetClusteringCoefficientsByDegree( )
{
std::vector< double > vectorOfClusteringCoefficients = GetLocalClusteringCoefficients();
std::vector< int > vectorOfDegree = GetDegreeOfNodes();
std::vector< double > vectorOfClusteringCoefficientsByDegree;
vectorOfClusteringCoefficientsByDegree.resize( GetMaximumDegree() + 1, 0 );
// c_{mean}(k) = frac{1}_{N_{k}} sum_{i in Y(k)} c_{i}
// where N_{k} is the number of vertices of degree k
// Y(k) is the set of vertices of degree k
// c_{i} is the local clustering coefficient of vertex i
for( int degree( 0 ); degree < vectorOfClusteringCoefficientsByDegree.size(); ++degree )
{
vectorOfClusteringCoefficientsByDegree[ degree ] = 0;
int n_k( 0 );
for( int index( 0 ); index < vectorOfDegree.size(); ++index )
{
if( degree == vectorOfDegree[ index ] )
{// if in Y( degree )
vectorOfClusteringCoefficientsByDegree[ degree ] += vectorOfClusteringCoefficients[ index ];
n_k++;
}
}
if( n_k != 0 )
{
vectorOfClusteringCoefficientsByDegree[ degree ] =
vectorOfClusteringCoefficientsByDegree[ degree ] / n_k;
}
}
return vectorOfClusteringCoefficientsByDegree;
}
double mitk::ConnectomicsNetwork::GetGlobalClusteringCoefficient( )
{
double globalClusteringCoefficient( 0.0 );
std::vector< double > vectorOfClusteringCoefficientsByDegree = GetClusteringCoefficientsByDegree();
std::vector< int > vectorOfDegree = GetDegreeOfNodes();
std::vector< int > degreeDistribution;
degreeDistribution.resize( vectorOfClusteringCoefficientsByDegree.size(), 0 );
int normalizationParameter( 0 );
for( int index( 0 ); index < vectorOfDegree.size(); ++index )
{
degreeDistribution[ vectorOfDegree[ index ] ]++;
normalizationParameter++;
}
// c_{mean} = sum_{k} P_{k} c_{mean}(k)
// where P_{k} is the degree distribution
// k is the degree
for( int degree( 0 ); degree < degreeDistribution.size(); ++degree )
{
globalClusteringCoefficient +=
degreeDistribution[ degree ] / ( (double) normalizationParameter)
* vectorOfClusteringCoefficientsByDegree[ degree ];
}
return globalClusteringCoefficient;
}
mitk::ConnectomicsNetwork::NetworkType* mitk::ConnectomicsNetwork::GetBoostGraph()
{
return &m_Network;
}
bool mitk::ConnectomicsNetwork::GetIsModified() const
{
return m_IsModified;
}
void mitk::ConnectomicsNetwork::SetIsModified( bool value)
{
m_IsModified = value;
}
mitk::ConnectomicsNetwork::NetworkNode mitk::ConnectomicsNetwork::GetNode( VertexDescriptorType vertex ) const
{
return m_Network[ vertex ];
}
mitk::ConnectomicsNetwork::NetworkEdge mitk::ConnectomicsNetwork::GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const
{
return m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ];
}
void mitk::ConnectomicsNetwork::UpdateBounds( )
{
float min = itk::NumericTraits<float>::min();
float max = itk::NumericTraits<float>::max();
float bounds[] = {max, min, max, min, max, min};
std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = this->GetVectorOfAllNodes();
if( nodeVector.size() == 0 )
{
bounds[0] = 0;
bounds[1] = 1;
bounds[2] = 0;
bounds[3] = 1;
bounds[4] = 0;
bounds[5] = 1;
}
// for each direction, make certain the point is in between
for( int index(0), end(nodeVector.size()) ; index < end; index++ )
{
for( int direction(0); direction < nodeVector.at( index ).coordinates.size(); direction++ )
{
if( nodeVector.at( index ).coordinates.at(direction) < bounds[ 2 * direction ] )
{
bounds[ 2 * direction ] = nodeVector.at( index ).coordinates.at(direction);
}
if( nodeVector.at( index ).coordinates.at(direction) > bounds[ 2 * direction + 1] )
{
bounds[ 2 * direction + 1] = nodeVector.at( index ).coordinates.at(direction);
}
}
}
// provide some border margin
for(int i=0; i<=4; i+=2)
{
bounds[i] -=10;
}
for(int i=1; i<=5; i+=2)
{
bounds[i] +=10;
}
this->GetGeometry()->SetFloatBounds(bounds);
- this->GetTimeSlicedGeometry()->UpdateInformation();
+ this->GetTimeGeometry()->Update();
}
void mitk::ConnectomicsNetwork::PruneUnconnectedSingleNodes()
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
// set to true if iterators are invalidated by deleting a vertex
bool vertexHasBeenRemoved( true );
// if no vertex has been removed in the last loop, we are done
while( vertexHasBeenRemoved )
{
vertexHasBeenRemoved = false;
// sets iterator to start and end to end
boost::tie(iterator, end) = boost::vertices( m_Network );
for ( ; iterator != end && !vertexHasBeenRemoved; ++iterator)
{
// If the node has no adjacent vertices it should be deleted
if( GetVectorOfAdjacentNodes( *iterator ).size() == 0 )
{
vertexHasBeenRemoved = true;
// this invalidates all iterators
boost::remove_vertex( *iterator, m_Network );
}
}
}
UpdateIDs();
}
void mitk::ConnectomicsNetwork::UpdateIDs()
{
boost::graph_traits<NetworkType>::vertex_iterator v_i, v_end;
boost::graph_traits<NetworkType>::edge_iterator e_i, e_end;
// update node ids
boost::tie( v_i, v_end ) = boost::vertices( m_Network );
for ( ; v_i != v_end; ++v_i)
{
m_Network[*v_i].id = *v_i;
}
// update edge information
boost::tie(e_i, e_end) = boost::edges( m_Network );
for ( ; e_i != e_end; ++e_i)
{
m_Network[ *e_i ].sourceId = m_Network[ boost::source( *e_i, m_Network ) ].id;
m_Network[ *e_i ].targetId = m_Network[ boost::target( *e_i, m_Network ) ].id;
}
this->SetIsModified( true );
}
void mitk::ConnectomicsNetwork::PruneEdgesBelowWeight( int targetWeight )
{
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// set to true if iterators are invalidated by deleting a vertex
bool edgeHasBeenRemoved( true );
// if no vertex has been removed in the last loop, we are done
while( edgeHasBeenRemoved )
{
edgeHasBeenRemoved = false;
// sets iterator to start and end to end
boost::tie(iterator, end) = boost::edges( m_Network );
for ( ; iterator != end && !edgeHasBeenRemoved; ++iterator)
{
// If the node has no adjacent edges it should be deleted
if( m_Network[ *iterator ].weight < targetWeight )
{
edgeHasBeenRemoved = true;
// this invalidates all iterators
boost::remove_edge( *iterator, m_Network );
}
}
}
// this will remove any nodes which, after deleting edges are now
// unconnected, also this calls UpdateIDs()
PruneUnconnectedSingleNodes();
}
std::vector< double > mitk::ConnectomicsNetwork::GetNodeBetweennessVector() const
{
std::vector< double > betweennessVector;
betweennessVector.clear();
betweennessVector.resize( this->GetNumberOfVertices() );
boost::brandes_betweenness_centrality(
m_Network,
boost::centrality_map(
boost::make_iterator_property_map( betweennessVector.begin(), boost::get( &NetworkNode::id, m_Network ), double() )
).vertex_index_map( boost::get( &NetworkNode::id, m_Network ) )
);
return betweennessVector;
}
std::vector< double > mitk::ConnectomicsNetwork::GetEdgeBetweennessVector() const
{
// std::map used for convenient initialization
typedef std::map<EdgeDescriptorType, int> EdgeIndexStdMap;
EdgeIndexStdMap stdEdgeIndex;
// associative property map needed for iterator property map-wrapper
typedef boost::associative_property_map< EdgeIndexStdMap > EdgeIndexMap;
EdgeIndexMap edgeIndex(stdEdgeIndex);
boost::graph_traits<NetworkType>::edge_iterator iterator, end;
// sets iterator to start end end to end
boost::tie(iterator, end) = boost::edges( m_Network );
int i(0);
for ( ; iterator != end; ++iterator, ++i)
{
stdEdgeIndex.insert(std::pair< EdgeDescriptorType, int >( *iterator, i));
}
// Define EdgeCentralityMap
std::vector< double > edgeBetweennessVector(boost::num_edges( m_Network ), 0.0);
// Create the external property map
boost::iterator_property_map< std::vector< double >::iterator, EdgeIndexMap >
e_centrality_map(edgeBetweennessVector.begin(), edgeIndex);
// Define VertexCentralityMap
typedef boost::property_map< NetworkType, boost::vertex_index_t>::type VertexIndexMap;
VertexIndexMap vertexIndex = get(boost::vertex_index, m_Network );
std::vector< double > betweennessVector(boost::num_vertices( m_Network ), 0.0);
// Create the external property map
boost::iterator_property_map< std::vector< double >::iterator, VertexIndexMap >
v_centrality_map(betweennessVector.begin(), vertexIndex);
boost::brandes_betweenness_centrality( m_Network, v_centrality_map, e_centrality_map );
return edgeBetweennessVector;
}
std::vector< double > mitk::ConnectomicsNetwork::GetShortestDistanceVectorFromLabel( std::string targetLabel ) const
{
std::vector< VertexDescriptorType > predecessorMap( boost::num_vertices( m_Network ) );
int numberOfNodes( boost::num_vertices( m_Network ) );
std::vector< double > distanceMatrix;
distanceMatrix.resize( numberOfNodes );
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
boost::tie(iterator, end) = boost::vertices( m_Network );
while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
{
++iterator;
}
if( iterator == end )
{
MITK_WARN << "Label not found";
return distanceMatrix;
}
boost::dijkstra_shortest_paths(m_Network, *iterator, boost::predecessor_map(&predecessorMap[ 0 ]).distance_map(&distanceMatrix[ 0 ]).weight_map( boost::get( &NetworkEdge::edge_weight ,m_Network ) ) ) ;
return distanceMatrix;
}
bool mitk::ConnectomicsNetwork::CheckForLabel( std::string targetLabel ) const
{
boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
boost::tie(iterator, end) = boost::vertices( m_Network );
while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
{
++iterator;
}
if( iterator == end )
{
return false;
}
return true;
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
index 444ca013a9..3a0f33f4d5 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
@@ -1,884 +1,885 @@
/*===================================================================
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 __mitkOdfVtkMapper2D_txx__
#define __mitkOdfVtkMapper2D_txx__
#include "mitkOdfVtkMapper2D.h"
#include "mitkDataNode.h"
#include "mitkBaseRenderer.h"
#include "mitkMatrixConvert.h"
#include "mitkGeometry3D.h"
+#include "mitkTimeGeometry.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkProperties.h"
#include "mitkTensorImage.h"
#include "vtkSphereSource.h"
#include "vtkPropCollection.h"
#include "vtkMaskedGlyph3D.h"
#include "vtkGlyph2D.h"
#include "vtkGlyph3D.h"
#include "vtkMaskedProgrammableGlyphFilter.h"
#include "vtkImageData.h"
#include "vtkLinearTransform.h"
#include "vtkCamera.h"
#include "vtkPointData.h"
#include "vtkTransformPolyDataFilter.h"
#include "vtkTransform.h"
#include "vtkOdfSource.h"
#include "vtkDoubleArray.h"
#include "vtkLookupTable.h"
#include "vtkProperty.h"
#include "vtkPolyDataNormals.h"
#include "vtkLight.h"
#include "vtkLightCollection.h"
#include "vtkMath.h"
#include "vtkFloatArray.h"
#include "vtkDelaunay2D.h"
#include "vtkMapper.h"
#include "vtkRenderer.h"
#include "itkOrientationDistributionFunction.h"
#include "itkFixedArray.h"
#include <mitkGL.h>
#include "vtkOpenGLRenderer.h"
#define _USE_MATH_DEFINES
#include <math.h>
template<class T, int N>
vtkSmartPointer<vtkTransform> mitk::OdfVtkMapper2D<T,N>::m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
template<class T, int N>
vtkSmartPointer<vtkOdfSource> mitk::OdfVtkMapper2D<T,N>::m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
template<class T, int N>
float mitk::OdfVtkMapper2D<T,N>::m_Scaling;
template<class T, int N>
int mitk::OdfVtkMapper2D<T,N>::m_Normalization;
template<class T, int N>
int mitk::OdfVtkMapper2D<T,N>::m_ScaleBy;
template<class T, int N>
float mitk::OdfVtkMapper2D<T,N>::m_IndexParam1;
template<class T, int N>
float mitk::OdfVtkMapper2D<T,N>::m_IndexParam2;
#define ODF_MAPPER_PI M_PI
template<class T, int N>
mitk::OdfVtkMapper2D<T,N>::LocalStorage::LocalStorage()
{
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes[0]->AddInput(vtkPolyData::New());
m_OdfsPlanes[1]->AddInput(vtkPolyData::New());
m_OdfsPlanes[2]->AddInput(vtkPolyData::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud();
m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud();
m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud();
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
vtkLookupTable *lut = vtkLookupTable::New();
m_OdfsMappers[0]->SetLookupTable(lut);
m_OdfsMappers[1]->SetLookupTable(lut);
m_OdfsMappers[2]->SetLookupTable(lut);
m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]);
m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]);
m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]);
}
template<class T, int N>
mitk::OdfVtkMapper2D<T,N>
::OdfVtkMapper2D()
{
m_Planes.push_back(vtkPlane::New());
m_Planes.push_back(vtkPlane::New());
m_Planes.push_back(vtkPlane::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters[0]->SetCutFunction( m_Planes[0] );
m_Cutters[0]->GenerateValues( 1, 0, 1 );
m_Cutters[1]->SetCutFunction( m_Planes[1] );
m_Cutters[1]->GenerateValues( 1, 0, 1 );
m_Cutters[2]->SetCutFunction( m_Planes[2] );
m_Cutters[2]->GenerateValues( 1, 0, 1 );
// Windowing the cutted planes in direction 1
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] );
m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] );
m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] );
// Windowing the cutted planes in direction 2
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] );
m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] );
m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] );
m_ShowMaxNumber = 500;
}
template<class T, int N>
mitk::OdfVtkMapper2D<T,N>
::~OdfVtkMapper2D()
{
}
template<class T, int N>
mitk::Image* mitk::OdfVtkMapper2D<T,N>
::GetInput()
{
return static_cast<mitk::Image * > ( m_DataNode->GetData() );
}
template<class T, int N>
vtkProp* mitk::OdfVtkMapper2D<T,N>
::GetVtkProp(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
return localStorage->m_PropAssemblies[GetIndex(renderer)];
}
template<class T, int N>
int mitk::OdfVtkMapper2D<T,N>
::GetIndex(mitk::BaseRenderer* renderer)
{
if(!strcmp(renderer->GetName(),"stdmulti.widget1"))
return 0;
if(!strcmp(renderer->GetName(),"stdmulti.widget2"))
return 1;
if(!strcmp(renderer->GetName(),"stdmulti.widget3"))
return 2;
return 0;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::GlyphMethod(void *arg)
{
vtkMaskedProgrammableGlyphFilter* pfilter=(vtkMaskedProgrammableGlyphFilter*)arg;
double point[3];
double debugpoint[3];
pfilter->GetPoint(point);
pfilter->GetPoint(debugpoint);
itk::Point<double,3> p(point);
Vector3D spacing = pfilter->GetGeometry()->GetSpacing();
p[0] /= spacing[0];
p[1] /= spacing[1];
p[2] /= spacing[2];
mitk::Point3D p2;
pfilter->GetGeometry()->IndexToWorld( p, p2 );
point[0] = p2[0];
point[1] = p2[1];
point[2] = p2[2];
vtkPointData* data = pfilter->GetPointData();
vtkDataArray* odfvals = data->GetArray("vector");
vtkIdType id = pfilter->GetPointId();
m_OdfTransform->Identity();
m_OdfTransform->Translate(point[0],point[1],point[2]);
typedef itk::OrientationDistributionFunction<float,N> OdfType;
OdfType odf;
if(odfvals->GetNumberOfComponents()==6)
{
float tensorelems[6] = {
(float)odfvals->GetComponent(id,0),
(float)odfvals->GetComponent(id,1),
(float)odfvals->GetComponent(id,2),
(float)odfvals->GetComponent(id,3),
(float)odfvals->GetComponent(id,4),
(float)odfvals->GetComponent(id,5),
};
itk::DiffusionTensor3D<float> tensor(tensorelems);
odf.InitFromTensor(tensor);
}
else
{
for(int i=0; i<N; i++)
odf[i] = (double)odfvals->GetComponent(id,i);
}
switch(m_ScaleBy)
{
case ODFSB_NONE:
m_OdfSource->SetScale(m_Scaling);
break;
case ODFSB_GFA:
m_OdfSource->SetScale(m_Scaling*odf.GetGeneralizedGFA(m_IndexParam1, m_IndexParam2));
break;
case ODFSB_PC:
m_OdfSource->SetScale(m_Scaling*odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0));
break;
}
m_OdfSource->SetNormalization(m_Normalization);
m_OdfSource->SetOdf(odf);
m_OdfSource->Modified();
}
template<class T, int N>
typename mitk::OdfVtkMapper2D<T,N>::OdfDisplayGeometry mitk::OdfVtkMapper2D<T,N>
::MeasureDisplayedGeometry(mitk::BaseRenderer* renderer)
{
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
// set up the cutter orientation according to the current geometry of
// the renderers plane
vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];
Point3D point = worldPlaneGeometry->GetOrigin();
Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
vnl2vtk( point.Get_vnl_vector(), vp );
vnl2vtk( normal.Get_vnl_vector(), vnormal );
mitk::DisplayGeometry::Pointer dispGeometry = renderer->GetDisplayGeometry();
mitk::Vector2D size = dispGeometry->GetSizeInMM();
mitk::Vector2D origin = dispGeometry->GetOriginInMM();
//
// |------O------|
// | d2 |
// L d1 M |
// | |
// |-------------|
//
mitk::Vector2D M;
mitk::Vector2D L;
mitk::Vector2D O;
M[0] = origin[0] + size[0]/2;
M[1] = origin[1] + size[1]/2;
L[0] = origin[0];
L[1] = origin[1] + size[1]/2;
O[0] = origin[0] + size[0]/2;
O[1] = origin[1] + size[1];
mitk::Point2D point1;
point1[0] = M[0]; point1[1] = M[1];
mitk::Point3D M3D;
dispGeometry->Map(point1, M3D);
point1[0] = L[0]; point1[1] = L[1];
mitk::Point3D L3D;
dispGeometry->Map(point1, L3D);
point1[0] = O[0]; point1[1] = O[1];
mitk::Point3D O3D;
dispGeometry->Map(point1, O3D);
double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0])
+ (M3D[1]-L3D[1])*(M3D[1]-L3D[1])
+ (M3D[2]-L3D[2])*(M3D[2]-L3D[2]));
double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0])
+ (M3D[1]-O3D[1])*(M3D[1]-O3D[1])
+ (M3D[2]-O3D[2])*(M3D[2]-O3D[2]));
double d = d1>d2 ? d1 : d2;
d = d2;
OdfDisplayGeometry retval;
retval.vp[0] = vp[0];
retval.vp[1] = vp[1];
retval.vp[2] = vp[2];
retval.vnormal[0] = vnormal[0];
retval.vnormal[1] = vnormal[1];
retval.vnormal[2] = vnormal[2];
retval.normal[0] = normal[0];
retval.normal[1] = normal[1];
retval.normal[2] = normal[2];
retval.d = d;
retval.d1 = d1;
retval.d2 = d2;
retval.M3D[0] = M3D[0];
retval.M3D[1] = M3D[1];
retval.M3D[2] = M3D[2];
retval.L3D[0] = L3D[0];
retval.L3D[1] = L3D[1];
retval.L3D[2] = L3D[2];
retval.O3D[0] = O3D[0];
retval.O3D[1] = O3D[1];
retval.O3D[2] = O3D[2];
retval.vp_original[0] = vp[0];
retval.vp_original[1] = vp[1];
retval.vp_original[2] = vp[2];
retval.vnormal_original[0] = vnormal[0];
retval.vnormal_original[1] = vnormal[1];
retval.vnormal_original[2] = vnormal[2];
retval.size[0] = size[0];
retval.size[1] = size[1];
retval.origin[0] = origin[0];
retval.origin[1] = origin[1];
return retval;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry dispGeo)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
vtkLinearTransform * vtktransform =
this->GetDataNode()->GetVtkTransform(this->GetTimestep());
int index = GetIndex(renderer);
vtkSmartPointer<vtkTransform> inversetransform = vtkSmartPointer<vtkTransform>::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double myscale[3];
((vtkTransform*)vtktransform)->GetScale(myscale);
inversetransform->PostMultiply();
inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
// vtk works in axis align coords
// thus the normal also must be axis align, since
// we do not allow arbitrary cutting through volume
//
// vnormal should already be axis align, but in order
// to get rid of precision effects, we set the two smaller
// components to zero here
int dims[3];
m_VtkImage->GetDimensions(dims);
double spac[3];
m_VtkImage->GetSpacing(spac);
if(fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[1])
&& fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[2]) )
{
if(fabs(dispGeo.vp[0]/spac[0]) < 0.4)
dispGeo.vp[0] = 0.4*spac[0];
if(fabs(dispGeo.vp[0]/spac[0]) > (dims[0]-1)-0.4)
dispGeo.vp[0] = ((dims[0]-1)-0.4)*spac[0];
dispGeo.vnormal[1] = 0;
dispGeo.vnormal[2] = 0;
}
if(fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[0]) && fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[2]) )
{
if(fabs(dispGeo.vp[1]/spac[1]) < 0.4)
dispGeo.vp[1] = 0.4*spac[1];
if(fabs(dispGeo.vp[1]/spac[1]) > (dims[1]-1)-0.4)
dispGeo.vp[1] = ((dims[1]-1)-0.4)*spac[1];
dispGeo.vnormal[0] = 0;
dispGeo.vnormal[2] = 0;
}
if(fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[1]) && fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[0]) )
{
if(fabs(dispGeo.vp[2]/spac[2]) < 0.4)
dispGeo.vp[2] = 0.4*spac[2];
if(fabs(dispGeo.vp[2]/spac[2]) > (dims[2]-1)-0.4)
dispGeo.vp[2] = ((dims[2]-1)-0.4)*spac[2];
dispGeo.vnormal[0] = 0;
dispGeo.vnormal[1] = 0;
}
m_Planes[index]->SetTransform( (vtkAbstractTransform*)NULL );
m_Planes[index]->SetOrigin( dispGeo.vp );
m_Planes[index]->SetNormal( dispGeo.vnormal );
vtkSmartPointer<vtkPoints> points;
vtkSmartPointer<vtkPoints> tmppoints;
vtkSmartPointer<vtkPolyData> polydata;
vtkSmartPointer<vtkFloatArray> pointdata;
vtkSmartPointer<vtkDelaunay2D> delaunay;
vtkSmartPointer<vtkPolyData> cuttedPlane;
// the cutter only works if we do not have a 2D-image
// or if we have a 2D-image and want to see the whole image.
//
// for side views of 2D-images, we need some special treatment
if(!( (dims[0] == 1 && dispGeo.vnormal[0] != 0) ||
(dims[1] == 1 && dispGeo.vnormal[1] != 0) ||
(dims[2] == 1 && dispGeo.vnormal[2] != 0) ))
{
m_Cutters[index]->SetCutFunction( m_Planes[index] );
m_Cutters[index]->SetInput( m_VtkImage );
m_Cutters[index]->Update();
cuttedPlane = m_Cutters[index]->GetOutput();
}
else
{
// cutting of a 2D-Volume does not work,
// so we have to build up our own polydata object
cuttedPlane = vtkPolyData::New();
points = vtkPoints::New();
points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints());
for(int i=0; i<m_VtkImage->GetNumberOfPoints(); i++)
{
points->SetPoint(i, m_VtkImage->GetPoint(i));
}
cuttedPlane->SetPoints(points);
pointdata = vtkFloatArray::New();
int comps = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfComponents();
pointdata->SetNumberOfComponents(comps);
int tuples = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfTuples();
pointdata->SetNumberOfTuples(tuples);
for(int i=0; i<tuples; i++)
pointdata->SetTuple(i,m_VtkImage->GetPointData()->GetScalars()->GetTuple(i));
pointdata->SetName( "vector" );
cuttedPlane->GetPointData()->AddArray(pointdata);
int nZero1, nZero2;
if(dims[0]==1)
{
nZero1 = 1; nZero2 = 2;
}
else if(dims[1]==1)
{
nZero1 = 0; nZero2 = 2;
}
else
{
nZero1 = 0; nZero2 = 1;
}
tmppoints = vtkPoints::New();
for(int j=0; j<m_VtkImage->GetNumberOfPoints(); j++){
double pt[3];
m_VtkImage->GetPoint(j,pt);
tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0);
}
polydata = vtkPolyData::New();
polydata->SetPoints( tmppoints );
delaunay = vtkDelaunay2D::New();
delaunay->SetInput( polydata );
delaunay->Update();
vtkCellArray* polys = delaunay->GetOutput()->GetPolys();
cuttedPlane->SetPolys(polys);
}
if(cuttedPlane->GetNumberOfPoints())
{
// WINDOWING HERE
inversetransform = vtkTransform::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double myscale[3];
((vtkTransform*)vtktransform)->GetScale(myscale);
inversetransform->PostMultiply();
inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.O3D[0];
dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.O3D[1];
dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.O3D[2];
vtkMath::Normalize(dispGeo.vnormal);
dispGeo.vp[0] = dispGeo.M3D[0];
dispGeo.vp[1] = dispGeo.M3D[1];
dispGeo.vp[2] = dispGeo.M3D[2];
inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
m_ThickPlanes1[index]->count = 0;
m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)NULL );
m_ThickPlanes1[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
m_ThickPlanes1[index]->SetThickness(dispGeo.d2);
m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] );
m_Clippers1[index]->SetInput( cuttedPlane );
m_Clippers1[index]->SetInsideOut(1);
m_Clippers1[index]->Update();
dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.L3D[0];
dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.L3D[1];
dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.L3D[2];
vtkMath::Normalize(dispGeo.vnormal);
dispGeo.vp[0] = dispGeo.M3D[0];
dispGeo.vp[1] = dispGeo.M3D[1];
dispGeo.vp[2] = dispGeo.M3D[2];
inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
m_ThickPlanes2[index]->count = 0;
m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)NULL );
m_ThickPlanes2[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
m_ThickPlanes2[index]->SetThickness(dispGeo.d1);
m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] );
m_Clippers2[index]->SetInput( m_Clippers1[index]->GetOutput() );
m_Clippers2[index]->SetInsideOut(1);
m_Clippers2[index]->Update();
cuttedPlane = m_Clippers2[index]->GetOutput ();
if(cuttedPlane->GetNumberOfPoints())
{
localStorage->m_OdfsPlanes[index]->RemoveAllInputs();
vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New();
normals->SetInputConnection( m_OdfSource->GetOutputPort() );
normals->SplittingOff();
normals->ConsistencyOff();
normals->AutoOrientNormalsOff();
normals->ComputePointNormalsOn();
normals->ComputeCellNormalsOff();
normals->FlipNormalsOff();
normals->NonManifoldTraversalOff();
vtkSmartPointer<vtkTransformPolyDataFilter> trans = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
trans->SetInputConnection( normals->GetOutputPort() );
trans->SetTransform(m_OdfTransform);
vtkSmartPointer<vtkMaskedProgrammableGlyphFilter> glyphGenerator = vtkSmartPointer<vtkMaskedProgrammableGlyphFilter>::New();
glyphGenerator->SetMaximumNumberOfPoints(std::min(m_ShowMaxNumber,(int)cuttedPlane->GetNumberOfPoints()));
glyphGenerator->SetRandomMode(0);
glyphGenerator->SetUseMaskPoints(1);
glyphGenerator->SetSource( trans->GetOutput() );
glyphGenerator->SetInput(cuttedPlane);
glyphGenerator->SetColorModeToColorBySource();
glyphGenerator->SetInputArrayToProcess(0,0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector");
glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry());
glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator);
try
{
glyphGenerator->Update();
}
catch( itk::ExceptionObject& err )
{
std::cout << err << std::endl;
}
localStorage->m_OdfsPlanes[index]->AddInput(glyphGenerator->GetOutput());
localStorage->m_OdfsPlanes[index]->Update();
}
}
localStorage->m_PropAssemblies[index]->VisibilityOn();
if(localStorage->m_PropAssemblies[index]->GetParts()->IsItemPresent(localStorage->m_OdfsActors[index]))
localStorage->m_PropAssemblies[index]->RemovePart(localStorage->m_OdfsActors[index]);
localStorage->m_OdfsMappers[index]->SetInput(localStorage->m_OdfsPlanes[index]->GetOutput());
localStorage->m_PropAssemblies[index]->AddPart(localStorage->m_OdfsActors[index]);
}
template<class T, int N>
bool mitk::OdfVtkMapper2D<T,N>
::IsVisibleOdfs(mitk::BaseRenderer* renderer)
{
mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput());
- const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
- if(inputTimeGeometry==NULL || inputTimeGeometry->GetTimeSteps()==0 || !inputTimeGeometry->IsValidTime(this->GetTimestep()))
+ const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
+ if(inputTimeGeometry==NULL || inputTimeGeometry->GetNumberOfTimeSteps()==0 || !inputTimeGeometry->IsValidTimeStep(this->GetTimestep()))
return false;
if(this->IsPlaneRotated(renderer))
return false;
bool retval = false;
switch(GetIndex(renderer))
{
case 0:
GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_T");
break;
case 1:
GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_S");
break;
case 2:
GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_C");
break;
}
return retval;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::MitkRenderOverlay(mitk::BaseRenderer* renderer)
{
if ( this->IsVisibleOdfs(renderer)==false )
return;
if ( this->GetVtkProp(renderer)->GetVisibility() )
this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer)
{
if ( this->IsVisibleOdfs( renderer )==false )
return;
if ( this->GetVtkProp(renderer)->GetVisibility() )
{
// adapt cam pos
OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer);
this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
}
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer)
{
if ( this->IsVisibleOdfs(renderer)==false )
return;
if ( this->GetVtkProp(renderer)->GetVisibility() )
this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
mitk::Image::Pointer input = const_cast<mitk::Image*>( this->GetInput() );
if ( input.IsNull() ) return ;
std::string classname("TensorImage");
if(classname.compare(input->GetNameOfClass())==0)
m_VtkImage = dynamic_cast<mitk::TensorImage*>( this->GetInput() )->GetNonRgbVtkImageData();
std::string qclassname("QBallImage");
if(qclassname.compare(input->GetNameOfClass())==0)
m_VtkImage = dynamic_cast<mitk::QBallImage*>( this->GetInput() )->GetNonRgbVtkImageData();
if( m_VtkImage )
{
// make sure, that we have point data with more than 1 component (as vectors)
vtkPointData* pointData = m_VtkImage->GetPointData();
if ( pointData == NULL )
{
itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" );
return ;
}
if ( pointData->GetNumberOfArrays() == 0 )
{
itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" );
return ;
}
else if ( pointData->GetArray(0)->GetNumberOfComponents() != N
&& pointData->GetArray(0)->GetNumberOfComponents() != 6 /*for tensor visualization*/)
{
itkWarningMacro( << "number of components != number of directions in ODF!" );
return;
}
else if ( pointData->GetArrayName( 0 ) == NULL )
{
m_VtkImage->GetPointData()->GetArray(0)->SetName("vector");
}
GenerateDataForRenderer(renderer);
}
else
{
itkWarningMacro( << "m_VtkImage is NULL!" );
return ;
}
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer);
if ( (localStorage->m_LastUpdateTime >= m_DataNode->GetMTime()) //was the node modified?
&& (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList()->GetMTime()) //was a property modified?
&& (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList(renderer)->GetMTime())
&& dispGeo.Equals(m_LastDisplayGeometry))
return;
localStorage->m_LastUpdateTime.Modified();
if(!IsVisibleOdfs(renderer))
{
localStorage->m_OdfsActors[0]->VisibilityOff();
localStorage->m_OdfsActors[1]->VisibilityOff();
localStorage->m_OdfsActors[2]->VisibilityOff();
}
else
{
localStorage->m_OdfsActors[0]->VisibilityOn();
localStorage->m_OdfsActors[1]->VisibilityOn();
localStorage->m_OdfsActors[2]->VisibilityOn();
m_OdfSource->SetAdditionalScale(GetMinImageSpacing(GetIndex(renderer)));
ApplyPropertySettings();
Slice(renderer, dispGeo);
m_LastDisplayGeometry = dispGeo;
}
}
template<class T, int N>
double mitk::OdfVtkMapper2D<T,N>::GetMinImageSpacing( int index )
{
// Spacing adapted scaling
double spacing[3];
m_VtkImage->GetSpacing(spacing);
double min;
if(index==0)
{
min = spacing[0];
min = min > spacing[1] ? spacing[1] : min;
}
if(index==1)
{
min = spacing[1];
min = min > spacing[2] ? spacing[2] : min;
}
if(index==2)
{
min = spacing[0];
min = min > spacing[2] ? spacing[2] : min;
}
return min;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::ApplyPropertySettings()
{
this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling );
this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber );
OdfNormalizationMethodProperty* nmp = dynamic_cast<OdfNormalizationMethodProperty*>(this->GetDataNode()->GetProperty( "Normalization" ));
if(nmp)
m_Normalization = nmp->GetNormalization();
OdfScaleByProperty* sbp = dynamic_cast<OdfScaleByProperty*>(this->GetDataNode()->GetProperty( "ScaleBy" ));
if(sbp)
m_ScaleBy = sbp->GetScaleBy();
this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1);
this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2);
}
template <class T, int N>
bool mitk::OdfVtkMapper2D<T,N>
::IsPlaneRotated(mitk::BaseRenderer* renderer)
{
Geometry2D::ConstPointer worldGeometry =
renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry =
dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
vtkFloatingPointType vnormal[ 3 ];
Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
vnl2vtk( normal.Get_vnl_vector(), vnormal );
vtkLinearTransform * vtktransform =
this->GetDataNode()->GetVtkTransform(this->GetTimestep());
vtkSmartPointer<vtkTransform> inversetransform = vtkSmartPointer<vtkTransform>::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double* n = inversetransform->TransformNormal(vnormal);
int nonZeros = 0;
for (int j=0; j<3; j++)
{
if (fabs(n[j])>mitk::eps){
nonZeros++;
}
}
if(nonZeros>1)
return true;
return false;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* /*renderer*/, bool /*overwrite*/)
{
node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 150 ) );
node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
node->SetProperty( "VisibleOdfs_T", mitk::BoolProperty::New( false ) );
node->SetProperty( "VisibleOdfs_C", mitk::BoolProperty::New( false ) );
node->SetProperty( "VisibleOdfs_S", mitk::BoolProperty::New( false ) );
node->SetProperty ("layer", mitk::IntProperty::New(100));
node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
}
#endif // __mitkOdfVtkMapper2D_txx__
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
index 73e833b1b3..f8d775402f 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
@@ -1,363 +1,363 @@
/*===================================================================
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 __mitkNrrdTbssRoiReader_cpp
#define __mitkNrrdTbssRoiReader_cpp
#include "mitkNrrdTbssRoiImageReader.h"
#include "itkImageFileReader.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
#include "itkNiftiImageIO.h"
#include <itkImageFileWriter.h>
#include <iostream>
#include <fstream>
#include "itksys/SystemTools.hxx"
namespace mitk
{
void NrrdTbssRoiImageReader
::GenerateData()
{
try
{
// Change locale if needed
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
// READ IMAGE INFORMATION
const unsigned int MINDIM = 3;
const unsigned int MAXDIM = 4;
MITK_INFO << "loading " << m_FileName << " via mitk::NrrdTbssImageReader... " << std::endl;
// Check to see if we can read the file given the name or prefix
if ( m_FileName == "" )
{
itkWarningMacro( << "Filename is empty!" )
return;
}
itk::NrrdImageIO::Pointer imageIO = itk::NrrdImageIO::New();
imageIO->SetFileName( m_FileName.c_str() );
imageIO->ReadImageInformation();
unsigned int ndim = imageIO->GetNumberOfDimensions();
if ( ndim < MINDIM || ndim > MAXDIM )
{
itkWarningMacro( << "Sorry, only dimensions 3 is supported. The given file has " << ndim << " dimensions!" )
return;
}
itk::ImageIORegion ioRegion( ndim );
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[ MAXDIM ];
dimensions[ 0 ] = 0;
dimensions[ 1 ] = 0;
dimensions[ 2 ] = 0;
dimensions[ 3 ] = 0;
float spacing[ MAXDIM ];
spacing[ 0 ] = 1.0f;
spacing[ 1 ] = 1.0f;
spacing[ 2 ] = 1.0f;
spacing[ 3 ] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for ( i = 0; i < ndim ; ++i )
{
ioStart[ i ] = 0;
ioSize[ i ] = imageIO->GetDimensions( i );
if(i<MAXDIM)
{
dimensions[ i ] = imageIO->GetDimensions( i );
spacing[ i ] = imageIO->GetSpacing( i );
if(spacing[ i ] <= 0)
spacing[ i ] = 1.0f;
}
if(i<3)
{
origin[ i ] = imageIO->GetOrigin( i );
}
}
ioRegion.SetSize( ioSize );
ioRegion.SetIndex( ioStart );
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
imageIO->SetIORegion( ioRegion );
void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
imageIO->Read( buffer );
//mitk::Image::Pointer static_cast<OutputType*>(this->GetOutput())image = mitk::Image::New();
if((ndim==4) && (dimensions[3]<=1))
ndim = 3;
if((ndim==3) && (dimensions[2]<=1))
ndim = 2;
mitk::PixelType pixelType = mitk::PixelType(imageIO->GetComponentTypeInfo(), imageIO->GetPixelType(),
imageIO->GetComponentSize(), imageIO->GetNumberOfComponents(),
imageIO->GetComponentTypeAsString( imageIO->GetComponentType() ).c_str(),
imageIO->GetPixelTypeAsString( imageIO->GetPixelType() ).c_str() );
//pixelType.Initialize( imageIO->GetComponentTypeInfo(), imageIO->GetNumberOfComponents(), imageIO->GetPixelType() );
static_cast<OutputType*>(this->GetOutput(0))->Initialize( pixelType, ndim, dimensions );
static_cast<OutputType*>(this->GetOutput(0))->SetImportChannel( buffer, 0, Image::ManageMemory );
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
for ( i=0; i < itkDimMax3; ++i)
for( j=0; j < itkDimMax3; ++j )
matrix[i][j] = imageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>
(static_cast<OutputType*>
(this->GetOutput(0))->GetSlicedGeometry(0)->GetGeometry2D(0));
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
SlicedGeometry3D* slicedGeometry = static_cast<OutputType*>(this->GetOutput(0))->GetSlicedGeometry(0);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, static_cast<OutputType*>(this->GetOutput(0))->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
// re-initialize TimeSlicedGeometry
- static_cast<OutputType*>(this->GetOutput(0))->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, static_cast<OutputType*>(this->GetOutput(0))->GetDimension(3));
+ dynamic_cast<ProportionalTimeGeometry *>(static_cast<OutputType*>(this->GetOutput(0))->GetTimeGeometry())->Initialize(slicedGeometry, static_cast<OutputType*>(this->GetOutput(0))->GetDimension(3));
buffer = NULL;
MITK_INFO << "number of image components: "<< static_cast<OutputType*>(this->GetOutput(0))->GetPixelType().GetNumberOfComponents() << std::endl;
// READ TBSS HEADER INFORMATION
ImageType::Pointer img;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".roi")
{
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetFileName(this->m_FileName);
reader->SetImageIO(imageIO);
reader->Update();
img = reader->GetOutput();
static_cast<OutputType*>(this->GetOutput(0))->SetImage(img);
itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
ReadRoiInfo(imgMetaDictionary);
}
// RESET LOCALE
try
{
MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
MITK_INFO << "...finished!" << std::endl;
}
catch(std::exception& e)
{
MITK_INFO << "Std::Exception while reading file!!";
MITK_INFO << e.what();
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
MITK_INFO << "Exception while reading file!!";
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
}
}
void NrrdTbssRoiImageReader
::ReadRoiInfo(itk::MetaDataDictionary dict)
{
std::vector<std::string> imgMetaKeys = dict.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString;
std::vector< itk::Index<3> > roi;
for (; itKey != imgMetaKeys.end(); itKey ++)
{
double x,y,z;
itk::Index<3> ix;
itk::ExposeMetaData<std::string> (dict, *itKey, metaString);
if (itKey->find("ROI_index") != std::string::npos)
{
MITK_INFO << *itKey << " ---> " << metaString;
sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
ix[0] = x; ix[1] = y; ix[2] = z;
roi.push_back(ix);
}
else if(itKey->find("preprocessed FA") != std::string::npos)
{
MITK_INFO << *itKey << " ---> " << metaString;
static_cast<OutputType*>(this->GetOutput(0))->SetPreprocessedFA(true);
static_cast<OutputType*>(this->GetOutput(0))->SetPreprocessedFAFile(metaString);
}
// Name of structure
if (itKey->find("structure") != std::string::npos)
{
MITK_INFO << *itKey << " ---> " << metaString;
static_cast<OutputType*>(this->GetOutput(0))->SetStructure(metaString);
}
}
static_cast<OutputType*>(this->GetOutput(0))->SetRoi(roi);
}
const char* NrrdTbssRoiImageReader
::GetFileName() const
{
return m_FileName.c_str();
}
void NrrdTbssRoiImageReader
::SetFileName(const char* aFileName)
{
m_FileName = aFileName;
}
const char* NrrdTbssRoiImageReader
::GetFilePrefix() const
{
return m_FilePrefix.c_str();
}
void NrrdTbssRoiImageReader
::SetFilePrefix(const char* aFilePrefix)
{
m_FilePrefix = aFilePrefix;
}
const char* NrrdTbssRoiImageReader
::GetFilePattern() const
{
return m_FilePattern.c_str();
}
void NrrdTbssRoiImageReader
::SetFilePattern(const char* aFilePattern)
{
m_FilePattern = aFilePattern;
}
bool NrrdTbssRoiImageReader
::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
return false;
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
ext = itksys::SystemTools::LowerCase(ext);
if (ext == ".roi")
{
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(filename);
try
{
reader->Update();
}
catch(itk::ExceptionObject e)
{
MITK_INFO << e.GetDescription();
return false;
}
return true;
}
return false;
}
} //namespace MITK
#endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index f91bcbecf3..82ec15d18a 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1766 +1,1766 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkControlVisualizationPropertiesView.h"
#include "mitkNodePredicateDataType.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkResliceMethodProperty.h"
#include "mitkRenderingManager.h"
#include "mitkTbssImage.h"
#include "mitkPlanarFigure.h"
#include "mitkFiberBundleX.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFiberBundleInteractor.h"
#include "mitkPlanarFigureInteractor.h"
#include <mitkQBallImage.h>
#include <mitkTensorImage.h>
#include <mitkDiffusionImage.h>
#include "mitkGlobalInteraction.h"
#include "mitkGeometry2D.h"
#include "mitkSegTool2D.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"
const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
using namespace berry;
struct CvpSelListener : ISelectionListener
{
berryObjectMacro(CvpSelListener);
CvpSelListener(QmitkControlVisualizationPropertiesView* view)
{
m_View = view;
}
void ApplySettings(mitk::DataNode::Pointer node)
{
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
int val;
node->GetIntProperty("ShowMaxNumber", val);
m_View->m_Controls->m_ShowMaxNumber->setValue(val);
m_View->m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
float fval;
node->GetFloatProperty("Scaling",fval);
m_View->m_Controls->m_ScalingFactor->setValue(fval);
m_View->m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
node->GetFloatProperty("IndexParam1",fval);
m_View->m_Controls->m_IndexParam1->setValue(fval);
node->GetFloatProperty("IndexParam2",fval);
m_View->m_Controls->m_IndexParam2->setValue(fval);
}
void DoSelectionChanged(ISelection::ConstPointer selection)
{
// save current selection in member variable
m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
m_View->m_Controls->m_VisibleOdfsON_T->setVisible(false);
m_View->m_Controls->m_VisibleOdfsON_S->setVisible(false);
m_View->m_Controls->m_VisibleOdfsON_C->setVisible(false);
m_View->m_Controls->m_TextureIntON->setVisible(false);
m_View->m_Controls->m_ImageControlsFrame->setVisible(false);
m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(false);
m_View->m_Controls->m_BundleControlsFrame->setVisible(false);
m_View->m_SelectedNode = 0;
if(m_View->m_CurrentSelection.IsNull())
return;
if(m_View->m_CurrentSelection->Size() == 1)
{
mitk::DataNodeObject::Pointer nodeObj = m_View->m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
if(nodeObj.IsNotNull())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData != NULL )
{
if(dynamic_cast<mitk::PlanarFigure*>(nodeData) != 0)
{
m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(true);
m_View->m_SelectedNode = node;
float val;
node->GetFloatProperty("planarfigure.line.width", val);
m_View->m_Controls->m_PFWidth->setValue((int)(val*10.0));
QString label = "Width %1";
label = label.arg(val);
m_View->m_Controls->label_pfwidth->setText(label);
float color[3];
node->GetColor( color, NULL, "planarfigure.default.line.color");
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_View->m_Controls->m_PFColor->setAutoFillBackground(true);
m_View->m_Controls->m_PFColor->setStyleSheet(styleSheet);
node->GetColor( color, NULL, "color");
styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_View->PlanarFigureFocus();
}
if(dynamic_cast<mitk::FiberBundleX*>(nodeData) != 0)
{
m_View->m_Controls->m_BundleControlsFrame->setVisible(true);
m_View->m_SelectedNode = node;
if(m_View->m_CurrentPickingNode != 0 && node.GetPointer() != m_View->m_CurrentPickingNode)
{
m_View->m_Controls->m_Crosshair->setEnabled(false);
}
else
{
m_View->m_Controls->m_Crosshair->setEnabled(true);
}
float val;
node->GetFloatProperty("TubeRadius", val);
m_View->m_Controls->m_TubeRadius->setValue((int)(val * 100.0));
QString label = "Radius %1";
label = label.arg(val);
m_View->m_Controls->label_tuberadius->setText(label);
int width;
node->GetIntProperty("LineWidth", width);
m_View->m_Controls->m_LineWidth->setValue(width);
label = "Width %1";
label = label.arg(width);
m_View->m_Controls->label_linewidth->setText(label);
float range;
node->GetFloatProperty("Fiber2DSliceThickness",range);
label = "Range %1";
label = label.arg(range*0.1);
m_View->m_Controls->label_range->setText(label);
}
} // check node data != NULL
}
}
if(m_View->m_CurrentSelection->Size() > 0 && m_View->m_SelectedNode == 0)
{
m_View->m_Controls->m_ImageControlsFrame->setVisible(true);
bool foundDiffusionImage = false;
bool foundQBIVolume = false;
bool foundTensorVolume = false;
bool foundImage = false;
bool foundMultipleOdfImages = false;
bool foundRGBAImage = false;
bool foundTbssImage = false;
// do something with the selected items
if(m_View->m_CurrentSelection)
{
// iterate selection
for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
i != m_View->m_CurrentSelection->End(); ++i)
{
// extract datatree node
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
mitk::BaseData* nodeData = node->GetData();
if(nodeData != NULL )
{
// only look at interesting types
if(QString("DiffusionImage").compare(nodeData->GetNameOfClass())==0)
{
foundDiffusionImage = true;
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
int val;
node->GetIntProperty("DisplayChannel", val);
m_View->m_Controls->m_DisplayIndex->setValue(val);
QString label = "Channel %1";
label = label.arg(val);
m_View->m_Controls->label_channel->setText(label);
int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(nodeData))->GetVectorImage()->GetVectorLength();
m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
}
if(QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
{
foundTbssImage = true;
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
int val;
node->GetIntProperty("DisplayChannel", val);
m_View->m_Controls->m_DisplayIndex->setValue(val);
QString label = "Channel %1";
label = label.arg(val);
m_View->m_Controls->label_channel->setText(label);
int maxVal = (dynamic_cast<mitk::TbssImage* >(nodeData))->GetImage()->GetVectorLength();
m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
}
else if(QString("QBallImage").compare(nodeData->GetNameOfClass())==0)
{
foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
foundQBIVolume = true;
ApplySettings(node);
}
else if(QString("TensorImage").compare(nodeData->GetNameOfClass())==0)
{
foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
foundTensorVolume = true;
ApplySettings(node);
}
else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
{
foundImage = true;
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(nodeData);
if(img.IsNotNull()
&& img->GetPixelType().GetPixelTypeId() == itk::ImageIOBase::RGBA
&& img->GetPixelType().GetTypeId() == typeid(unsigned char) )
{
foundRGBAImage = true;
}
bool tex_int;
node->GetBoolProperty("texture interpolation", tex_int);
if(tex_int)
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
m_View->m_Controls->m_TextureIntON->setChecked(true);
m_View->m_TexIsOn = true;
}
else
{
m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
m_View->m_Controls->m_TextureIntON->setChecked(false);
m_View->m_TexIsOn = false;
}
}
} // END CHECK node != NULL
}
}
}
m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
&& !foundMultipleOdfImages;
m_View->m_Controls->m_NumberGlyphsFrame->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_NormalizationDropdown->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->label->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_ScalingFactor->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_AdditionalScaling->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_NormalizationScalingFrame->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->OpacMinFrame->setVisible(foundRGBAImage || m_View->m_FoundSingleOdfImage);
// changed for SPIE paper, Principle curvature scaling
//m_View->m_Controls->params_frame->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->params_frame->setVisible(false);
m_View->m_Controls->m_VisibleOdfsON_T->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_VisibleOdfsON_S->setVisible(m_View->m_FoundSingleOdfImage);
m_View->m_Controls->m_VisibleOdfsON_C->setVisible(m_View->m_FoundSingleOdfImage);
bool foundAnyImage = foundDiffusionImage ||
foundQBIVolume || foundTensorVolume || foundImage || foundTbssImage;
m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
}
}
void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
{
// check, if selection comes from datamanager
if (part)
{
QString partname(part->GetPartName().c_str());
if(partname.compare("Datamanager")==0)
{
// apply selection
DoSelectionChanged(selection);
}
}
}
QmitkControlVisualizationPropertiesView* m_View;
};
QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL),
m_NodeUsedForOdfVisualization(NULL),
m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
m_CurrentSelection(0),
m_CurrentPickingNode(0),
m_GlyIsOn_S(false),
m_GlyIsOn_C(false),
m_GlyIsOn_T(false),
m_FiberBundleObserverTag(0),
m_Color(NULL)
{
currentThickSlicesMode = 1;
m_MyMenu = NULL;
}
QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
{
if(m_SlicesRotationObserverTag1 )
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if( coordinator)
coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
}
if( m_SlicesRotationObserverTag2)
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if( coordinator )
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 ) );
n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
}
else
{
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 ) );
n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
}
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);
connect( m_MyMenu, SIGNAL( aboutToShow() ), this, SLOT(OnMenuAboutToShow()) );
// button for changing rotation mode
m_Controls->m_TSMenu->setMenu( m_MyMenu );
//m_CrosshairModeButton->setIcon( QIcon( iconCrosshairMode_xpm ) );
m_Controls->params_frame->setVisible(false);
QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
m_Controls->m_Reinit->setIcon(icon5);
m_Controls->m_Focus->setIcon(icon5);
QIcon iconColor(":/QmitkDiffusionImaging/color24.gif");
m_Controls->m_PFColor->setIcon(iconColor);
m_Controls->m_Color->setIcon(iconColor);
QIcon iconReset(":/QmitkDiffusionImaging/reset.png");
m_Controls->m_ResetColoring->setIcon(iconReset);
m_Controls->m_PFColor->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QIcon iconCrosshair(":/QmitkDiffusionImaging/crosshair.png");
m_Controls->m_Crosshair->setIcon(iconCrosshair);
// was is los
QIcon iconPaint(":/QmitkDiffusionImaging/paint2.png");
m_Controls->m_TDI->setIcon(iconPaint);
QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
m_Controls->m_TextureIntON->setCheckable(true);
#ifndef DIFFUSION_IMAGING_EXTENDED
int size = m_Controls->m_AdditionalScaling->count();
for(int t=0; t<size; t++)
{
if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
{
m_Controls->m_AdditionalScaling->removeItem(t);
}
}
#endif
m_Controls->m_OpacitySlider->setRange(0.0,1.0);
m_Controls->m_OpacitySlider->setLowerValue(0.0);
m_Controls->m_OpacitySlider->setUpperValue(0.0);
m_Controls->m_ScalingFrame->setVisible(false);
m_Controls->m_NormalizationFrame->setVisible(false);
m_Controls->frame_tube->setVisible(false);
m_Controls->frame_wire->setVisible(false);
}
m_IsInitialized = false;
m_SelListener = berry::ISelectionListener::Pointer(new CvpSelListener(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
m_IsInitialized = true;
}
void QmitkControlVisualizationPropertiesView::OnMenuAboutToShow ()
{
// THICK SLICE SUPPORT
QMenu *myMenu = m_MyMenu;
myMenu->clear();
QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
thickSlicesActionGroup->setExclusive(true);
mitk::BaseRenderer::Pointer renderer =
this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
int currentTSMode = 0;
{
mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices" ));
if( m.IsNotNull() )
currentTSMode = m->GetValueAsId();
}
const int maxTS = 30;
int currentNum = 0;
{
mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(renderer->GetCurrentWorldGeometry2DNode()->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::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::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_DisplayIndex), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
connect( (QObject*)(m_Controls->m_Reinit), SIGNAL(clicked()), this, SLOT(Reinit()) );
connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
connect( (QObject*)(m_Controls->m_IndexParam1), SIGNAL(valueChanged(double)), this, SLOT(IndexParam1Changed(double)) );
connect( (QObject*)(m_Controls->m_IndexParam2), SIGNAL(valueChanged(double)), this, SLOT(IndexParam2Changed(double)) );
connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
connect( (QObject*)(m_Controls->m_OpacitySlider), SIGNAL(spanChanged(double,double)), this, SLOT(OpacityChanged(double,double)) );
connect((QObject*) m_Controls->m_Wire, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationWire()));
connect((QObject*) m_Controls->m_Tube, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationTube()));
connect((QObject*) m_Controls->m_Color, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationColor()));
connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
connect((QObject*) m_Controls->m_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
connect((QObject*) m_Controls->m_PFWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(PFWidth(int)));
connect((QObject*) m_Controls->m_PFColor, SIGNAL(clicked()), (QObject*) this, SLOT(PFColor()));
connect((QObject*) m_Controls->m_TDI, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateTdi()));
connect((QObject*) m_Controls->m_LineWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(LineWidthChanged(int)));
connect((QObject*) m_Controls->m_TubeRadius, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(TubeRadiusChanged(int)));
}
}
void QmitkControlVisualizationPropertiesView::Activated()
{
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
QmitkFunctionality::Activated();
}
void QmitkControlVisualizationPropertiesView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
int QmitkControlVisualizationPropertiesView::GetSizeFlags(bool width)
{
if(!width)
{
return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
}
else
{
return 0;
}
}
int QmitkControlVisualizationPropertiesView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
{
if(width==false)
{
return m_FoundSingleOdfImage ? 120 : 80;
}
else
{
return preferredResult;
}
}
// set diffusion image channel to b0 volume
void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
{
mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
if (dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData()))
{
mitk::DiffusionImage<short>::Pointer dimg = dynamic_cast<mitk::DiffusionImage<short>*>(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;
if( dimg->GetB0Indices().size() > 0)
displayChannelPropertyValue = dimg->GetB0Indices().front();
notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
}
}
/* OnSelectionChanged is registered to SelectionService, therefore no need to
implement SelectionService Listener explicitly */
void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
// deactivate channel slider if no diffusion weighted image or tbss image is selected
m_Controls->m_DisplayIndex->setVisible(false);
m_Controls->label_channel->setVisible(false);
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if (node.IsNotNull() && (dynamic_cast<mitk::TbssImage*>(nodeData) ||
dynamic_cast<mitk::DiffusionImage<short>*>(nodeData)))
{
m_Controls->m_DisplayIndex->setVisible(true);
m_Controls->label_channel->setVisible(true);
}
else if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
{
if (m_Color.IsNotNull())
m_Color->RemoveObserver(m_FiberBundleObserverTag);
itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
if (m_Color.IsNotNull())
m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
}
}
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData)) )
{
if(m_NodeUsedForOdfVisualization.IsNotNull())
{
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
}
m_NodeUsedForOdfVisualization = node;
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
m_Controls->m_TSMenu->setVisible(false); // deactivate mip etc. for tensor and q-ball images
break;
}
else
m_Controls->m_TSMenu->setVisible(true);
}
}
mitk::DataStorage::SetOfObjects::Pointer
QmitkControlVisualizationPropertiesView::ActiveSet(std::string classname)
{
if (m_CurrentSelection)
{
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
i != m_CurrentSelection->End();
++i)
{
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// check if node has data,
// if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
const mitk::BaseData* nodeData = node->GetData();
if(nodeData == NULL)
continue;
if(QString(classname.c_str()).compare(nodeData->GetNameOfClass())==0)
{
set->InsertElement(at++, node);
}
}
}
return set;
}
return 0;
}
void QmitkControlVisualizationPropertiesView::SetBoolProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, bool value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetBoolProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetIntProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, int value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetFloatProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, float value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetFloatProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetLevelWindowProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::LevelWindow value)
{
if(set.IsNotNull())
{
mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), prop);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::SetEnumProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::EnumerationProperty::Pointer value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkControlVisualizationPropertiesView::DisplayIndexChanged(int dispIndex)
{
QString label = "Channel %1";
label = label.arg(dispIndex);
m_Controls->label_channel->setText(label);
std::vector<std::string> sets;
sets.push_back("DiffusionImage");
sets.push_back("TbssImage");
std::vector<std::string>::iterator it = sets.begin();
while(it != sets.end())
{
std::string s = *it;
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet(s);
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
++itemiter;
}
//m_MultiWidget->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
it++;
}
}
void QmitkControlVisualizationPropertiesView::Reinit()
{
if (m_CurrentSelection)
{
mitk::DataNodeObject::Pointer nodeObj =
m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
- basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkControlVisualizationPropertiesView::TextIntON()
{
if(m_TexIsOn)
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
}
else
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("DiffusionImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("TensorImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("QBallImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("Image");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
m_TexIsOn = !m_TexIsOn;
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
{
m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
VisibleOdfsON(0);
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
{
m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
VisibleOdfsON(1);
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
{
m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
if (m_NodeUsedForOdfVisualization.IsNull())
{
MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
return;
}
m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
VisibleOdfsON(2);
}
bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
{
// for all 2D renderwindows of m_MultiWidget check alignment
mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
if (displayPlane.IsNull()) return false;
mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
if( currentImage == NULL )
{
MITK_ERROR << " Casting problems. Returning false";
return false;
}
int affectedDimension(-1);
int affectedSlice(-1);
return !(mitk::SegTool2D::DetermineAffectedImageSlice( currentImage, displayPlane, affectedDimension, affectedSlice ));
}
void QmitkControlVisualizationPropertiesView::VisibleOdfsON(int view)
{
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
{
int maxNr = m_Controls->m_ShowMaxNumber->value();
if ( maxNr < 1 )
{
m_Controls->m_ShowMaxNumber->setValue( 1 );
maxNr = 1;
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
set = ActiveSet("TensorImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
{
typedef mitk::OdfNormalizationMethodProperty PropType;
PropType::Pointer normMeth = PropType::New();
switch(normDropdown)
{
case 0:
normMeth->SetNormalizationToMinMax();
break;
case 1:
normMeth->SetNormalizationToMax();
break;
case 2:
normMeth->SetNormalizationToNone();
break;
case 3:
normMeth->SetNormalizationToGlobalMax();
break;
default:
normMeth->SetNormalizationToMinMax();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
// if(m_MultiWidget)
// m_MultiWidget->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"Scaling", scalingFactor);
set = ActiveSet("TensorImage");
SetFloatProp(set,"Scaling", scalingFactor);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
{
typedef mitk::OdfScaleByProperty PropType;
PropType::Pointer scaleBy = PropType::New();
switch(additionalScaling)
{
case 0:
scaleBy->SetScaleByNothing();
break;
case 1:
scaleBy->SetScaleByGFA();
//m_Controls->params_frame->setVisible(true);
break;
#ifdef DIFFUSION_IMAGING_EXTENDED
case 2:
scaleBy->SetScaleByPrincipalCurvature();
// commented in for SPIE paper, Principle curvature scaling
//m_Controls->params_frame->setVisible(true);
break;
#endif
default:
scaleBy->SetScaleByNothing();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::IndexParam1Changed(double param1)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam1", param1);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam1", param1);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::IndexParam2Changed(double param2)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam2", param2);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam2", param2);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::OpacityChanged(double l, double u)
{
mitk::LevelWindow olw;
olw.SetRangeMinMax(l*255, u*255);
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("TensorImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("Image");
SetLevelWindowProp(set,"opaclevelwindow", olw);
m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
{
m_Controls->m_ScalingFrame->setVisible(
m_Controls->m_ScalingCheckbox->isChecked());
if(!m_Controls->m_ScalingCheckbox->isChecked())
{
m_Controls->m_AdditionalScaling->setCurrentIndex(0);
m_Controls->m_ScalingFactor->setValue(1.0);
}
}
void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
{
if (m_SelectedNode)
{
bool currentMode;
m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
{
if (m_SelectedNode)
{
float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
{
QString label = "Range %1";
label = label.arg(value * 0.1);
m_Controls->label_range->setText(label);
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationWire()
{
if(m_SelectedNode)
{
int width = m_Controls->m_LineWidth->value();
m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationTube()
{
if(m_SelectedNode)
{
float radius = m_Controls->m_TubeRadius->value() / 100.0;
m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
{
float color[3];
m_SelectedNode->GetColor(color);
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[1]*255.0));
styleSheet.append(",");
styleSheet.append(QString::number(color[2]*255.0));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color[0], color[1], color[2]));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
m_SelectedNode->Modified();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationColor()
{
if(m_SelectedNode)
{
QColor color = QColorDialog::getColor();
if (!color.isValid())
return;
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
m_SelectedNode->Modified();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
{
if(m_SelectedNode)
{
MITK_INFO << "reset colorcoding to oBased";
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(255,255,255)";
m_Controls->m_Color->setStyleSheet(styleSheet);
// m_SelectedNode->SetProperty("color",NULL);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(1.0, 1.0, 1.0));
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED);
fib->DoColorCodingOrientationBased();
m_SelectedNode->Modified();
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
{
if(m_SelectedNode)
{
mitk::PlanarFigure* _PlanarFigure = 0;
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
if (_PlanarFigure && _PlanarFigure->GetGeometry2D())
{
QmitkRenderWindow* selectedRenderWindow = 0;
bool PlanarFigureInitializedWindow = false;
QmitkRenderWindow* RenderWindow1 =
this->GetActiveStdMultiWidget()->GetRenderWindow1();
if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
{
selectedRenderWindow = RenderWindow1;
}
QmitkRenderWindow* RenderWindow2 =
this->GetActiveStdMultiWidget()->GetRenderWindow2();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow2->GetRenderer()))
{
selectedRenderWindow = RenderWindow2;
}
QmitkRenderWindow* RenderWindow3 =
this->GetActiveStdMultiWidget()->GetRenderWindow3();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow3->GetRenderer()))
{
selectedRenderWindow = RenderWindow3;
}
QmitkRenderWindow* RenderWindow4 =
this->GetActiveStdMultiWidget()->GetRenderWindow4();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow4->GetRenderer()))
{
selectedRenderWindow = RenderWindow4;
}
const mitk::PlaneGeometry
* _PlaneGeometry =
dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry1 =
RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane1 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry2 =
RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane2 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry3 =
RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane3 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
normal[0] = fabs(normal[0]); normal[1] = fabs(normal[1]); normal[2] = fabs(normal[2]);
normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
double ang1 = angle(normal, normal1);
double ang2 = angle(normal, normal2);
double ang3 = angle(normal, normal3);
if(ang1 < ang2 && ang1 < ang3)
{
selectedRenderWindow = RenderWindow1;
}
else
{
if(ang2 < ang3)
{
selectedRenderWindow = RenderWindow2;
}
else
{
selectedRenderWindow = RenderWindow3;
}
}
// make node visible
if (selectedRenderWindow)
{
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->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", m_SelectedNode);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
}
}
void QmitkControlVisualizationPropertiesView::SetInteractor()
{
typedef std::vector<mitk::DataNode*> Container;
Container _NodeSet = this->GetDataManagerSelection();
mitk::DataNode* node = 0;
mitk::FiberBundleX* bundle = 0;
mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
// finally add all nodes to the model
for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
; it++)
{
node = const_cast<mitk::DataNode*>(*it);
bundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
if(bundle)
{
bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
if(bundleInteractor.IsNotNull())
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
if(!m_Controls->m_Crosshair->isChecked())
{
m_Controls->m_Crosshair->setChecked(false);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
m_CurrentPickingNode = 0;
}
else
{
m_Controls->m_Crosshair->setChecked(true);
bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
m_CurrentPickingNode = node;
}
}
}
}
void QmitkControlVisualizationPropertiesView::PFWidth(int w)
{
double width = w/10.0;
m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QString label = "Width %1";
label = label.arg(width);
m_Controls->label_pfwidth->setText(label);
}
void QmitkControlVisualizationPropertiesView::PFColor()
{
QColor color = QColorDialog::getColor();
if (!color.isValid())
return;
m_Controls->m_PFColor->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_PFColor->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkControlVisualizationPropertiesView::GenerateTdi()
{
if(m_SelectedNode)
{
mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
if(!bundle)
return;
typedef float OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
// run generator
itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
generator->SetFiberBundle(bundle);
generator->SetOutputAbsoluteValues(true);
generator->SetUpsamplingFactor(1);
generator->Update();
// get result
OutImageType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
// to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
QString name(m_SelectedNode->GetName().c_str());
name += "_TDI";
node->SetName(name.toStdString());
node->SetVisibility(true);
GetDataStorage()->Add(node);
}
}
void QmitkControlVisualizationPropertiesView::LineWidthChanged(int w)
{
QString label = "Width %1";
label = label.arg(w);
m_Controls->label_linewidth->setText(label);
BundleRepresentationWire();
}
void QmitkControlVisualizationPropertiesView::TubeRadiusChanged(int r)
{
QString label = "Radius %1";
label = label.arg(r / 100.0);
m_Controls->label_tuberadius->setText(label);
this->BundleRepresentationTube();
}
void QmitkControlVisualizationPropertiesView::Welcome()
{
berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
GetSite()->GetWorkbenchWindow(), false);
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
index eec63e7d6c..926c574038 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
@@ -1,800 +1,800 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkDiffusionDicomImportView.h"
// qt includes
#include <QFileDialog>
// itk includes
#include "itkTimeProbesCollectorBase.h"
#include "itkGDCMSeriesFileNames.h"
#include "itksys/SystemTools.hxx"
// mitk includes
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include "mitkMemoryUtilities.h"
// diffusion module includes
#include "mitkDicomDiffusionImageHeaderReader.h"
#include "mitkGroupDiffusionHeadersFilter.h"
#include "mitkDicomDiffusionImageReader.h"
#include "mitkDiffusionImage.h"
#include "mitkNrrdDiffusionImageWriter.h"
#include "gdcmDirectory.h"
#include "gdcmScanner.h"
#include "gdcmSorter.h"
#include "gdcmIPPSorter.h"
#include "gdcmAttribute.h"
#include "gdcmVersion.h"
#include <QMessageBox>
const std::string QmitkDiffusionDicomImport::VIEW_ID = "org.mitk.views.diffusiondicomimport";
QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(QObject* /*parent*/, const char* /*name*/)
: QmitkFunctionality(), m_Controls(NULL), m_MultiWidget(NULL),
m_OutputFolderName(""), m_OutputFolderNameSet(false)
{
}
QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkDiffusionDicomImport::~QmitkDiffusionDicomImport()
{}
void QmitkDiffusionDicomImport::CreateQtPartControl(QWidget *parent)
{
m_Parent = parent;
if (m_Controls == NULL)
{
m_Controls = new Ui::QmitkDiffusionDicomImportControls;
m_Controls->setupUi(parent);
this->CreateConnections();
m_Controls->m_DicomLoadRecursiveCheckbox->setChecked(true);
m_Controls->m_DicomLoadAverageDuplicatesCheckbox->setChecked(false);
m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(false);
m_Controls->m_OverrideOptionCheckbox->setVisible(false);
AverageClicked();
}
}
void QmitkDiffusionDicomImport::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_AddFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadAddFolderNames()) );
connect( m_Controls->m_DeleteFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadDeleteFolderNames()) );
connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(DicomLoadStartLoad()) );
connect( m_Controls->m_DicomLoadAverageDuplicatesCheckbox, SIGNAL(clicked()), this, SLOT(AverageClicked()) );
connect( m_Controls->m_OutputSetButton, SIGNAL(clicked()), this, SLOT(OutputSet()) );
connect( m_Controls->m_OutputClearButton, SIGNAL(clicked()), this, SLOT(OutputClear()) );
connect( m_Controls->m_Remove, SIGNAL(clicked()), this, SLOT(Remove()) );
}
}
void QmitkDiffusionDicomImport::Remove()
{
int i = m_Controls->listWidget->currentRow();
m_Controls->listWidget->takeItem(i);
}
void QmitkDiffusionDicomImport::OutputSet()
{
// SELECT FOLDER DIALOG
QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
w->setFileMode( QFileDialog::Directory );
// RETRIEVE SELECTION
if ( w->exec() != QDialog::Accepted )
return;
m_OutputFolderName = w->selectedFiles()[0];
m_OutputFolderNameSet = true;
m_Controls->m_OutputLabel->setText(m_OutputFolderName);
// show file override option checkbox
m_Controls->m_OverrideOptionCheckbox->setVisible(true);
}
void QmitkDiffusionDicomImport::OutputClear()
{
m_OutputFolderName = "";
m_OutputFolderNameSet = false;
m_Controls->m_OutputLabel->setText("... optional out-folder ...");
// hide file override option checkbox - no output specified
m_Controls->m_OverrideOptionCheckbox->setVisible(false);
}
void QmitkDiffusionDicomImport::AverageClicked()
{
m_Controls->m_Blur->setEnabled(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked());
}
void QmitkDiffusionDicomImport::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkDiffusionDicomImport::DicomLoadDeleteFolderNames()
{
m_Controls->listWidget->clear();
}
void QmitkDiffusionDicomImport::DicomLoadAddFolderNames()
{
// SELECT FOLDER DIALOG
QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
w->setFileMode( QFileDialog::Directory );
// RETRIEVE SELECTION
if ( w->exec() != QDialog::Accepted )
return;
m_Controls->listWidget->addItems(w->selectedFiles());
}
bool SortBySeriesUID(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
{
gdcm::Attribute<0x0020,0x000e> at1;
at1.Set( ds1 );
gdcm::Attribute<0x0020,0x000e> at2;
at2.Set( ds2 );
return at1 < at2;
}
bool SortByAcquisitionNumber(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
{
gdcm::Attribute<0x0020,0x0012> at1;
at1.Set( ds1 );
gdcm::Attribute<0x0020,0x0012> at2;
at2.Set( ds2 );
return at1 < at2;
}
bool SortBySeqName(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
{
gdcm::Attribute<0x0018, 0x0024> at1;
at1.Set( ds1 );
gdcm::Attribute<0x0018, 0x0024> at2;
at2.Set( ds2 );
std::string str1 = at1.GetValue().Trim();
std::string str2 = at2.GetValue().Trim();
return std::lexicographical_compare(str1.begin(), str1.end(),
str2.begin(), str2.end() );
}
void QmitkDiffusionDicomImport::Status(QString status)
{
mitk::StatusBar::GetInstance()->DisplayText(status.toAscii());
MITK_INFO << status.toStdString().c_str();
}
void QmitkDiffusionDicomImport::Status(std::string status)
{
mitk::StatusBar::GetInstance()->DisplayText(status.c_str());
MITK_INFO << status.c_str();
}
void QmitkDiffusionDicomImport::Status(const char* status)
{
mitk::StatusBar::GetInstance()->DisplayText(status);
MITK_INFO << status;
}
void QmitkDiffusionDicomImport::Error(QString status)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(status.toAscii());
MITK_ERROR << status.toStdString().c_str();
}
void QmitkDiffusionDicomImport::Error(std::string status)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(status.c_str());
MITK_ERROR << status.c_str();
}
void QmitkDiffusionDicomImport::Error(const char* status)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(status);
MITK_ERROR << status;
}
void QmitkDiffusionDicomImport::PrintMemoryUsage()
{
size_t processSize = mitk::MemoryUtilities::GetProcessMemoryUsage();
size_t totalSize = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
float percentage = ( (float) processSize / (float) totalSize ) * 100.0;
MITK_INFO << "Current memory usage: " << GetMemoryDescription( processSize, percentage );
}
std::string QmitkDiffusionDicomImport::FormatMemorySize( size_t size )
{
double val = size;
std::string descriptor("B");
if ( val >= 1000.0 )
{
val /= 1024.0;
descriptor = "KB";
}
if ( val >= 1000.0 )
{
val /= 1024.0;
descriptor = "MB";
}
if ( val >= 1000.0 )
{
val /= 1024.0;
descriptor = "GB";
}
std::ostringstream str;
str << std::fixed << std::setprecision(2) << val << " " << descriptor;
return str.str();
}
std::string QmitkDiffusionDicomImport::FormatPercentage( double val )
{
std::ostringstream str;
str << std::fixed << std::setprecision(2) << val << " " << "%";
return str.str();
}
std::string QmitkDiffusionDicomImport::GetMemoryDescription( size_t processSize, float percentage )
{
std::ostringstream str;
str << FormatMemorySize(processSize) << " (" << FormatPercentage( percentage ) <<")" ;
return str.str();
}
void QmitkDiffusionDicomImport::DicomLoadStartLoad()
{
itk::TimeProbesCollectorBase clock;
bool imageSuccessfullySaved = true;
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
int nrFolders = m_Controls->listWidget->count();
if(!nrFolders)
{
Error(QString("No input folders were selected. ABORTING."));
return;
}
Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
PrintMemoryUsage();
QString status;
mitk::DataNode::Pointer node;
mitk::ProgressBar::GetInstance()->AddStepsToDo(2*nrFolders);
std::string folder = m_Controls->m_OutputLabel->text().toStdString();
if(berry::Platform::IsWindows())
{
folder.append("\\import.log");
}
else
{
folder.append("/import.log");
}
ofstream logfile;
if(m_OutputFolderNameSet) logfile.open(folder.c_str());
while(m_Controls->listWidget->count())
{
// RETREIVE FOLDERNAME
QListWidgetItem * item = m_Controls->listWidget->takeItem(0);
QString folderName = item->text();
if(m_OutputFolderNameSet) logfile << "Reading " << folderName.toStdString() << '\n';
// PARSING DIRECTORY
PrintMemoryUsage();
clock.Start(folderName.toAscii());
std::vector<std::string> seriesUIDs(0);
std::vector<std::vector<std::string> > seriesFilenames(0);
Status("== Initial Directory Scan ==");
if(m_OutputFolderNameSet) logfile << "== Initial Directory Scan ==\n";
gdcm::Directory d;
d.Load( folderName.toStdString().c_str(), true ); // recursive !
const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
const unsigned int ntotalfiles = l1.size();
Status(QString(" ... found %1 different files").arg(ntotalfiles));
if(m_OutputFolderNameSet)logfile << "...found " << ntotalfiles << " different files\n";
Status("Scanning Headers");
if(m_OutputFolderNameSet) logfile << "Scanning Headers\n";
gdcm::Scanner s;
const gdcm::Tag t1(0x0020,0x000d); // Study Instance UID
const gdcm::Tag t2(0x0020,0x000e); // Series Instance UID
const gdcm::Tag t5(0x0028, 0x0010); // number rows
const gdcm::Tag t6(0x0028, 0x0011); // number cols
s.AddTag( t1 );
s.AddTag( t2 );
s.AddTag( t5 );
s.AddTag( t6 );
bool b = s.Scan( d.GetFilenames() );
if( !b )
{
Error("Scanner failed");
if(m_OutputFolderNameSet )logfile << "ERROR: scanner failed\n";
continue;
}
// Only get the DICOM files:
gdcm::Directory::FilenamesType l2 = s.GetKeys();
const int nfiles = l2.size();
if(nfiles < 1)
{
Error("No DICOM files found");
if(m_OutputFolderNameSet)logfile << "ERROR: No DICOM files found\n";
continue;
}
Status(QString(" ... successfully scanned %1 headers.").arg(nfiles));
if(m_OutputFolderNameSet) logfile << "...succesfully scanned " << nfiles << " headers\n";
Status("Sorting");
if(m_OutputFolderNameSet) logfile << "Sorting\n";
const gdcm::Scanner::ValuesType &values1 = s.GetValues(t1);
int nvalues;
if(m_Controls->m_DuplicateID->isChecked())
{
nvalues = 1;
}
else
{
nvalues = values1.size();
}
if(nvalues>1)
{
Error("Multiple sSeries tudies found. Please limit to 1 study per folder");
if(m_OutputFolderNameSet) logfile << "Multiple series found. Limit to one. If you are convinced this is an error use the merge duplicate study IDs option \n";
continue;
}
const gdcm::Scanner::ValuesType &values5 = s.GetValues(t5);
const gdcm::Scanner::ValuesType &values6 = s.GetValues(t6);
if(values5.size()>1 || values6.size()>1)
{
Error("Folder contains images of unequal dimensions that cannot be combined in one 3d volume. ABORTING.");
if(m_OutputFolderNameSet) logfile << "Folder contains images of unequal dimensions that cannot be combined in one 3d volume. ABORTING\n.";
continue;
}
const gdcm::Scanner::ValuesType &values2 = s.GetValues(t2);
int nSeries;
if(m_Controls->m_DuplicateID->isChecked())
{
nSeries = 1;
}
else
{
nSeries = values2.size();
}
gdcm::Directory::FilenamesType files;
if(nSeries > 1)
{
gdcm::Sorter sorter;
sorter.SetSortFunction( SortBySeriesUID );
sorter.StableSort( l2 );
files = sorter.GetFilenames();
}
else
{
files = l2;
}
unsigned int nTotalAcquis = 0;
if(nfiles % nSeries != 0)
{
Error("Number of files in series not equal, ABORTING");
if(m_OutputFolderNameSet) logfile << "Number of files in series not equal, Some volumes are probably incomplete. ABORTING \n";
continue;
}
int filesPerSeries = nfiles / nSeries;
gdcm::Scanner::ValuesType::const_iterator it2 = values2.begin();
for(int i=0; i<nSeries; i++)
{
gdcm::Directory::FilenamesType sub( files.begin() + i*filesPerSeries, files.begin() + (i+1)*filesPerSeries);
gdcm::Scanner s;
const gdcm::Tag t3(0x0020,0x0012); // Acquisition ID
const gdcm::Tag t4(0x0018,0x0024); // Sequence Name (in case acquisitions are equal for all)
// const gdcm::Tag t5(0x20,0x32) ); // Image Position (Patient)
s.AddTag(t3);
s.AddTag(t4);
// s.AddTag(t5);
bool b = s.Scan( sub );
if( !b )
{
Error("Scanner failed");
if(m_OutputFolderNameSet) logfile << "Scanner failed\n";
continue;
}
gdcm::Sorter subsorter;
gdcm::Scanner::ValuesType::const_iterator it;
const gdcm::Scanner::ValuesType &values3 = s.GetValues(t3);
const gdcm::Scanner::ValuesType &values4 = s.GetValues(t4);;
unsigned int nAcquis = values3.size();
if(nAcquis > 1) // More than one element must have this tag (Not != )
{
subsorter.SetSortFunction( SortByAcquisitionNumber );
it = values3.begin();
}
else if (values4.size() > 1)
{
nAcquis = values4.size();
subsorter.SetSortFunction( SortBySeqName );
it = values4.begin();
}
// Hotfix for Bug 14758, better fix by selecting always availible tags.
else
{
Error("Sorting tags (0x0020,0x0012) and (0x0018,0x0024) missing, ABORTING");
if(m_OutputFolderNameSet) logfile << "Sorting tags (0x0020,0x0012) and (0x0018,0x0024) missing, ABORTING\n";
continue;
}
nTotalAcquis += nAcquis;
subsorter.Sort( sub );
if(filesPerSeries % nAcquis != 0)
{
Error("Number of files per acquisition not equal, ABORTING");
if(m_OutputFolderNameSet) logfile << "Number of files per acquisition not equal, ABORTING \n";
continue;
}
int filesPerAcqu = filesPerSeries / nAcquis;
gdcm::Directory::FilenamesType subfiles = subsorter.GetFilenames();
for ( unsigned int j = 0 ; j < nAcquis ; ++j )
{
std::string identifier = "serie_" + *it2 + "_acquis_" + *it++;
gdcm::IPPSorter ippsorter;
gdcm::Directory::FilenamesType ipplist((j)*filesPerAcqu+subfiles.begin(),(j+1)*filesPerAcqu+subfiles.begin());
ippsorter.SetComputeZSpacing( true );
if( !ippsorter.Sort( ipplist ) )
{
Error(QString("Failed to sort acquisition %1, ABORTING").arg(identifier.c_str()));
if(m_OutputFolderNameSet) logfile << "Failed to sort acquisition " << identifier.c_str() << " , Aborting\n";
continue;
}
const std::vector<std::string> & list = ippsorter.GetFilenames();
seriesFilenames.push_back(list);
seriesUIDs.push_back(identifier.c_str());
}
++it2;
}
// Hot Fix for Bug 14758, checking if no file is acuired.
if (nTotalAcquis < 1) // Test if zero, if true than error because no file was selected
{
Error("Nno files in acquisitions, ABORTING");
if(m_OutputFolderNameSet) logfile << "Nno files in acquisitions, ABORTING \n";
continue;
}
if(nfiles % nTotalAcquis != 0)
{
Error("Number of files per acquisition differs between series, ABORTING");
if(m_OutputFolderNameSet) logfile << "Number of files per acquisition differs between series, ABORTING \n";
continue;
}
int slices = nfiles/nTotalAcquis;
Status(QString("Series is composed of %1 different 3D volumes with %2 slices.").arg(nTotalAcquis).arg(slices));
if(m_OutputFolderNameSet) logfile << "Series is composed of " << nTotalAcquis << " different 3D volumes with " << slices << " slices\n";
// READING HEADER-INFOS
PrintMemoryUsage();
Status(QString("Reading Headers %1").arg(folderName));
if(m_OutputFolderNameSet) logfile << "Reading Headers "<< folderName.toStdString() << "\n";
mitk::DicomDiffusionImageHeaderReader::Pointer headerReader;
mitk::GroupDiffusionHeadersFilter::InputType inHeaders;
unsigned int size2 = seriesUIDs.size();
for ( unsigned int i = 0 ; i < size2 ; ++i )
{
// Hot Fix for Bug 14459, catching if no valid data in datafile.
try
{
Status(QString("Reading header image #%1/%2").arg(i+1).arg(size2));
headerReader = mitk::DicomDiffusionImageHeaderReader::New();
headerReader->SetSeriesDicomFilenames(seriesFilenames[i]);
headerReader->Update();
inHeaders.push_back(headerReader->GetOutput());
}
catch (mitk::Exception e)
{
Error("Could not read file header, ABORTING");
if(m_OutputFolderNameSet) logfile << e;
continue;
}
//Status(std::endl;
}
mitk::ProgressBar::GetInstance()->Progress();
// // GROUP HEADERS
// mitk::GroupDiffusionHeadersFilter::Pointer grouper
// = mitk::GroupDiffusionHeadersFilter::New();
// mitk::GroupDiffusionHeadersFilter::OutputType outHeaders;
// grouper->SetInput(inHeaders);
// grouper->Update();
// outHeaders = grouper->GetOutput();
// READ VOLUMES
PrintMemoryUsage();
if(m_OutputFolderNameSet) logfile << "Loading volumes\n";
Status(QString("Loading Volumes %1").arg(folderName));
typedef short PixelValueType;
typedef mitk::DicomDiffusionImageReader< PixelValueType, 3 > VolumesReader;
VolumesReader::Pointer vReader = VolumesReader::New();
VolumesReader::HeaderContainer hc = inHeaders;
// hc.insert(hc.end(), outHeaders[1].begin(), outHeaders[1].end() );
// hc.insert(hc.end(), outHeaders[2].begin(), outHeaders[2].end() );
if(hc.size()>1)
{
vReader->SetHeaders(hc);
vReader->Update();
VolumesReader::OutputImageType::Pointer vecImage;
vecImage = vReader->GetOutput();
Status(QString("Volumes Loaded (%1)").arg(folderName));
// CONSTRUCT CONTAINER WITH DIRECTIONS
typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
typedef itk::VectorContainer< unsigned int,
GradientDirectionType > GradientDirectionContainerType;
GradientDirectionContainerType::Pointer directions =
GradientDirectionContainerType::New();
std::vector<double> b_vals;
double maxb = 0;
for(unsigned int i=0; i<hc.size(); i++)
{
double bv = hc[i]->bValue;
if(maxb<bv)
{
maxb = bv;
}
b_vals.push_back(bv);
}
for(unsigned int i=0; i<hc.size(); i++)
{
vnl_vector_fixed<double, 3> vect = hc[i]->DiffusionVector;
vect.normalize();
vect *= sqrt(b_vals[i]/maxb);
directions->push_back(vect);
}
// DWI TO DATATREE
PrintMemoryUsage();
Status(QString("Initializing Diffusion Image"));
if(m_OutputFolderNameSet) logfile << "Initializing Diffusion Image\n";
typedef mitk::DiffusionImage<PixelValueType> DiffVolumesType;
DiffVolumesType::Pointer diffImage = DiffVolumesType::New();
diffImage->SetDirections(directions);
diffImage->SetVectorImage(vecImage);
diffImage->SetB_Value(maxb);
diffImage->InitializeFromVectorImage();
diffImage->UpdateBValueList();
Status(QString("Diffusion Image initialized"));
if(m_OutputFolderNameSet) logfile << "Diffusion Image initialized\n";
if(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked())
{
PrintMemoryUsage();
Status(QString("Averaging gradient directions"));
logfile << "Averaging gradient directions\n";
diffImage->AverageRedundantGradients(m_Controls->m_Blur->value());
}
QString descr = QString("%1_%2_%3")
.arg(((inHeaders)[0])->seriesDescription.c_str())
.arg(((inHeaders)[0])->seriesNumber)
.arg(((inHeaders)[0])->patientName.c_str());
descr = descr.trimmed();
descr = descr.replace(" ", "_");
if(!m_OutputFolderNameSet)
{
node=mitk::DataNode::New();
node->SetData( diffImage );
GetDefaultDataStorage()->Add(node);
SetDwiNodeProperties(node, descr.toStdString().c_str());
Status(QString("Image %1 added to datastorage").arg(descr));
}
else
{
typedef mitk::NrrdDiffusionImageWriter<PixelValueType> WriterType;
WriterType::Pointer writer = WriterType::New();
QString fullpath = QString("%1/%2.dwi")
.arg(m_OutputFolderName)
.arg(descr);
// if the override option is not checked, we need to make sure that the current filepath
// does not point to an existing file
if( !(m_Controls->m_OverrideOptionCheckbox->isChecked()) )
{
QFile outputFile( fullpath );
// generate new filename if file exists
int file_counter = 0;
while( outputFile.exists() )
{
// copy base name
QString newdescr = descr;
file_counter++;
MITK_WARN << "The file "<< fullpath.toStdString() << " exists already.";
QString appendix = QString("_%1").arg( QString::number(file_counter) );
newdescr.append(appendix);
fullpath = QString("%1/%2.dwi")
.arg(m_OutputFolderName)
.arg(newdescr);
// set the new generated filename for next check
outputFile.setFileName( fullpath );
}
}
writer->SetFileName(fullpath.toStdString());
writer->SetInput(diffImage);
try
{
writer->Update();
}
catch (itk::ExceptionObject &ex)
{
imageSuccessfullySaved = false;
Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
logfile << 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()).toStdString() << "\n";
node=mitk::DataNode::New();
node->SetData( diffImage );
GetDefaultDataStorage()->Add(node);
SetDwiNodeProperties(node, descr.toStdString().c_str());
Status(QString("Image %1 added to datastorage").arg(descr));
logfile << "Image " << descr.toStdString() << " added to datastorage\n";
continue ;
}
Status(QString("Image %1 written to disc (%1)").arg(fullpath.toStdString().c_str()));
logfile << "Image " << fullpath.toStdString() << "\n";
}
}
else
{
Status(QString("No diffusion information found (%1)").arg(folderName));
if(m_OutputFolderNameSet) logfile << "No diffusion information found "<< folderName.toStdString();
}
Status(QString("Finished processing %1 with memory:").arg(folderName));
if(m_OutputFolderNameSet) logfile << "Finished processing " << folderName.toStdString() << "\n";
PrintMemoryUsage();
clock.Stop(folderName.toAscii());
mitk::ProgressBar::GetInstance()->Progress();
int lwidget = m_Controls->listWidget->count();
std::cout << lwidget <<std::endl;
logfile << "\n";
}
logfile.close();
Status("Timing information");
clock.Report();
if(!m_OutputFolderNameSet && node.IsNotNull())
{
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
- basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
try
{
MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
catch (itk::ExceptionObject &ex)
{
Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
return ;
}
if (!imageSuccessfullySaved)
QMessageBox::warning(NULL,"WARNING","One or more files could not be saved! The according files where moved to the datastorage.");
Status(QString("Finished import with memory:"));
PrintMemoryUsage();
}
void QmitkDiffusionDicomImport::SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name)
{
node->SetProperty( "IsDWIRawVolume", mitk::BoolProperty::New( true ) );
// set foldername as string property
mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
node->SetProperty( "name", nameProp );
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
index beca52cd6e..774d8968e3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
@@ -1,496 +1,496 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Qmitk
#include "QmitkDwiSoftwarePhantomView.h"
// MITK
#include <mitkDiffusionImage.h>
#include <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<ItkUcharImgType>(mitkBinaryImg, signalRegion);
m_SignalRegions.push_back(signalRegion);
}
gradientList = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
// switch(m_Controls->m_NumGradientsBox->value())
// {
// case 0:
// gradientList = MakeGradientList<12>();
// break;
// case 1:
// gradientList = MakeGradientList<42>();
// break;
// case 2:
// gradientList = MakeGradientList<92>();
// break;
// case 3:
// gradientList = MakeGradientList<162>();
// break;
// case 4:
// gradientList = MakeGradientList<252>();
// break;
// case 5:
// gradientList = MakeGradientList<362>();
// break;
// case 6:
// gradientList = MakeGradientList<492>();
// break;
// case 7:
// gradientList = MakeGradientList<642>();
// break;
// case 8:
// gradientList = MakeGradientList<812>();
// break;
// case 9:
// gradientList = MakeGradientList<1002>();
// break;
// default:
// gradientList = MakeGradientList<92>();
// }
double bVal = m_Controls->m_TensorsToDWIBValueEdit->value();
itk::ImageRegion<3> imageRegion;
imageRegion.SetSize(0, m_Controls->m_SizeX->value());
imageRegion.SetSize(1, m_Controls->m_SizeY->value());
imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
mitk::Vector3D spacing;
spacing[0] = m_Controls->m_SpacingX->value();
spacing[1] = m_Controls->m_SpacingY->value();
spacing[2] = m_Controls->m_SpacingZ->value();
FilterType::Pointer filter = FilterType::New();
filter->SetGradientList(gradientList);
filter->SetBValue(bVal);
filter->SetNoiseVariance(m_Controls->m_NoiseLevel->value());
filter->SetImageRegion(imageRegion);
filter->SetSpacing(spacing);
filter->SetSignalRegions(m_SignalRegions);
filter->SetGreyMatterAdc(m_Controls->m_GmAdc->value());
std::vector< float > tensorFA;
std::vector< float > tensorADC;
std::vector< float > tensorWeight;
std::vector< vnl_vector_fixed<double, 3> > tensorDirection;
for (int i=0; i<m_SpinFa.size(); i++)
{
tensorFA.push_back(m_SpinFa.at(i)->value());
tensorADC.push_back(m_SpinAdc.at(i)->value());
vnl_vector_fixed<double, 3> dir;
dir[0] = m_SpinX.at(i)->value();
dir[1] = m_SpinY.at(i)->value();
dir[2] = m_SpinZ.at(i)->value();
dir.normalize();
tensorDirection.push_back(dir);
tensorWeight.push_back(m_SpinWeight.at(i)->value());
}
filter->SetTensorFA(tensorFA);
filter->SetTensorADC(tensorADC);
filter->SetTensorWeight(tensorWeight);
filter->SetTensorDirection(tensorDirection);
if (!m_Controls->m_SimulateBaseline->isChecked())
filter->SetSimulateBaseline(false);
else
filter->SetSimulateBaseline(true);
filter->Update();
mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
image->SetVectorImage( filter->GetOutput() );
image->SetB_Value(bVal);
image->SetDirections(gradientList);
image->InitializeFromVectorImage();
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->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ 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::Geometry3D::Pointer geometry = image->GetGeometry();
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
directions->SetGeometry(geometry);
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(directions);
QString name(m_Controls->m_ImageName->text());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkDwiSoftwarePhantomView::UpdateGui()
{
if (!m_SignalRegionNodes.empty())
{
m_Controls->m_SignalRegionBox->setVisible(true);
m_Controls->m_Instruction->setVisible(false);
}
else
{
m_Controls->m_SignalRegionBox->setVisible(false);
m_Controls->m_Instruction->setVisible(true);
}
QLayout* layout = m_Controls->m_SignalRegionBox->layout();
for (int i=0; i<m_Labels.size(); i++)
{
delete m_Labels.at(i);
}
for (int i=0; i<m_SpinFa.size(); i++)
{
delete m_SpinFa.at(i);
delete m_SpinAdc.at(i);
delete m_SpinX.at(i);
delete m_SpinY.at(i);
delete m_SpinZ.at(i);
delete m_SpinWeight.at(i);
}
m_Labels.clear();
m_SpinFa.clear();
m_SpinAdc.clear();
m_SpinX.clear();
m_SpinY.clear();
m_SpinZ.clear();
m_SpinWeight.clear();
if (layout)
delete layout;
QGridLayout* newlayout = new QGridLayout();
m_Controls->m_SignalRegionBox->setLayout(newlayout);
if (!m_SignalRegionNodes.empty())
{
QLabel* label1 = new QLabel("Image");
newlayout->addWidget(label1,0,0);
m_Labels.push_back(label1);
QLabel* label2 = new QLabel("FA");
newlayout->addWidget(label2,0,1);
m_Labels.push_back(label2);
QLabel* label3 = new QLabel("ADC");
newlayout->addWidget(label3,0,2);
m_Labels.push_back(label3);
QLabel* label4 = new QLabel("X");
newlayout->addWidget(label4,0,03);
m_Labels.push_back(label4);
QLabel* label5 = new QLabel("Y");
newlayout->addWidget(label5,0,4);
m_Labels.push_back(label5);
QLabel* label6 = new QLabel("Z");
newlayout->addWidget(label6,0,5);
m_Labels.push_back(label6);
QLabel* label7 = new QLabel("Weight");
newlayout->addWidget(label7,0,6);
m_Labels.push_back(label7);
}
for (int i=0; i<m_SignalRegionNodes.size(); i++)
{
QLabel* label = new QLabel(m_SignalRegionNodes.at(i)->GetName().c_str());
newlayout->addWidget(label,i+1,0);
m_Labels.push_back(label);
QDoubleSpinBox* spinFa = new QDoubleSpinBox();
spinFa->setValue(0.7);
spinFa->setMinimum(0);
spinFa->setMaximum(1);
spinFa->setSingleStep(0.1);
newlayout->addWidget(spinFa,i+1,1);
m_SpinFa.push_back(spinFa);
QDoubleSpinBox* spinAdc = new QDoubleSpinBox();
newlayout->addWidget(spinAdc,i+1,2);
spinAdc->setMinimum(0);
spinAdc->setMaximum(1);
spinAdc->setSingleStep(0.001);
spinAdc->setDecimals(3);
spinAdc->setValue(0.001); ///// ???????????????????????????
m_SpinAdc.push_back(spinAdc);
QDoubleSpinBox* spinX = new QDoubleSpinBox();
newlayout->addWidget(spinX,i+1,3);
spinX->setValue(1);
spinX->setMinimum(-1);
spinX->setMaximum(1);
spinX->setSingleStep(0.1);
m_SpinX.push_back(spinX);
QDoubleSpinBox* spinY = new QDoubleSpinBox();
newlayout->addWidget(spinY,i+1,4);
spinY->setMinimum(-1);
spinY->setMaximum(1);
spinY->setSingleStep(0.1);
m_SpinY.push_back(spinY);
QDoubleSpinBox* spinZ = new QDoubleSpinBox();
newlayout->addWidget(spinZ,i+1,5);
spinZ->setMinimum(-1);
spinZ->setMaximum(1);
spinZ->setSingleStep(0.1);
m_SpinZ.push_back(spinZ);
QDoubleSpinBox* spinWeight = new QDoubleSpinBox();
newlayout->addWidget(spinWeight,i+1,6);
spinWeight->setMinimum(0);
spinWeight->setMaximum(1);
spinWeight->setSingleStep(0.1);
spinWeight->setValue(1.0);
m_SpinWeight.push_back(spinWeight);
}
}
void QmitkDwiSoftwarePhantomView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkDwiSoftwarePhantomView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkDwiSoftwarePhantomView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
m_SignalRegionNodes.clear();
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
m_SignalRegionNodes.push_back(node);
}
}
UpdateGui();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
index 07ec5fdecd..0a42c8e3e5 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
@@ -1,1810 +1,1810 @@
/*===================================================================
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 timeSlicedGeometry is null to invoke rendering mechansims ====
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.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
(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);
}
/* 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
(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
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_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::DataNode::Pointer FBNode;
FBNode = mitk::DataNode::New();
FBNode->SetName("FiberBundleX");
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::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
+ 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_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_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";
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_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();
//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);
//highlight current colorcoding
QString cc = m_FiberBundleX->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
// 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 */
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_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() );
QString numOfPoints;
numOfPoints.setNum( m_FiberBundleX->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) {
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() )
{
//show fiber extraction button
m_Controls->buttonExtractFibers->setEnabled(true);
} else {
m_Controls->buttonExtractFibers->setEnabled(false);
}
if (m_FiberBundleX.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
//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();
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::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
+ 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
* - visualization of analysed fiberbundle
*/
m_FiberBundleNode = NULL;
m_FiberBundleX = 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()) )
{
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_FiberBundleNode = NULL;
}
// ==== FIBERBUNDLE_INFO ELEMENTS ====
if ( m_Controls->page_FiberInfo->isVisible() )
FeedFiberInfoWidget();
// enable FiberBundleX 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->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
}
}
}
void QmitkFiberBundleDeveloperView::Activated()
{
MITK_INFO << "FB DevelopersV ACTIVATED()";
}
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 23b8a8c7ab..f49ec407b3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,1594 +1,1594 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//misc
#define _USE_MATH_DEFINES
#include <math.h>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberfoxView.h"
// MITK
#include <mitkImage.h>
#include <mitkDiffusionImage.h>
#include <mitkImageToItk.h>
#include <itkDwiPhantomGenerationFilter.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 <mitkTensorModel.h>
#include <mitkBallModel.h>
#include <mitkStickModel.h>
#include <mitkAstroStickModel.h>
#include <mitkDotModel.h>
#include <mitkRicianNoiseModel.h>
#include <mitkGibbsRingingArtifact.h>
#include <mitkSignalDecay.h>
#include <itkScalableAffineTransform.h>
#include <mitkLevelWindowProperty.h>
#include <QMessageBox>
#define _USE_MATH_DEFINES
#include <math.h>
const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
QmitkFiberfoxView::QmitkFiberfoxView()
: QmitkAbstractView()
, m_Controls( 0 )
, m_SelectedImage( NULL )
{
}
// Destructor
QmitkFiberfoxView::~QmitkFiberfoxView()
{
}
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 );
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_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_KspaceParamFrame->setVisible(false);
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(int)), (QObject*) this, SLOT(OnFiberSamplingChanged(int)));
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_AddGibbsRinging, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGibbsRinging(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)));
}
}
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);
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;
}
}
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);
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;
}
}
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_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;
}
}
void QmitkFiberfoxView::OnConstantRadius(int value)
{
if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnAddGibbsRinging(int value)
{
if (value>0)
m_Controls->m_KspaceParamFrame->setVisible(true);
else
m_Controls->m_KspaceParamFrame->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 value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFiberDensityChanged(int value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFiberSamplingChanged(int value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnTensionChanged(double value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnContinuityChanged(double value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnBiasChanged(double value)
{
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::AlignOnGrid()
{
for (int i=0; i<m_SelectedFiducials.size(); i++)
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
{
mitk::DataNode::Pointer pFibNode = *it;
if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
{
mitk::DataNode::Pointer pImgNode = *it2;
if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
mitk::Geometry3D::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( 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::Geometry3D::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( int i=0; i<m_SelectedImages.size(); i++ )
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
{
mitk::DataNode::Pointer fibNode = *it;
if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
mitk::Geometry3D::Pointer geom = img->GetGeometry();
itk::Index<3> idx;
geom->WorldToIndex(wc0, idx);
mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
mitk::Point3D world;
geom->IndexToWorld(cIdx,world);
mitk::Vector3D trans = world - wc0;
pe->GetGeometry()->Translate(trans);
}
}
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::OnFlipButton()
{
if (m_SelectedFiducial.IsNull())
return;
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
if( it != m_DataNodeToPlanarFigureData.end() )
{
QmitkPlanarFigureData& data = it->second;
data.m_Flipped += 1;
data.m_Flipped %= 2;
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
{
NPoints *= 2;
GradientListType pointshell;
int numB0 = NPoints/20;
if (numB0==0)
numB0=1;
GradientType g;
g.Fill(0.0);
for (int i=0; i<numB0; i++)
pointshell.push_back(g);
if (NPoints==0)
return pointshell;
vnl_vector<double> theta; theta.set_size(NPoints);
vnl_vector<double> phi; phi.set_size(NPoints);
double C = sqrt(4*M_PI);
phi(0) = 0.0;
phi(NPoints-1) = 0.0;
for(int i=0; i<NPoints; i++)
{
theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
if( i>0 && i<NPoints-1)
{
phi(i) = (phi(i-1) + C /
sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
// % (2*DIST_POINTSHELL_PI);
}
}
for(int i=0; i<NPoints; i++)
{
g[2] = sin(theta(i));
if (g[2]<0)
continue;
g[0] = cos(theta(i)) * cos(phi(i));
g[1] = cos(theta(i)) * sin(phi(i));
pointshell.push_back(g);
}
return pointshell;
}
template<int ndirs>
std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
{
std::vector<itk::Vector<double,3> > retval;
vnl_matrix_fixed<double, 3, ndirs>* U =
itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
// Add 0 vector for B0
int numB0 = ndirs/10;
if (numB0==0)
numB0=1;
itk::Vector<double,3> v;
v.Fill(0.0);
for (int i=0; i<numB0; i++)
{
retval.push_back(v);
}
for(int i=0; i<ndirs;i++)
{
itk::Vector<double,3> v;
v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
retval.push_back(v);
}
return retval;
}
void QmitkFiberfoxView::OnAddBundle()
{
if (m_SelectedImage.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( bundle );
QString name = QString("Bundle_%1").arg(children->size());
node->SetName(name.toStdString());
m_SelectedBundles.push_back(node);
UpdateGui();
GetDataStorage()->Add(node, m_SelectedImage);
}
void QmitkFiberfoxView::OnDrawROI()
{
if (m_SelectedBundles.empty())
OnAddBundle();
if (m_SelectedBundles.empty())
return;
mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( figure );
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);
GetDataStorage()->Add(node, m_SelectedBundles.at(0));
this->DisableCrosshairNavigation();
mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
UpdateGui();
}
bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
{
int li = -1;
i->GetPropertyValue("layer", li);
int lj = -1;
j->GetPropertyValue("layer", lj);
return li<lj;
}
void QmitkFiberfoxView::GenerateFibers()
{
if (m_SelectedBundles.empty())
{
if (m_SelectedFiducial.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
m_SelectedBundles.push_back(*it);
if (m_SelectedBundles.empty())
return;
}
vector< vector< mitk::PlanarEllipse::Pointer > > fiducials;
vector< vector< unsigned int > > fliplist;
for (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);
}
else
{
v.Normalize();
v *= radius;
ellipse->SetControlPoint(1, c+v);
}
}
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)
{
fiducials.push_back(fib);
fliplist.push_back(flip);
}
else if (fib.size()>0)
m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
filter->SetFiducials(fiducials);
filter->SetFlipList(fliplist);
switch(m_Controls->m_DistributionBox->currentIndex()){
case 0:
filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_UNIFORM);
break;
case 1:
filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_GAUSSIAN);
filter->SetVariance(m_Controls->m_VarianceBox->value());
break;
}
filter->SetDensity(m_Controls->m_FiberDensityBox->value());
filter->SetTension(m_Controls->m_TensionBox->value());
filter->SetContinuity(m_Controls->m_ContinuityBox->value());
filter->SetBias(m_Controls->m_BiasBox->value());
filter->SetFiberSampling(m_Controls->m_FiberSamplingBox->value());
filter->Update();
vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
for (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()
{
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();
mitk::Point3D origin;
origin[0] = spacing[0]/2;
origin[1] = spacing[1]/2;
origin[2] = spacing[2]/2;
itk::Matrix<double, 3, 3> directionMatrix; directionMatrix.SetIdentity();
if (m_SelectedBundles.empty())
{
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::Geometry3D* geom = image->GetGeometry();
geom->SetOrigin(origin);
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->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
UpdateGui();
return;
}
if (m_SelectedImage.IsNotNull())
{
mitk::Image* img = dynamic_cast<mitk::Image*>(m_SelectedImage->GetData());
itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
imageRegion = itkImg->GetLargestPossibleRegion();
spacing = itkImg->GetSpacing();
origin = itkImg->GetOrigin();
directionMatrix = itkImg->GetDirection();
}
DiffusionSignalModel<double>::GradientListType gradientList;
double bVal = 1000;
if (m_SelectedDWI.IsNull())
{
gradientList = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());;
bVal = m_Controls->m_BvalueBox->value();
}
else
{
mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedDWI->GetData());
imageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
spacing = dwi->GetVectorImage()->GetSpacing();
origin = dwi->GetVectorImage()->GetOrigin();
directionMatrix = dwi->GetVectorImage()->GetDirection();
bVal = dwi->GetB_Value();
mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = dwi->GetDirections();
for (int i=0; i<dirs->Size(); i++)
{
DiffusionSignalModel<double>::GradientType g;
g[0] = dirs->at(i)[0];
g[1] = dirs->at(i)[1];
g[2] = dirs->at(i)[2];
gradientList.push_back(g);
}
}
for (int i=0; i<m_SelectedBundles.size(); i++)
{
// storage for generated phantom image
mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
QString signalModelString("");
itk::TractsToDWIImageFilter::DiffusionModelList fiberModelList, nonFiberModelList;
// signal models
double comp3Weight = 1;
double comp4Weight = 0;
if (m_Controls->m_Compartment4Box->currentIndex()>0)
{
comp4Weight = m_Controls->m_Comp4FractionBox->value();
comp3Weight -= comp4Weight;
}
mitk::StickModel<double> stickModel1;
mitk::StickModel<double> stickModel2;
mitk::TensorModel<double> zeppelinModel1;
mitk::TensorModel<double> zeppelinModel2;
mitk::TensorModel<double> tensorModel1;
mitk::TensorModel<double> tensorModel2;
mitk::BallModel<double> ballModel1;
mitk::BallModel<double> ballModel2;
mitk::AstroStickModel<double> astrosticksModel1;
mitk::AstroStickModel<double> astrosticksModel2;
mitk::DotModel<double> dotModel1;
mitk::DotModel<double> dotModel2;
// compartment 1
switch (m_Controls->m_Compartment1Box->currentIndex())
{
case 0:
MITK_INFO << "Using stick model";
stickModel1.SetGradientList(gradientList);
stickModel1.SetDiffusivity(m_Controls->m_StickWidget1->GetD());
stickModel1.SetT2(m_Controls->m_StickWidget1->GetT2());
fiberModelList.push_back(&stickModel1);
signalModelString += "Stick";
resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
resultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(stickModel1.GetT2()) );
break;
case 1:
MITK_INFO << "Using zeppelin model";
zeppelinModel1.SetGradientList(gradientList);
zeppelinModel1.SetBvalue(bVal);
zeppelinModel1.SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
zeppelinModel1.SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
zeppelinModel1.SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
zeppelinModel1.SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
fiberModelList.push_back(&zeppelinModel1);
signalModelString += "Zeppelin";
resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(zeppelinModel1.GetT2()) );
break;
case 2:
MITK_INFO << "Using tensor model";
tensorModel1.SetGradientList(gradientList);
tensorModel1.SetBvalue(bVal);
tensorModel1.SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
tensorModel1.SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
tensorModel1.SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
tensorModel1.SetT2(m_Controls->m_TensorWidget1->GetT2());
fiberModelList.push_back(&tensorModel1);
signalModelString += "Tensor";
resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(zeppelinModel1.GetT2()) );
break;
}
// compartment 2
switch (m_Controls->m_Compartment2Box->currentIndex())
{
case 0:
break;
case 1:
stickModel2.SetGradientList(gradientList);
stickModel2.SetDiffusivity(m_Controls->m_StickWidget2->GetD());
stickModel2.SetT2(m_Controls->m_StickWidget2->GetT2());
fiberModelList.push_back(&stickModel2);
signalModelString += "Stick";
resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
resultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(stickModel2.GetT2()) );
break;
case 2:
zeppelinModel2.SetGradientList(gradientList);
zeppelinModel2.SetBvalue(bVal);
zeppelinModel2.SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
zeppelinModel2.SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
zeppelinModel2.SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
zeppelinModel2.SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
fiberModelList.push_back(&zeppelinModel2);
signalModelString += "Zeppelin";
resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(zeppelinModel2.GetT2()) );
break;
case 3:
tensorModel2.SetGradientList(gradientList);
tensorModel2.SetBvalue(bVal);
tensorModel2.SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
tensorModel2.SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
tensorModel2.SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
tensorModel2.SetT2(m_Controls->m_TensorWidget2->GetT2());
fiberModelList.push_back(&tensorModel2);
signalModelString += "Tensor";
resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
resultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(zeppelinModel2.GetT2()) );
break;
}
// compartment 3
switch (m_Controls->m_Compartment3Box->currentIndex())
{
case 0:
ballModel1.SetGradientList(gradientList);
ballModel1.SetBvalue(bVal);
ballModel1.SetDiffusivity(m_Controls->m_BallWidget1->GetD());
ballModel1.SetT2(m_Controls->m_BallWidget1->GetT2());
ballModel1.SetWeight(comp3Weight);
nonFiberModelList.push_back(&ballModel1);
signalModelString += "Ball";
resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(ballModel1.GetT2()) );
break;
case 1:
astrosticksModel1.SetGradientList(gradientList);
astrosticksModel1.SetBvalue(bVal);
astrosticksModel1.SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
astrosticksModel1.SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
astrosticksModel1.SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
astrosticksModel1.SetWeight(comp3Weight);
nonFiberModelList.push_back(&astrosticksModel1);
signalModelString += "Astrosticks";
resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(astrosticksModel1.GetT2()) );
resultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
break;
case 2:
dotModel1.SetGradientList(gradientList);
dotModel1.SetT2(m_Controls->m_DotWidget1->GetT2());
dotModel1.SetWeight(comp3Weight);
nonFiberModelList.push_back(&dotModel1);
signalModelString += "Dot";
resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(dotModel1.GetT2()) );
break;
}
// compartment 4
switch (m_Controls->m_Compartment4Box->currentIndex())
{
case 0:
break;
case 1:
ballModel2.SetGradientList(gradientList);
ballModel2.SetBvalue(bVal);
ballModel2.SetDiffusivity(m_Controls->m_BallWidget2->GetD());
ballModel2.SetT2(m_Controls->m_BallWidget2->GetT2());
ballModel2.SetWeight(comp4Weight);
nonFiberModelList.push_back(&ballModel2);
signalModelString += "Ball";
resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(ballModel2.GetT2()) );
break;
case 2:
astrosticksModel2.SetGradientList(gradientList);
astrosticksModel2.SetBvalue(bVal);
astrosticksModel2.SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
astrosticksModel2.SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
astrosticksModel2.SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
astrosticksModel2.SetWeight(comp4Weight);
nonFiberModelList.push_back(&astrosticksModel2);
signalModelString += "Astrosticks";
resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(astrosticksModel2.GetT2()) );
resultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
break;
case 3:
dotModel2.SetGradientList(gradientList);
dotModel2.SetT2(m_Controls->m_DotWidget2->GetT2());
dotModel2.SetWeight(comp4Weight);
nonFiberModelList.push_back(&dotModel2);
signalModelString += "Dot";
resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(dotModel2.GetT2()) );
break;
}
itk::TractsToDWIImageFilter::KspaceArtifactList artifactList;
// noise model
double noiseVariance = m_Controls->m_NoiseLevel->value();
mitk::RicianNoiseModel<double> noiseModel;
noiseModel.SetNoiseVariance(noiseVariance);
// artifact models
QString artifactModelString("");
mitk::GibbsRingingArtifact<double> gibbsModel;
if (m_Controls->m_AddGibbsRinging->isChecked())
{
artifactModelString += "_Gibbs-ringing";
resultNode->AddProperty("Fiberfox.k-Space-Undersampling", IntProperty::New(m_Controls->m_KspaceUndersamplingBox->currentText().toInt()));
gibbsModel.SetKspaceCropping((double)m_Controls->m_KspaceUndersamplingBox->currentText().toInt());
artifactList.push_back(&gibbsModel);
}
if ( this->m_Controls->m_TEbox->value() < imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() )
{
this->m_Controls->m_TEbox->setValue( imageRegion.GetSize(1)*m_Controls->m_LineReadoutTimeBox->value() );
QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(this->m_Controls->m_TEbox->value())+" ms");
}
double lineReadoutTime = m_Controls->m_LineReadoutTimeBox->value();
// adjusting line readout time to the adapted image size needed for the FFT
int y=2;
while (y<imageRegion.GetSize(1))
y *= 2;
if (y>imageRegion.GetSize(1))
lineReadoutTime *= (double)imageRegion.GetSize(1)/y;
mitk::SignalDecay<double> contrastModel;
contrastModel.SetTinhom(this->m_Controls->m_T2starBox->value());
contrastModel.SetTE(this->m_Controls->m_TEbox->value());
contrastModel.SetTline(lineReadoutTime);
artifactList.push_back(&contrastModel);
mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedBundles.at(i)->GetData());
if (fiberBundle->GetNumFibers()<=0)
continue;
itk::TractsToDWIImageFilter::Pointer filter = itk::TractsToDWIImageFilter::New();
filter->SetImageRegion(imageRegion);
filter->SetSpacing(spacing);
filter->SetOrigin(origin);
filter->SetDirectionMatrix(directionMatrix);
filter->SetFiberBundle(fiberBundle);
filter->SetFiberModels(fiberModelList);
filter->SetNonFiberModels(nonFiberModelList);
filter->SetNoiseModel(&noiseModel);
filter->SetKspaceArtifacts(artifactList);
filter->SetNumberOfRepetitions(m_Controls->m_RepetitionsBox->value());
filter->SetEnforcePureFiberVoxels(m_Controls->m_EnforcePureFiberVoxelsBox->isChecked());
filter->SetInterpolationShrink(m_Controls->m_InterpolationShrink->value());
filter->SetFiberRadius(m_Controls->m_FiberRadius->value());
filter->SetSignalScale(m_Controls->m_SignalScaleBox->value());
if (m_TissueMask.IsNotNull())
{
ItkUcharImgType::Pointer mask = ItkUcharImgType::New();
mitk::CastToItkImage<ItkUcharImgType>(m_TissueMask, mask);
filter->SetTissueMask(mask);
}
filter->Update();
mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
image->SetVectorImage( filter->GetOutput() );
image->SetB_Value(bVal);
image->SetDirections(gradientList);
image->InitializeFromVectorImage();
resultNode->SetData( image );
resultNode->SetName(m_SelectedBundles.at(i)->GetName()
+"_D"+QString::number(imageRegion.GetSize(0)).toStdString()
+"-"+QString::number(imageRegion.GetSize(1)).toStdString()
+"-"+QString::number(imageRegion.GetSize(2)).toStdString()
+"_S"+QString::number(spacing[0]).toStdString()
+"-"+QString::number(spacing[1]).toStdString()
+"-"+QString::number(spacing[2]).toStdString()
+"_b"+QString::number(bVal).toStdString()
+"_NOISE"+QString::number(noiseVariance).toStdString()
+"_"+signalModelString.toStdString()
+artifactModelString.toStdString());
GetDataStorage()->Add(resultNode, m_SelectedBundles.at(i));
resultNode->AddProperty("Fiberfox.InterpolationShrink", IntProperty::New(m_Controls->m_InterpolationShrink->value()));
resultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(m_Controls->m_SignalScaleBox->value()));
resultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(m_Controls->m_FiberRadius->value()));
resultNode->AddProperty("Fiberfox.Tinhom", IntProperty::New(m_Controls->m_T2starBox->value()));
resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
resultNode->AddProperty("Fiberfox.Repetitions", IntProperty::New(m_Controls->m_RepetitionsBox->value()));
resultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(bVal));
resultNode->AddProperty("Fiberfox.Model", StringProperty::New(signalModelString.toStdString()));
resultNode->AddProperty("Fiberfox.PureFiberVoxels", BoolProperty::New(m_Controls->m_EnforcePureFiberVoxelsBox->isChecked()));
resultNode->AddProperty("binary", BoolProperty::New(false));
resultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(filter->GetLevelWindow()) );
if (m_Controls->m_KspaceImageBox->isChecked())
{
itk::Image<double, 3>::Pointer kspace = filter->GetKspaceImage();
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk(kspace.GetPointer());
image->SetVolume(kspace->GetBufferPointer());
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( image );
node->SetName(m_SelectedBundles.at(i)->GetName()+"_k-space");
GetDataStorage()->Add(node, m_SelectedBundles.at(i));
}
mitk::BaseData::Pointer basedata = resultNode->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
- basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkFiberfoxView::ApplyTransform()
{
vector< mitk::DataNode::Pointer > selectedBundles;
for( int i=0; i<m_SelectedImages.size(); i++ )
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
{
mitk::DataNode::Pointer fibNode = *it;
if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
selectedBundles.push_back(fibNode);
}
}
if (selectedBundles.empty())
selectedBundles = m_SelectedBundles2;
if (!selectedBundles.empty())
{
std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin();
for (it; it!=selectedBundles.end(); ++it)
{
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
// handle child fiducials
if (m_Controls->m_IncludeFiducials->isChecked())
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
mitk::Geometry3D* 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< float, 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< float, 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< float, 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< float, 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);
}
}
}
}
}
else
{
for (int i=0; i<m_SelectedFiducials.size(); i++)
{
mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
mitk::Geometry3D* 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< float, 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< float, 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< float, 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< float, 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());
}
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("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
return;
}
std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
for (it; it!=m_SelectedBundles.end(); ++it)
{
// find parent image
mitk::DataNode::Pointer parentNode;
mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
{
mitk::DataNode::Pointer pImgNode = *it2;
if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
{
parentNode = pImgNode;
break;
}
}
mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
QString name((*it)->GetName().c_str());
name += "_copy";
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
if (parentNode.IsNotNull())
GetDataStorage()->Add(fbNode, parentNode);
else
GetDataStorage()->Add(fbNode);
// copy child fiducials
if (m_Controls->m_IncludeFiducials->isChecked())
{
mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
{
mitk::DataNode::Pointer fiducialNode = *it2;
if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
{
mitk::PlanarEllipse::Pointer pe = mitk::PlanarEllipse::New();
pe->DeepCopy(dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()));
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData(pe);
newNode->SetName(fiducialNode->GetName());
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("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
return;
}
std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
QString name("");
name += QString((*it)->GetName().c_str());
++it;
for (it; it!=m_SelectedBundles.end(); ++it)
{
newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
name += "+"+QString((*it)->GetName().c_str());
}
mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
fbNode->SetData(newBundle);
fbNode->SetName(name.toStdString());
fbNode->SetVisibility(true);
GetDataStorage()->Add(fbNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkFiberfoxView::UpdateGui()
{
m_Controls->m_FiberBundleLabel->setText("<font color='red'>mandatory</font>");
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);
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_TransformBundlesButton->setEnabled(true);
m_Controls->m_CircleButton->setEnabled(true);
m_Controls->m_FiberGenMessage->setVisible(false);
m_Controls->m_AlignOnGrid->setEnabled(true);
}
if (m_TissueMask.IsNotNull() || m_SelectedImage.IsNotNull())
{
m_Controls->m_GeometryMessage->setVisible(true);
m_Controls->m_GeometryFrame->setEnabled(false);
}
if (m_SelectedDWI.IsNotNull())
{
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);
}
if (!m_SelectedBundles.empty())
{
m_Controls->m_CopyBundlesButton->setEnabled(true);
m_Controls->m_GenerateFibersButton->setEnabled(true);
m_Controls->m_FiberBundleLabel->setText(m_SelectedBundles.at(0)->GetName().c_str());
if (m_SelectedBundles.size()>1)
m_Controls->m_JoinBundlesButton->setEnabled(true);
}
}
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_TissueMask = NULL;
m_SelectedBundles.clear();
m_SelectedImage = NULL;
m_SelectedDWI = NULL;
m_Controls->m_TissueMaskLabel->setText("<font color='grey'>optional</font>");
// iterate all selected objects, adjust warning visibility
for( int i=0; i<nodes.size(); i++)
{
mitk::DataNode::Pointer node = nodes.at(i);
if ( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
{
m_SelectedDWI = node;
m_SelectedImage = node;
m_SelectedImages.push_back(node);
}
else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
m_SelectedImages.push_back(node);
m_SelectedImage = node;
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_TissueMask = dynamic_cast<mitk::Image*>(node->GetData());
m_Controls->m_TissueMaskLabel->setText(node->GetName().c_str());
}
}
else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
m_SelectedBundles2.push_back(node);
if (m_Controls->m_RealTimeFibers->isChecked())
{
m_SelectedBundles.push_back(node);
mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
GenerateFibers();
}
else
m_SelectedBundles.push_back(node);
}
else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
{
m_SelectedFiducials.push_back(node);
m_SelectedFiducial = node;
m_SelectedBundles.clear();
mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
{
mitk::DataNode::Pointer pNode = *it;
if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
m_SelectedBundles.push_back(pNode);
}
}
}
UpdateGui();
}
void QmitkFiberfoxView::EnableCrosshairNavigation()
{
MITK_DEBUG << "EnableCrosshairNavigation";
// enable the crosshair navigation
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MITK_DEBUG << "enabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(true);
// linkedRenderWindow->EnableSlicingPlanes(true);
}
if (m_Controls->m_RealTimeFibers->isChecked())
GenerateFibers();
}
void QmitkFiberfoxView::DisableCrosshairNavigation()
{
MITK_DEBUG << "DisableCrosshairNavigation";
// disable the crosshair navigation during the drawing
if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
MITK_DEBUG << "disabling linked navigation";
linkedRenderWindow->EnableLinkedNavigation(false);
// linkedRenderWindow->EnableSlicingPlanes(false);
}
}
void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
{
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
if( 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->GetInteractor());
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
if(figureInteractor.IsNull())
{
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
}
else
{
// just to be sure that the interactor is not added twice
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
}
MITK_DEBUG << "adding interactor to globalinteraction";
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
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();
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
index 6ecdb77b95..737b6dd2df 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
@@ -1,815 +1,815 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkIVIMView.h"
#include "QmitkStdMultiWidget.h"
// qt
#include "qmessagebox.h"
#include "qclipboard.h"
// mitk
#include "mitkDiffusionImage.h"
#include "mitkImageCast.h"
// itk
#include "itkScalarImageToHistogramGenerator.h"
#include "itkRegionOfInterestImageFilter.h"
#include "itkImageRegionConstIteratorWithIndex.h"
// itk/mitk
#include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
#include "itkRegularizedIVIMReconstructionFilter.h"
#include "mitkImageCast.h"
const std::string QmitkIVIMView::VIEW_ID = "org.mitk.views.ivim";
QmitkIVIMView::QmitkIVIMView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_Active(false)
, m_SliceObserverTag1(0), m_SliceObserverTag2(0), m_SliceObserverTag3(0)
, m_DiffusionImageNode(NULL)
, m_MaskImageNode(NULL)
{
}
QmitkIVIMView::~QmitkIVIMView()
{
// QmitkStdMultiWidget* MultiWidget = this->GetActiveStdMultiWidget(false);
// if(MultiWidget)
// {
// //unregister observers when view is destroyed
// if( MultiWidget->mitkWidget1 != NULL && m_SliceObserverTag1 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget1->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag1 );
// }
// if( MultiWidget->mitkWidget2 != NULL && m_SliceObserverTag2 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget2->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag2 );
// }
// if( MultiWidget->mitkWidget3!= NULL && m_SliceObserverTag3 != 0)
// {
// mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget3->GetSliceNavigationController();
// slicer->RemoveObserver( m_SliceObserverTag3 );
// }
// }
}
void QmitkIVIMView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkIVIMViewControls;
m_Controls->setupUi( parent );
connect( m_Controls->m_ButtonStart, SIGNAL(clicked()), this, SLOT(FittIVIMStart()) );
connect( m_Controls->m_ButtonAutoThres, SIGNAL(clicked()), this, SLOT(AutoThreshold()) );
connect( m_Controls->m_MethodCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(MethodCombo(int)) );
connect( m_Controls->m_DStarSlider, SIGNAL(valueChanged(int)), this, SLOT(DStarSlider(int)) );
connect( m_Controls->m_BThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(BThreshSlider(int)) );
connect( m_Controls->m_S0ThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(S0ThreshSlider(int)) );
connect( m_Controls->m_NumItSlider, SIGNAL(valueChanged(int)), this, SLOT(NumItsSlider(int)) );
connect( m_Controls->m_LambdaSlider, SIGNAL(valueChanged(int)), this, SLOT(LambdaSlider(int)) );
connect( m_Controls->m_CheckDStar, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_CheckD, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_Checkf, SIGNAL(clicked()), this, SLOT(Checkbox()) );
connect( m_Controls->m_ChooseMethod, SIGNAL(clicked()), this, SLOT(ChooseMethod()) );
connect( m_Controls->m_CurveClipboard, SIGNAL(clicked()), this, SLOT(ClipboardCurveButtonClicked()) );
connect( m_Controls->m_ValuesClipboard, SIGNAL(clicked()), this, SLOT(ClipboardStatisticsButtonClicked()) );
}
QString dstar = QString::number(m_Controls->m_DStarSlider->value()/1000.0);
m_Controls->m_DStarLabel->setText(dstar);
QString bthresh = QString::number(m_Controls->m_BThreshSlider->value()*5.0);
m_Controls->m_BThreshLabel->setText(bthresh);
QString s0thresh = QString::number(m_Controls->m_S0ThreshSlider->value()*0.5);
m_Controls->m_S0ThreshLabel->setText(s0thresh);
QString numits = QString::number(m_Controls->m_NumItSlider->value());
m_Controls->m_NumItsLabel->setText(numits);
QString lambda = QString::number(m_Controls->m_LambdaSlider->value()*.00001);
m_Controls->m_LambdaLabel->setText(lambda);
m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
m_Controls->m_Warning->setVisible(false);
MethodCombo(m_Controls->m_MethodCombo->currentIndex());
}
void QmitkIVIMView::Checkbox()
{
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::MethodCombo(int val)
{
switch(val)
{
case 0:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 1:
m_Controls->m_DstarFrame->setVisible(true);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 2:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(true);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 3:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(true);
m_Controls->m_NeglBframe->setVisible(true);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
case 4:
m_Controls->m_DstarFrame->setVisible(false);
m_Controls->m_NeglSiFrame->setVisible(false);
m_Controls->m_NeglBframe->setVisible(false);
m_Controls->m_IterationsFrame->setVisible(false);
m_Controls->m_LambdaFrame->setVisible(false);
break;
}
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::DStarSlider (int val)
{
QString sval = QString::number(val/1000.0);
m_Controls->m_DStarLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::BThreshSlider (int val)
{
QString sval = QString::number(val*5.0);
m_Controls->m_BThreshLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::S0ThreshSlider (int val)
{
QString sval = QString::number(val*0.5);
m_Controls->m_S0ThreshLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::NumItsSlider (int val)
{
QString sval = QString::number(val);
m_Controls->m_NumItsLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::LambdaSlider (int val)
{
QString sval = QString::number(val*.00001);
m_Controls->m_LambdaLabel->setText(sval);
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
}
void QmitkIVIMView::StdMultiWidgetNotAvailable()
{
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag1 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag2 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag3 );
}
m_MultiWidget = NULL;
}
void QmitkIVIMView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
bool foundOneDiffusionImage = false;
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
m_MaskImageNode = NULL;
m_DiffusionImageNode = NULL;
// iterate all selected objects, adjust warning visibility
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
{
if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
{
m_DiffusionImageNode = node;
foundOneDiffusionImage = true;
m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
}
else
{
bool isBinary = false;
node->GetPropertyValue<bool>("binary", isBinary);
if (isBinary)
{
m_MaskImageNode = node;
m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
}
}
}
}
if (m_DiffusionImageNode.IsNotNull())
{
m_Controls->m_VisualizeResultsWidget->setVisible(true);
m_Controls->m_InputData->setTitle("Input Data");
}
else
m_Controls->m_VisualizeResultsWidget->setVisible(false);
m_Controls->m_ButtonStart->setEnabled( foundOneDiffusionImage );
m_Controls->m_ButtonAutoThres->setEnabled( foundOneDiffusionImage );
m_Controls->m_ControlsFrame->setEnabled( foundOneDiffusionImage );
m_Controls->m_BottomControlsFrame->setEnabled( foundOneDiffusionImage );
itk::StartEvent dummy;
OnSliceChanged(dummy);
}
void QmitkIVIMView::AutoThreshold()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
if (nodes.empty()) return;
if (!nodes.front())
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, "Template", "Please load and select a diffusion image before starting image processing.");
return;
}
typedef mitk::DiffusionImage<short> DiffImgType;
DiffImgType* dimg = dynamic_cast<DiffImgType*>(nodes.front()->GetData());
if (!dimg)
{
// Nothing selected. Inform the user and return
QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
return;
}
// find bzero index
int index = -1;
DiffImgType::GradientDirectionContainerType::Pointer directions = dimg->GetDirections();
for(DiffImgType::GradientDirectionContainerType::ConstIterator it = directions->Begin();
it != directions->End(); ++it)
{
index++;
DiffImgType::GradientDirectionType g = it.Value();
if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
break;
}
typedef itk::VectorImage<short,3> VecImgType;
VecImgType::Pointer vecimg = dimg->GetVectorImage();
int vecLength = vecimg->GetVectorLength();
index = index > vecLength-1 ? vecLength-1 : index;
MITK_INFO << "Performing Histogram Analysis on Channel" << index;
typedef itk::Image<short,3> ImgType;
ImgType::Pointer img = ImgType::New();
mitk::CastToItkImage<ImgType>(dimg, img);
itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
itw = itw.Begin();
itk::ImageRegionConstIterator<VecImgType> itr (vecimg, vecimg->GetLargestPossibleRegion() );
itr = itr.Begin();
while(!itr.IsAtEnd())
{
itw.Set(itr.Get().GetElement(index));
++itr;
++itw;
}
typedef itk::Statistics::ScalarImageToHistogramGenerator< ImgType >
HistogramGeneratorType;
typedef HistogramGeneratorType::HistogramType HistogramType;
HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
histogramGenerator->SetInput( img );
histogramGenerator->SetMarginalScale( 10 ); // Defines y-margin width of histogram
histogramGenerator->SetNumberOfBins( 100 ); // CT range [-1024, +2048] --> bin size 4 values
histogramGenerator->SetHistogramMin( dimg->GetScalarValueMin() );
histogramGenerator->SetHistogramMax( dimg->GetScalarValueMax() * .5 );
histogramGenerator->Compute();
HistogramType::ConstIterator iter = histogramGenerator->GetOutput()->Begin();
float maxFreq = 0;
float maxValue = 0;
while ( iter != histogramGenerator->GetOutput()->End() )
{
if(iter.GetFrequency() > maxFreq)
{
maxFreq = iter.GetFrequency();
maxValue = iter.GetMeasurementVector()[0];
}
++iter;
}
maxValue *= 2;
int sliderPos = maxValue * 2;
m_Controls->m_S0ThreshSlider->setValue(sliderPos);
S0ThreshSlider(sliderPos);
}
void QmitkIVIMView::FittIVIMStart()
{
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
mitk::DiffusionImage<short>* img = 0;
for ( int i=0; i<nodes.size(); i++ )
{
img = dynamic_cast<mitk::DiffusionImage<short>*>(nodes.at(i)->GetData());
if (img)
break;
}
if (!img)
{
QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
return;
}
typedef itk::VectorImage<short,3> VecImgType;
VecImgType::Pointer vecimg = img->GetVectorImage();
OutImgType::IndexType dummy;
FittIVIM(vecimg, img->GetDirections(), img->GetB_Value(), true, dummy);
OutputToDatastorage(nodes);
}
void QmitkIVIMView::OnSliceChanged(const itk::EventObject& /*e*/)
{
if(!m_Visible)
return;
m_Controls->m_Warning->setVisible(false);
if(!m_Controls || m_DiffusionImageNode.IsNull())
return;
m_Controls->m_VisualizeResultsWidget->setVisible(false);
mitk::DiffusionImage<short>::Pointer diffusionImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_DiffusionImageNode->GetData());
mitk::Image::Pointer maskImg = NULL;
if (m_MaskImageNode.IsNotNull())
maskImg = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
if (!m_MultiWidget) return;
typedef itk::VectorImage<short,3> VecImgType;
VecImgType::Pointer vecimg = (VecImgType*)diffusionImg->GetVectorImage().GetPointer();
VecImgType::Pointer roiImage = VecImgType::New();
bool success = false;
if(maskImg.IsNull())
{
int roisize = 0;
if(m_Controls->m_MethodCombo->currentIndex() == 4)
roisize = 5;
mitk::Point3D pos = m_MultiWidget->GetCrossPosition();
VecImgType::IndexType crosspos;
- diffusionImg->GetTimeSlicedGeometry()->WorldToIndex(pos, crosspos);
+ diffusionImg->GetGeometry()->WorldToIndex(pos, crosspos);
if (!vecimg->GetLargestPossibleRegion().IsInside(crosspos))
{
m_Controls->m_Warning->setText(QString("Crosshair position not inside of selected diffusion weighted image. Reinit needed!"));
m_Controls->m_Warning->setVisible(true);
return;
}
else
m_Controls->m_Warning->setVisible(false);
VecImgType::IndexType index;
index[0] = crosspos[0] - roisize; index[0] = index[0] < 0 ? 0 : index[0];
index[1] = crosspos[1] - roisize; index[1] = index[1] < 0 ? 0 : index[1];
index[2] = crosspos[2] - roisize; index[2] = index[2] < 0 ? 0 : index[2];
VecImgType::SizeType size;
size[0] = roisize*2+1;
size[1] = roisize*2+1;
size[2] = roisize*2+1;
VecImgType::SizeType maxSize = vecimg->GetLargestPossibleRegion().GetSize();
size[0] = index[0]+size[0] > maxSize[0] ? maxSize[0]-index[0] : size[0];
size[1] = index[1]+size[1] > maxSize[1] ? maxSize[1]-index[1] : size[1];
size[2] = index[2]+size[2] > maxSize[2] ? maxSize[2]-index[2] : size[2];
VecImgType::RegionType region;
region.SetSize( size );
region.SetIndex( index );
vecimg->SetRequestedRegion( region );
VecImgType::IndexType newstart;
newstart.Fill(0);
VecImgType::RegionType newregion;
newregion.SetSize( size );
newregion.SetIndex( newstart );
roiImage->CopyInformation( vecimg );
roiImage->SetRegions( newregion );
roiImage->SetOrigin( pos );
roiImage->Allocate();
roiImage->SetPixel(newstart, vecimg->GetPixel(index));
success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetB_Value(), false, crosspos);
}
else
{
typedef itk::Image<float,3> MaskImgType;
MaskImgType::Pointer maskItk;
CastToItkImage( maskImg, maskItk );
mitk::Point3D pos;
pos[0] = 0;
pos[1] = 0;
pos[2] = 0;
VecImgType::IndexType index;
index[0] = 0;
index[1] = 0;
index[2] = 0;
VecImgType::SizeType size;
size[0] = 1;
size[1] = 1;
size[2] = 1;
VecImgType::RegionType region;
region.SetSize( size );
region.SetIndex( index );
vecimg->SetRequestedRegion( region );
// iterators over output and input
itk::ImageRegionConstIteratorWithIndex<VecImgType>
vecit(vecimg, vecimg->GetLargestPossibleRegion());
itk::VariableLengthVector<double> avg(vecimg->GetVectorLength());
avg.Fill(0);
float numPixels = 0;
while ( ! vecit.IsAtEnd() )
{
VecImgType::PointType point;
vecimg->TransformIndexToPhysicalPoint(vecit.GetIndex(), point);
MaskImgType::IndexType index;
maskItk->TransformPhysicalPointToIndex(point, index);
if(maskItk->GetPixel(index) != 0)
{
avg += vecit.Get();
numPixels += 1.0;
}
// update iterators
++vecit;
}
avg /= numPixels;
m_Controls->m_Warning->setText(QString("Averaging ")+QString::number((int)numPixels)+QString(" voxels!"));
m_Controls->m_Warning->setVisible(true);
roiImage->CopyInformation( vecimg );
roiImage->SetRegions( region );
roiImage->SetOrigin( pos );
roiImage->Allocate();
roiImage->SetPixel(index, avg);
success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetB_Value(), false, index);
}
vecimg->SetRegions( vecimg->GetLargestPossibleRegion() );
if (success)
{
m_Controls->m_VisualizeResultsWidget->setVisible(true);
m_Controls->m_VisualizeResultsWidget->SetParameters(m_Snap);
}
}
bool QmitkIVIMView::FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos)
{
IVIMFilterType::Pointer filter = IVIMFilterType::New();
filter->SetInput(vecimg);
filter->SetGradientDirections(dirs);
filter->SetBValue(bval);
switch(m_Controls->m_MethodCombo->currentIndex())
{
case 0:
filter->SetMethod(IVIMFilterType::IVIM_FIT_ALL);
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
break;
case 1:
filter->SetMethod(IVIMFilterType::IVIM_DSTAR_FIX);
filter->SetDStar(m_Controls->m_DStarLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
break;
case 2:
filter->SetMethod(IVIMFilterType::IVIM_D_THEN_DSTAR);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
case 3:
filter->SetMethod(IVIMFilterType::IVIM_LINEAR_D_THEN_F);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
case 4:
filter->SetMethod(IVIMFilterType::IVIM_REGULARIZED);
filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
filter->SetNumberIterations(m_Controls->m_NumItsLabel->text().toInt());
filter->SetLambda(m_Controls->m_LambdaLabel->text().toDouble());
filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
break;
}
if(!multivoxel)
{
filter->SetFitDStar(true);
}
filter->SetNumberOfThreads(1);
filter->SetVerbose(false);
filter->SetCrossPosition(crosspos);
try{
filter->Update();
m_Snap = filter->GetSnapshot();
m_DStarMap = filter->GetOutput(2);
m_DMap = filter->GetOutput(1);
m_fMap = filter->GetOutput(0);
}
catch (itk::ExceptionObject &ex)
{
MITK_INFO << ex ;
m_Controls->m_Warning->setText(QString("IVIM fit not possible: ")+ex.GetDescription());
m_Controls->m_Warning->setVisible(true);
return false;
}
return true;
}
void QmitkIVIMView::OutputToDatastorage(std::vector<mitk::DataNode*> nodes)
{
// Outputs to Datastorage
QString basename(nodes.front()->GetName().c_str());
if(m_Controls->m_CheckDStar->isChecked())
{
mitk::Image::Pointer dstarimage = mitk::Image::New();
dstarimage->InitializeByItk(m_DStarMap.GetPointer());
dstarimage->SetVolume(m_DStarMap->GetBufferPointer());
QString newname2 = basename; newname2 = newname2.append("_DStarMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node2=mitk::DataNode::New();
node2->SetData( dstarimage );
node2->SetName(newname2.toAscii());
GetDefaultDataStorage()->Add(node2);
}
if(m_Controls->m_CheckD->isChecked())
{
mitk::Image::Pointer dimage = mitk::Image::New();
dimage->InitializeByItk(m_DMap.GetPointer());
dimage->SetVolume(m_DMap->GetBufferPointer());
QString newname1 = basename; newname1 = newname1.append("_DMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node1=mitk::DataNode::New();
node1->SetData( dimage );
node1->SetName(newname1.toAscii());
GetDefaultDataStorage()->Add(node1);
}
if(m_Controls->m_Checkf->isChecked())
{
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk(m_fMap.GetPointer());
image->SetVolume(m_fMap->GetBufferPointer());
QString newname0 = basename; newname0 = newname0.append("_fMap_%1").arg(m_Controls->m_MethodCombo->currentText());
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
node->SetName(newname0.toAscii());
GetDefaultDataStorage()->Add(node);
}
m_MultiWidget->RequestUpdate();
}
void QmitkIVIMView::ChooseMethod()
{
m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
}
void QmitkIVIMView::ClipboardCurveButtonClicked()
{
if(true)
{
QString clipboard("Measurement Points\n");
for ( int i=0; i<m_Snap.bvalues.size(); i++)
{
clipboard = clipboard.append( "%L1 \t" )
.arg( m_Snap.bvalues[i], 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
for ( int i=0; i<m_Snap.allmeas.size(); i++)
{
clipboard = clipboard.append( "%L1 \t" )
.arg( m_Snap.allmeas[i], 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
clipboard = clipboard.append( "1st Linear Fit of D and f \n" );
double maxb = m_Snap.bvalues.max_value();
clipboard = clipboard.append( "%L1 \t %L2 \n %L3 \t %L4 \n" )
.arg( (float) 0, 0, 'f', 2 )
.arg( maxb, 0, 'f', 2 )
.arg(1-m_Snap.currentFunceiled, 0, 'f', 2 )
.arg((1-m_Snap.currentFunceiled)*exp(-maxb * m_Snap.currentD), 0, 'f', 2 );
int nsampling = 50;
double f = 1-m_Snap.currentFunceiled;
clipboard = clipboard.append("Final Model\n");
for(int i=0; i<nsampling; i++)
{
double x = (((1.0)*i)/(1.0*nsampling))*maxb;
clipboard = clipboard.append( "%L1 \t" )
.arg( x, 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
for(int i=0; i<nsampling; i++)
{
double x = (((1.0)*i)/(1.0*nsampling))*maxb;
double y = f*exp(- x * m_Snap.currentD) + (1-f)*exp(- x * (m_Snap.currentD+m_Snap.currentDStar));
clipboard = clipboard.append( "%L1 \t" )
.arg( y, 0, 'f', 2 );
}
clipboard = clipboard.append( "\n" );
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkIVIMView::ClipboardStatisticsButtonClicked()
{
if ( true )
{
QString clipboard( "f \t D \t D* \n" );
clipboard = clipboard.append( "%L1 \t %L2 \t %L3" )
.arg( m_Snap.currentF, 0, 'f', 10 )
.arg( m_Snap.currentD, 0, 'f', 10 )
.arg( m_Snap.currentDStar, 0, 'f', 10 ) ;
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkIVIMView::Activated()
{
m_Active = true;
}
void QmitkIVIMView::Deactivated()
{
m_Active = false;
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
index 91fb6a4289..89fa93dd37 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
@@ -1,366 +1,366 @@
/*===================================================================
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 "QmitkODFDetailsView.h"
#include <QmitkStdMultiWidget.h>
#include <QTableWidgetItem>
#include <vtkFloatArray.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkLookupTable.h>
#include <mitkOdfNormalizationMethodProperty.h>
#include <QTextEdit>
#include <mitkTensorImage.h>
#include <QMessageBox>
#include <QmitkRenderingManager.h>
#include <mitkImageReadAccessor.h>
const std::string QmitkODFDetailsView::VIEW_ID = "org.mitk.views.odfdetails";
QmitkODFDetailsView::QmitkODFDetailsView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_OdfNormalization(0)
, m_ImageNode(NULL)
{
m_VtkActor = vtkActor::New();
m_VtkMapper = vtkPolyDataMapper::New();
m_Renderer = vtkRenderer::New();
m_VtkRenderWindow = vtkRenderWindow::New();
m_RenderWindowInteractor = vtkRenderWindowInteractor::New();
m_Camera = vtkCamera::New();
m_VtkRenderWindow->SetSize(300,300);
}
QmitkODFDetailsView::~QmitkODFDetailsView()
{
}
void QmitkODFDetailsView::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::QmitkODFDetailsViewControls;
m_Controls->setupUi( parent );
m_Controls->m_OdfBox->setVisible(false);
m_Controls->m_ODFRenderWidget->setVisible(false);
}
}
void QmitkODFDetailsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
}
void QmitkODFDetailsView::StdMultiWidgetNotAvailable()
{
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag1 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag2 );
}
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( m_SliceObserverTag3 );
}
m_MultiWidget = NULL;
}
void QmitkODFDetailsView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
if (m_ImageNode.IsNotNull())
m_ImageNode->RemoveObserver( m_PropertyObserverTag );
m_Controls->m_InputData->setTitle("Please Select Input Data");
m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
m_ImageNode = NULL;
// iterate selection
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(node->GetData()) || dynamic_cast<mitk::TensorImage*>(node->GetData())) )
{
m_Controls->m_InputImageLabel->setText(node->GetName().c_str());
m_ImageNode = node;
}
}
UpdateOdf();
if (m_ImageNode.IsNotNull())
{
itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
m_PropertyObserverTag = m_ImageNode->AddObserver( itk::ModifiedEvent(), command );
m_Controls->m_InputData->setTitle("Input Data");
}
}
void QmitkODFDetailsView::UpdateOdf()
{
try
{
m_Controls->m_OverviewBox->setVisible(true);
if (m_ImageNode.IsNull() || !m_MultiWidget)
{
m_Controls->m_ODFRenderWidget->setVisible(false);
m_Controls->m_OdfBox->setVisible(false);
m_Controls->m_OverviewBox->setVisible(false);
return;
}
// restore the input image label ( needed in case the last run resulted into an exception )
m_Controls->m_InputImageLabel->setText(m_ImageNode->GetName().c_str());
// ODF Normalization Property
mitk::OdfNormalizationMethodProperty* nmp = dynamic_cast<mitk::OdfNormalizationMethodProperty*>(m_ImageNode->GetProperty( "Normalization" ));
if(nmp)
m_OdfNormalization = nmp->GetNormalization();
m_TemplateOdf = itk::OrientationDistributionFunction<float,QBALL_ODFSIZE>::GetBaseMesh();
m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
m_OdfTransform->Identity();
m_OdfVals = vtkSmartPointer<vtkDoubleArray>::New();
m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
itk::OrientationDistributionFunction<double, QBALL_ODFSIZE> odf;
mitk::Point3D world = m_MultiWidget->GetCrossPosition();
mitk::Point3D index;
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
unsigned int *img_dimension = img->GetDimensions();
- img->GetTimeSlicedGeometry()->WorldToIndex(world, index);
+ img->GetGeometry()->WorldToIndex(world, index);
float sum = 0;
float max = itk::NumericTraits<float>::NonpositiveMin();
float min = itk::NumericTraits<float>::max();
QString values;
QString overviewText;
// check if dynamic_cast successfull and if the crosshair position is inside of the geometry of the ODF data
// otherwise possible crash for a scenario with multiple nodes
if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()) && ( m_ImageNode->GetData()->GetGeometry()->IsInside(world) ) )
{
m_Controls->m_ODFRenderWidget->setVisible(true);
m_Controls->m_OdfBox->setVisible(true);
try
{
mitk::QBallImage* qball_image = dynamic_cast< mitk::QBallImage* >( m_ImageNode->GetData() );
// get access to the qball image data with explicitely allowing exceptions if memory locked
mitk::ImageReadAccessor readAccess( qball_image, qball_image->GetVolumeData(0), mitk::ImageAccessorBase::ExceptionIfLocked );
const float* qball_cPtr = static_cast< const float*>(readAccess.GetData());
OdfVectorImgType::IndexType ind;
ind[0] = (int)(index[0]+0.5);
ind[1] = (int)(index[1]+0.5);
ind[2] = (int)(index[2]+0.5);
// pixel size = QBALL_ODFSIZE
// position offset = standard offset
unsigned int offset_to_data = QBALL_ODFSIZE * (ind[2] * img_dimension[1] * img_dimension[0] + ind[1] * img_dimension[0] + ind[0]);
const float *pixel_data = qball_cPtr + offset_to_data;
for (int i=0; i<QBALL_ODFSIZE; i++)
{
float val = pixel_data[i];
odf.SetNthComponent(i, val);
values += QString::number(i)+": "+QString::number(val)+"\n";
sum += val;
if (val>max)
max = val;
if (val<min)
min = val;
}
float mean = sum/QBALL_ODFSIZE;
QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
overviewText += "Coordinates: "+pos+"\n";
overviewText += "GFA: "+QString::number(odf.GetGeneralizedFractionalAnisotropy())+"\n";
overviewText += "Sum: "+QString::number(sum)+"\n";
overviewText += "Mean: "+QString::number(mean)+"\n";
overviewText += "Min: "+QString::number(min)+"\n";
overviewText += "Max: "+QString::number(max)+"\n";
vnl_vector_fixed<double, 3> pd = odf.GetDirection(odf.GetPrincipleDiffusionDirection());
overviewText += "Main Diffusion:\n "+QString::number(pd[0])+"\n "+QString::number(pd[1])+"\n "+QString::number(pd[2])+"\n";
m_Controls->m_OdfValuesTextEdit->setText(values);
m_Controls->m_OverviewTextEdit->setVisible(true);
}
catch( mitk::Exception &e )
{
MITK_WARN << "LOCKED : " << e.what();
m_Controls->m_ODFRenderWidget->setVisible(false);
m_Controls->m_OdfBox->setVisible(false);
m_Controls->m_OverviewTextEdit->setVisible(false);
// reset the selection
m_Controls->m_InputImageLabel->setText("<font color='green'>Click image to restore rendering!</font>");
}
}
else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()))
{
m_Controls->m_ODFRenderWidget->setVisible(true);
m_Controls->m_OdfBox->setVisible(false);
mitk::TensorImage* qball_image = dynamic_cast< mitk::TensorImage*>(m_ImageNode->GetData());
// pixel access block
try
{
// get access to the qball image data with explicitely allowing exceptions if memory locked
mitk::ImageReadAccessor readAccess( qball_image, qball_image->GetVolumeData(0), mitk::ImageAccessorBase::ExceptionIfLocked );
const float* qball_cPtr = static_cast< const float*>(readAccess.GetData());
TensorImageType::IndexType ind;
ind[0] = (int)(index[0]+0.5);
ind[1] = (int)(index[1]+0.5);
ind[2] = (int)(index[2]+0.5);
// 6 - tensorsize
// remaining computation - standard offset
unsigned int offset_to_data = 6 * (ind[2] * img_dimension[1] * img_dimension[0] + ind[1] * img_dimension[0] + ind[0]);
const float *pixel_data = qball_cPtr + offset_to_data;
float tensorelems[6] = {
*(pixel_data ),
*(pixel_data + 1),
*(pixel_data + 2),
*(pixel_data + 3),
*(pixel_data + 4),
*(pixel_data + 5),
};
itk::DiffusionTensor3D<float> tensor(tensorelems);
odf.InitFromTensor(tensor);
/** Array of eigen-values. */
typedef itk::FixedArray<float, 3> EigenValuesArrayType;
/** Matrix of eigen-vectors. */
typedef itk::Matrix<float, 3, 3> MatrixType;
typedef itk::Matrix<float, 3, 3> EigenVectorsMatrixType;
EigenValuesArrayType eigenValues;
EigenVectorsMatrixType eigenVectors;
QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
overviewText += "Coordinates: "+pos+"\n";
overviewText += "FA: "+QString::number(tensor.GetFractionalAnisotropy())+"\n";
overviewText += "RA: "+QString::number(tensor.GetRelativeAnisotropy())+"\n";
overviewText += "Trace: "+QString::number(tensor.GetTrace())+"\n";
tensor.ComputeEigenAnalysis(eigenValues,eigenVectors);
overviewText += "Eigenvalues:\n "+QString::number(eigenValues[2])+"\n "+QString::number(eigenValues[1])+"\n "+QString::number(eigenValues[0])+"\n";
overviewText += "Main Diffusion:\n "+QString::number(eigenVectors[0][0])+"\n "+QString::number(eigenVectors[1][0])+"\n "+QString::number(eigenVectors[2][0])+"\n";
overviewText += "Values:\n "+QString::number(tensorelems[0])+"\n "+QString::number(tensorelems[1])+"\n "+QString::number(tensorelems[2])+"\n "+QString::number(tensorelems[3])+"\n "+QString::number(tensorelems[4])+"\n "+QString::number(tensorelems[5])+"\n "+"\n";
m_Controls->m_OverviewTextEdit->setVisible(true);
}
// end pixel access block
catch(mitk::Exception &e )
{
MITK_WARN << "LOCKED : " << e.what();
m_Controls->m_ODFRenderWidget->setVisible(false);
m_Controls->m_OdfBox->setVisible(false);
m_Controls->m_OverviewTextEdit->setVisible(false);
// reset the selection
m_Controls->m_InputImageLabel->setText("<font color='green'>Click image to restore rendering!</font>");
}
}
else
{
m_Controls->m_ODFRenderWidget->setVisible(false);
m_Controls->m_OdfBox->setVisible(false);
overviewText += "Please reinit image geometry.\n";
}
// proceed only if the render widget is visible which indicates that the
// predecessing computations were successfull
if( m_Controls->m_ODFRenderWidget->isVisible() )
{
m_Controls->m_ODFDetailsWidget->SetParameters(odf);
switch(m_OdfNormalization)
{
case 0:
odf = odf.MinMaxNormalize();
break;
case 1:
odf = odf.MaxNormalize();
break;
case 2:
odf = odf.MaxNormalize();
break;
default:
odf = odf.MinMaxNormalize();
}
m_Controls->m_ODFRenderWidget->GenerateODF(odf);
m_Controls->m_OverviewTextEdit->setText(overviewText.toStdString().c_str());
}
}
catch(...)
{
QMessageBox::critical(0, "Error", "Data could not be analyzed. The image might be corrupted.");
}
}
void QmitkODFDetailsView::OnSliceChanged(const itk::EventObject& /*e*/)
{
UpdateOdf();
}
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
index 0f62da5d3b..697c66ac8b 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkPointBasedRegistrationView.cpp
@@ -1,1359 +1,1359 @@
/*===================================================================
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 "QmitkPointBasedRegistrationView.h"
#include "ui_QmitkPointBasedRegistrationViewControls.h"
#include "QmitkPointListWidget.h"
#include <vtkIterativeClosestPointTransform.h>
#include <vtkMatrix4x4.h>
#include <vtkMath.h>
#include <vtkLandmarkTransform.h>
#include <QmitkStdMultiWidget.h>
#include "QmitkCommonFunctionality.h"
#include "qradiobutton.h"
#include "qapplication.h"
#include <qcursor.h>
#include <qinputdialog.h>
#include <qlcdnumber.h>
#include <qlabel.h>
#include "qmessagebox.h"
#include "mitkLandmarkWarping.h"
#include <mitkPointOperation.h>
#include <mitkPositionEvent.h>
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#include <mitkPointSetWriter.h>
#include <mitkPointSetReader.h>
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateProperty.h"
#include "mitkNodePredicateAnd.h"
#include "mitkNodePredicateNot.h"
#include <mitkMessage.h>
#include <itkCommand.h>
#include "mitkDataNodeObject.h"
#include "berryIWorkbenchWindow.h"
#include "berryISelectionService.h"
const std::string QmitkPointBasedRegistrationView::VIEW_ID = "org.mitk.views.pointbasedregistration";
using namespace berry;
struct SelListenerPointBasedRegistration : ISelectionListener
{
berryObjectMacro(SelListenerPointBasedRegistration);
SelListenerPointBasedRegistration(QmitkPointBasedRegistrationView* view)
{
m_View = view;
}
void DoSelectionChanged(ISelection::ConstPointer selection)
{
// if(!m_View->IsVisible())
// return;
// save current selection in member variable
m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
// do something with the selected items
if(m_View->m_CurrentSelection)
{
if (m_View->m_CurrentSelection->Size() != 2)
{
if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
m_View->m_Controls.TextLabelFixed->hide();
m_View->m_Controls.m_FixedLabel->hide();
m_View->m_Controls.line2->hide();
m_View->m_Controls.m_FixedPointListWidget->hide();
m_View->m_Controls.TextLabelMoving->hide();
m_View->m_Controls.m_MovingLabel->hide();
m_View->m_Controls.line1->hide();
m_View->m_Controls.m_MovingPointListWidget->hide();
m_View->m_Controls.m_OpacityLabel->hide();
m_View->m_Controls.m_OpacitySlider->hide();
m_View->m_Controls.label->hide();
m_View->m_Controls.label_2->hide();
m_View->m_Controls.m_SwitchImages->hide();
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
}
}
else
{
m_View->m_Controls.m_StatusLabel->hide();
bool foundFixedImage = false;
mitk::DataNode::Pointer fixedNode;
// iterate selection
for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
i != m_View->m_CurrentSelection->End(); ++i)
{
// extract datatree node
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::TNodePredicateDataType<mitk::BaseData>::Pointer isBaseData(mitk::TNodePredicateDataType<mitk::BaseData>::New());
mitk::TNodePredicateDataType<mitk::PointSet>::Pointer isPointSet(mitk::TNodePredicateDataType<mitk::PointSet>::New());
mitk::NodePredicateNot::Pointer notPointSet = mitk::NodePredicateNot::New(isPointSet);
mitk::TNodePredicateDataType<mitk::Geometry2DData>::Pointer isGeometry2DData(mitk::TNodePredicateDataType<mitk::Geometry2DData>::New());
mitk::NodePredicateNot::Pointer notGeometry2DData = mitk::NodePredicateNot::New(isGeometry2DData);
mitk::NodePredicateAnd::Pointer notPointSetAndNotGeometry2DData = mitk::NodePredicateAnd::New( notPointSet, notGeometry2DData );
mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New( isBaseData, notPointSetAndNotGeometry2DData );
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = m_View->GetDataStorage()->GetSubset(predicate);
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// only look at interesting types
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if(nodeIt->Value().GetPointer() == node.GetPointer())
{
// was - compare()
// use contain to allow other Image types to be selected, i.e. a diffusion image
if (QString( node->GetData()->GetNameOfClass() ).contains("Image") )
{
// verify that the node selected by name is really an image or derived class
mitk::Image* _image = dynamic_cast<mitk::Image*>(node->GetData());
if (_image != NULL)
{
if( _image->GetDimension() == 4)
{
m_View->m_Controls.m_StatusLabel->show();
QMessageBox::information( NULL, "PointBasedRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
return;
}
if (foundFixedImage == false)
{
fixedNode = node;
foundFixedImage = true;
}
else
{
m_View->SetImagesVisible(selection);
m_View->FixedSelected(fixedNode);
m_View->MovingSelected(node);
m_View->m_Controls.m_StatusLabel->hide();
m_View->m_Controls.TextLabelFixed->show();
m_View->m_Controls.m_FixedLabel->show();
m_View->m_Controls.line2->show();
m_View->m_Controls.m_FixedPointListWidget->show();
m_View->m_Controls.TextLabelMoving->show();
m_View->m_Controls.m_MovingLabel->show();
m_View->m_Controls.line1->show();
m_View->m_Controls.m_MovingPointListWidget->show();
m_View->m_Controls.m_OpacityLabel->show();
m_View->m_Controls.m_OpacitySlider->show();
m_View->m_Controls.label->show();
m_View->m_Controls.label_2->show();
m_View->m_Controls.m_SwitchImages->show();
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
}
}
}
else
{
m_View->m_Controls.m_StatusLabel->show();
return;
}
}
}
}
}
if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
}
}
}
else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
}
}
void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
{
// check, if selection comes from datamanager
if (part)
{
QString partname(part->GetPartName().c_str());
if(partname.compare("Datamanager")==0)
{
// apply selection
DoSelectionChanged(selection);
}
}
}
QmitkPointBasedRegistrationView* m_View;
};
QmitkPointBasedRegistrationView::QmitkPointBasedRegistrationView(QObject * /*parent*/, const char * /*name*/)
: QmitkFunctionality(), m_SelListener(0), m_MultiWidget(NULL), m_FixedLandmarks(NULL), m_MovingLandmarks(NULL), m_MovingNode(NULL),
m_FixedNode(NULL), m_ShowRedGreen(false), m_Opacity(0.5), m_OriginalOpacity(1.0), m_Transformation(0), m_HideFixedImage(false), m_HideMovingImage(false),
m_OldFixedLabel(""), m_OldMovingLabel(""), m_Deactivated (false), m_CurrentFixedLandmarksObserverID(0), m_CurrentMovingLandmarksObserverID(0)
{
m_FixedLandmarksChangedCommand = itk::SimpleMemberCommand<QmitkPointBasedRegistrationView>::New();
m_FixedLandmarksChangedCommand->SetCallbackFunction(this, &QmitkPointBasedRegistrationView::updateFixedLandmarksList);
m_MovingLandmarksChangedCommand = itk::SimpleMemberCommand<QmitkPointBasedRegistrationView>::New();
m_MovingLandmarksChangedCommand->SetCallbackFunction(this, &QmitkPointBasedRegistrationView::updateMovingLandmarksList);
this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkPointBasedRegistrationView,
const mitk::DataNode*> ( this, &QmitkPointBasedRegistrationView::DataNodeHasBeenRemoved ));
}
QmitkPointBasedRegistrationView::~QmitkPointBasedRegistrationView()
{
if(m_SelListener.IsNotNull())
{
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
}
if (m_FixedPointSetNode.IsNotNull())
{
m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
}
if (m_MovingPointSetNode.IsNotNull())
{
m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
}
m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
}
void QmitkPointBasedRegistrationView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_Parent->setEnabled(false);
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
m_Controls.m_ShowRedGreenValues->setEnabled(false);
this->CreateConnections();
// let the point set widget know about the multi widget (cross hair updates)
m_Controls.m_FixedPointListWidget->SetMultiWidget( m_MultiWidget );
m_Controls.m_MovingPointListWidget->SetMultiWidget( m_MultiWidget );
}
void QmitkPointBasedRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_Parent->setEnabled(true);
m_MultiWidget = &stdMultiWidget;
m_MultiWidget->SetWidgetPlanesVisibility(true);
m_Controls.m_FixedPointListWidget->SetMultiWidget( m_MultiWidget );
m_Controls.m_MovingPointListWidget->SetMultiWidget( m_MultiWidget );
}
void QmitkPointBasedRegistrationView::StdMultiWidgetNotAvailable()
{
m_Parent->setEnabled(false);
m_MultiWidget = NULL;
m_Controls.m_FixedPointListWidget->SetMultiWidget( NULL );
m_Controls.m_MovingPointListWidget->SetMultiWidget( NULL );
}
void QmitkPointBasedRegistrationView::CreateConnections()
{
connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(EditPointSets(bool)), (QObject*)(m_Controls.m_MovingPointListWidget), SLOT(DeactivateInteractor(bool)));
connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(EditPointSets(bool)), (QObject*)(m_Controls.m_FixedPointListWidget), SLOT(DeactivateInteractor(bool)));
connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(EditPointSets(bool)), this, SLOT(HideMovingImage(bool)));
connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(EditPointSets(bool)), this, SLOT(HideFixedImage(bool)));
connect( (QObject*)(m_Controls.m_FixedPointListWidget), SIGNAL(PointListChanged()), this, SLOT(updateFixedLandmarksList()));
connect( (QObject*)(m_Controls.m_MovingPointListWidget), SIGNAL(PointListChanged()), this, SLOT(updateMovingLandmarksList()));
connect((QObject*)(m_Controls.m_Calculate),SIGNAL(clicked()),this,SLOT(calculate()));
connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
connect((QObject*)(m_Controls.m_UndoTransformation),SIGNAL(clicked()),this,SLOT(UndoTransformation()));
connect((QObject*)(m_Controls.m_RedoTransformation),SIGNAL(clicked()),this,SLOT(RedoTransformation()));
connect((QObject*)(m_Controls.m_ShowRedGreenValues),SIGNAL(toggled(bool)),this,SLOT(showRedGreen(bool)));
connect((QObject*)(m_Controls.m_OpacitySlider),SIGNAL(valueChanged(int)),this,SLOT(OpacityUpdate(int)));
connect((QObject*)(m_Controls.m_SelectedTransformationClass),SIGNAL(activated(int)), this,SLOT(transformationChanged(int)));
connect((QObject*)(m_Controls.m_UseICP),SIGNAL(toggled(bool)), this,SLOT(checkCalculateEnabled()));
connect((QObject*)(m_Controls.m_UseICP),SIGNAL(toggled(bool)), this,SLOT(checkLandmarkError()));
}
void QmitkPointBasedRegistrationView::Activated()
{
m_Deactivated = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Activated();
this->clearTransformationLists();
if (m_SelListener.IsNull())
{
m_SelListener = berry::ISelectionListener::Pointer(new SelListenerPointBasedRegistration(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<SelListenerPointBasedRegistration>()->DoSelectionChanged(sel);
}
this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
this->showRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
}
void QmitkPointBasedRegistrationView::Visible()
{
}
void QmitkPointBasedRegistrationView::Deactivated()
{
m_Deactivated = true;
if (m_FixedPointSetNode.IsNotNull())
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
this->setImageColor(false);
if (m_FixedNode.IsNotNull())
m_FixedNode->SetOpacity(1.0);
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
}
this->clearTransformationLists();
if (m_FixedPointSetNode.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_FixedLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_FixedPointSetNode);
}
if (m_MovingPointSetNode.IsNotNull() && m_MovingLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_MovingPointSetNode);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_FixedNode = NULL;
m_MovingNode = NULL;
if(m_FixedLandmarks.IsNotNull())
m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
m_FixedLandmarks = NULL;
if(m_MovingLandmarks.IsNotNull())
m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
m_MovingLandmarks = NULL;
m_FixedPointSetNode = NULL;
m_MovingPointSetNode = NULL;
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
}
void QmitkPointBasedRegistrationView::Hidden()
{
/*
m_Deactivated = true;
if (m_FixedPointSetNode.IsNotNull())
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
m_Controls.m_FixedPointListWidget->SetPointSetNode(NULL);
m_Controls.m_FixedPointListWidget->DeactivateInteractor(true);
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_Controls.m_MovingPointListWidget->SetPointSetNode(NULL);
m_Controls.m_MovingPointListWidget->DeactivateInteractor(true);
this->setImageColor(false);
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
}
this->clearTransformationLists();
if (m_FixedPointSetNode.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_FixedLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_FixedPointSetNode);
}
if (m_MovingPointSetNode.IsNotNull() && m_MovingLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() == 0)
{
this->GetDataStorage()->Remove(m_MovingPointSetNode);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_FixedNode = NULL;
m_MovingNode = NULL;
if(m_FixedLandmarks.IsNotNull())
m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
m_FixedLandmarks = NULL;
if(m_MovingLandmarks.IsNotNull())
m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
m_MovingLandmarks = NULL;
m_FixedPointSetNode = NULL;
m_MovingPointSetNode = NULL;
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//QmitkFunctionality::Deactivated();*/
}
void QmitkPointBasedRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
{
if(node == m_FixedNode || node == m_MovingNode)
{
m_Controls.m_StatusLabel->show();
m_Controls.TextLabelFixed->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
m_Controls.m_SwitchImages->hide();
m_Controls.m_ShowRedGreenValues->setEnabled(false);
}
}
void QmitkPointBasedRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
{
if(m_FixedLandmarks.IsNotNull())
m_FixedLandmarks->RemoveObserver(m_CurrentFixedLandmarksObserverID);
if (fixedImage.IsNotNull())
{
if (m_FixedNode != fixedImage)
{
// remove changes on previous selected node
if (m_FixedNode.IsNotNull())
{
this->setImageColor(false);
m_FixedNode->SetOpacity(1.0);
if (m_FixedPointSetNode.IsNotNull())
{
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
}
}
// get selected node
m_FixedNode = fixedImage;
m_FixedNode->SetOpacity(0.5);
m_FixedNode->SetVisibility(true);
m_Controls.m_FixedLabel->setText(QString::fromStdString(m_FixedNode->GetName()));
m_Controls.m_FixedLabel->show();
m_Controls.m_SwitchImages->show();
m_Controls.TextLabelFixed->show();
m_Controls.line2->show();
m_Controls.m_FixedPointListWidget->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_FixedColor = colorProperty->GetColor();
}
this->setImageColor(m_ShowRedGreen);
bool hasPointSetNode = false;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_FixedNode);
unsigned long size;
size = children->Size();
for (unsigned long i = 0; i < size; ++i)
{
mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(children->GetElement(i)->GetProperty("name"));
if(nameProp.IsNotNull() && nameProp->GetValueAsString()=="PointBasedRegistrationNode")
{
m_FixedPointSetNode=children->GetElement(i);
m_FixedLandmarks = dynamic_cast<mitk::PointSet*> (m_FixedPointSetNode->GetData());
this->GetDataStorage()->Remove(m_FixedPointSetNode);
hasPointSetNode = true;
break;
}
}
if (!hasPointSetNode)
{
m_FixedLandmarks = mitk::PointSet::New();
m_FixedPointSetNode = mitk::DataNode::New();
m_FixedPointSetNode->SetData(m_FixedLandmarks);
m_FixedPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
}
m_FixedPointSetNode->GetStringProperty("label", m_OldFixedLabel);
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New("F "));
m_FixedPointSetNode->SetProperty("color", mitk::ColorProperty::New(0.0f, 1.0f, 1.0f));
m_FixedPointSetNode->SetVisibility(true);
m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
this->GetDataStorage()->Add(m_FixedPointSetNode, m_FixedNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if (m_FixedPointSetNode.IsNull())
{
m_FixedLandmarks = mitk::PointSet::New();
m_FixedPointSetNode = mitk::DataNode::New();
m_FixedPointSetNode->SetData(m_FixedLandmarks);
m_FixedPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
m_FixedPointSetNode->GetStringProperty("label", m_OldFixedLabel);
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New("F "));
m_FixedPointSetNode->SetProperty("color", mitk::ColorProperty::New(0.0f, 1.0f, 1.0f));
m_FixedPointSetNode->SetVisibility(true);
m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
this->GetDataStorage()->Add(m_FixedPointSetNode, m_FixedNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
else
{
m_FixedNode = NULL;
if (m_FixedPointSetNode.IsNotNull())
m_FixedPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldFixedLabel));
m_FixedPointSetNode = NULL;
m_FixedLandmarks = NULL;
m_Controls.m_FixedPointListWidget->SetPointSetNode(m_FixedPointSetNode);
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.line2->hide();
m_Controls.m_FixedPointListWidget->hide();
m_Controls.m_SwitchImages->hide();
}
if(m_FixedLandmarks.IsNotNull())
m_CurrentFixedLandmarksObserverID = m_FixedLandmarks->AddObserver(itk::ModifiedEvent(), m_FixedLandmarksChangedCommand);
}
void QmitkPointBasedRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
{
if(m_MovingLandmarks.IsNotNull())
m_MovingLandmarks->RemoveObserver(m_CurrentMovingLandmarksObserverID);
if (movingImage.IsNotNull())
{
if (m_MovingNode != movingImage)
{
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
if (m_FixedNode == m_MovingNode)
m_FixedNode->SetOpacity(0.5);
this->setImageColor(false);
if (m_MovingNode != m_FixedNode)
{
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
}
else
{
m_OldFixedLabel = m_OldMovingLabel;
}
}
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_MovingNode = movingImage;
m_MovingNode->SetVisibility(true);
m_Controls.m_MovingLabel->setText(QString::fromStdString(m_MovingNode->GetName()));
m_Controls.m_MovingLabel->show();
m_Controls.TextLabelMoving->show();
m_Controls.line1->show();
m_Controls.m_MovingPointListWidget->show();
m_Controls.m_OpacityLabel->show();
m_Controls.m_OpacitySlider->show();
m_Controls.label->show();
m_Controls.label_2->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_MovingColor = colorProperty->GetColor();
}
this->setImageColor(m_ShowRedGreen);
m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
this->OpacityUpdate(m_Opacity);
bool hasPointSetNode = false;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
unsigned long size;
size = children->Size();
for (unsigned long i = 0; i < size; ++i)
{
mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(children->GetElement(i)->GetProperty("name"));
if(nameProp.IsNotNull() && nameProp->GetValueAsString()=="PointBasedRegistrationNode")
{
m_MovingPointSetNode=children->GetElement(i);
m_MovingLandmarks = dynamic_cast<mitk::PointSet*> (m_MovingPointSetNode->GetData());
this->GetDataStorage()->Remove(m_MovingPointSetNode);
hasPointSetNode = true;
break;
}
}
if (!hasPointSetNode)
{
m_MovingLandmarks = mitk::PointSet::New();
m_MovingPointSetNode = mitk::DataNode::New();
m_MovingPointSetNode->SetData(m_MovingLandmarks);
m_MovingPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
}
this->GetDataStorage()->Add(m_MovingPointSetNode, m_MovingNode);
m_MovingPointSetNode->GetStringProperty("label", m_OldMovingLabel);
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New("M "));
m_MovingPointSetNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f));
m_MovingPointSetNode->SetVisibility(true);
m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->clearTransformationLists();
this->OpacityUpdate(m_Opacity);
}
if (m_MovingPointSetNode.IsNull())
{
m_MovingLandmarks = mitk::PointSet::New();
m_MovingPointSetNode = mitk::DataNode::New();
m_MovingPointSetNode->SetData(m_MovingLandmarks);
m_MovingPointSetNode->SetProperty("name", mitk::StringProperty::New("PointBasedRegistrationNode"));
m_MovingPointSetNode->GetStringProperty("label", m_OldMovingLabel);
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New("M "));
m_MovingPointSetNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f));
m_MovingPointSetNode->SetVisibility(true);
m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
this->GetDataStorage()->Add(m_MovingPointSetNode, m_MovingNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
else
{
m_MovingNode = NULL;
if (m_MovingPointSetNode.IsNotNull())
m_MovingPointSetNode->SetProperty("label", mitk::StringProperty::New(m_OldMovingLabel));
m_MovingPointSetNode = NULL;
m_MovingLandmarks = NULL;
m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode);
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.line1->hide();
m_Controls.m_MovingPointListWidget->hide();
m_Controls.m_OpacityLabel->hide();
m_Controls.m_OpacitySlider->hide();
m_Controls.label->hide();
m_Controls.label_2->hide();
}
if(m_MovingLandmarks.IsNotNull())
m_CurrentMovingLandmarksObserverID = m_MovingLandmarks->AddObserver(itk::ModifiedEvent(), m_MovingLandmarksChangedCommand);
}
void QmitkPointBasedRegistrationView::updateMovingLandmarksList()
{
// mitk::PointSet* ps = mitk::PointSet::New();
// ps = dynamic_cast<mitk::PointSet*>(m_MovingPointSetNode->GetData());
// mitk::DataNode::Pointer tmpPtr = m_MovingPointSetNode;
// m_MovingLandmarks = 0;
// m_MovingLandmarks = (ps);
m_MovingLandmarks = dynamic_cast<mitk::PointSet*>(m_MovingPointSetNode->GetData());
// m_Controls.m_MovingPointListWidget->SetPointSetNode(m_MovingPointSetNode); //Workaround: m_MovingPointListWidget->m_PointListView->m_PointListModel loses the pointer on the pointsetnode
this->checkLandmarkError();
this->CheckCalculate();
}
void QmitkPointBasedRegistrationView::updateFixedLandmarksList()
{
m_FixedLandmarks = dynamic_cast<mitk::PointSet*>(m_FixedPointSetNode->GetData());
this->checkLandmarkError();
this->CheckCalculate();
}
void QmitkPointBasedRegistrationView::HideFixedImage(bool hide)
{
m_HideFixedImage = hide;
if(m_FixedNode.IsNotNull())
{
m_FixedNode->SetVisibility(!hide);
}
if (hide)
{
//this->reinitMovingClicked();
}
if (!m_HideMovingImage && !m_HideFixedImage)
{
//this->globalReinitClicked();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPointBasedRegistrationView::HideMovingImage(bool hide)
{
m_HideMovingImage = hide;
if(m_MovingNode.IsNotNull())
{
m_MovingNode->SetVisibility(!hide);
}
if (hide)
{
//this->reinitFixedClicked();
}
if (!m_HideMovingImage && !m_HideFixedImage)
{
//this->globalReinitClicked();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
bool QmitkPointBasedRegistrationView::CheckCalculate()
{
if((m_MovingPointSetNode.IsNull())||(m_FixedPointSetNode.IsNull()||m_FixedLandmarks.IsNull()||m_MovingLandmarks.IsNull()))
return false;
if(m_MovingNode==m_FixedNode)
return false;
return this->checkCalculateEnabled();
}
void QmitkPointBasedRegistrationView::UndoTransformation()
{
if(!m_UndoPointsGeometryList.empty())
{
mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
m_RedoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
m_MovingLandmarks->SetGeometry(m_UndoPointsGeometryList.back());
m_UndoPointsGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingPointSetNode->SetMapper(1, NULL);
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
mitk::AffineGeometryFrame3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
m_RedoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingGeometry.GetPointer()));
movingData->SetGeometry(m_UndoGeometryList.back());
m_UndoGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingNode->SetMapper(1, NULL);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
- movingData->GetTimeSlicedGeometry()->UpdateInformation();
- m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
+ movingData->GetTimeGeometry()->Update();
+ m_MovingLandmarks->GetTimeGeometry()->Update();
m_Controls.m_RedoTransformation->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
if(!m_UndoPointsGeometryList.empty())
{
m_Controls.m_UndoTransformation->setEnabled(true);
}
else
{
m_Controls.m_UndoTransformation->setEnabled(false);
}
}
void QmitkPointBasedRegistrationView::RedoTransformation()
{
if(!m_RedoPointsGeometryList.empty())
{
mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
m_MovingLandmarks->SetGeometry(m_RedoPointsGeometryList.back());
m_RedoPointsGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingPointSetNode->SetMapper(1, NULL);
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
mitk::AffineGeometryFrame3D::Pointer movingGeometry = movingData->GetGeometry(0)->Clone();
m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingGeometry.GetPointer()));
movingData->SetGeometry(m_RedoGeometryList.back());
m_RedoGeometryList.pop_back();
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingNode->SetMapper(1, NULL);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
- movingData->GetTimeSlicedGeometry()->UpdateInformation();
- m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
+ movingData->GetTimeGeometry()->Update();
+ m_MovingLandmarks->GetTimeGeometry()->Update();
m_Controls.m_UndoTransformation->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
if(!m_RedoPointsGeometryList.empty())
{
m_Controls.m_RedoTransformation->setEnabled(true);
}
else
{
m_Controls.m_RedoTransformation->setEnabled(false);
}
}
void QmitkPointBasedRegistrationView::showRedGreen(bool redGreen)
{
m_ShowRedGreen = redGreen;
this->setImageColor(m_ShowRedGreen);
}
void QmitkPointBasedRegistrationView::setImageColor(bool redGreen)
{
if (!redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(m_FixedColor);
}
if (!redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(m_MovingColor);
}
if (redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
}
if (redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPointBasedRegistrationView::OpacityUpdate(float opacity)
{
if (opacity > 1)
{
opacity = opacity/100.0f;
}
m_Opacity = opacity;
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_Opacity);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPointBasedRegistrationView::OpacityUpdate(int opacity)
{
float fValue = ((float)opacity)/100.0f;
this->OpacityUpdate(fValue);
}
void QmitkPointBasedRegistrationView::clearTransformationLists()
{
m_Controls.m_UndoTransformation->setEnabled(false);
m_Controls.m_RedoTransformation->setEnabled(false);
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
m_UndoGeometryList.clear();
m_UndoPointsGeometryList.clear();
m_RedoGeometryList.clear();
m_RedoPointsGeometryList.clear();
}
void QmitkPointBasedRegistrationView::checkLandmarkError()
{
double totalDist = 0, dist = 0, dist2 = 0;
mitk::Point3D point1, point2, point3;
double p1[3], p2[3];
if(m_Transformation < 3)
{
if (m_Controls.m_UseICP->isChecked())
{
if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull()&& m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0)
{
for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
point1 = m_MovingLandmarks->GetPoint(pointId);
point2 = m_FixedLandmarks->GetPoint(0);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
dist = vtkMath::Distance2BetweenPoints(p1, p2);
for(int pointId2 = 1; pointId2 < m_FixedLandmarks->GetSize(); ++pointId2)
{
point2 = m_FixedLandmarks->GetPoint(pointId2);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = p1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = p2[2];
dist2 = vtkMath::Distance2BetweenPoints(p1, p2);
if (dist2 < dist)
{
dist = dist2;
}
}
totalDist += dist;
}
m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
m_Controls.m_MeanErrorLCD->show();
m_Controls.m_MeanError->show();
}
else
{
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
}
}
else
{
if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0 && m_MovingLandmarks->GetSize() == m_FixedLandmarks->GetSize())
{
for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
point1 = m_MovingLandmarks->GetPoint(pointId);
point2 = m_FixedLandmarks->GetPoint(pointId);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
totalDist += vtkMath::Distance2BetweenPoints(p1, p2);
}
m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
m_Controls.m_MeanErrorLCD->show();
m_Controls.m_MeanError->show();
}
else
{
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
}
}
}
else
{
if (m_MovingLandmarks.IsNotNull() && m_FixedLandmarks.IsNotNull() && m_MovingLandmarks->GetSize() != 0 && m_FixedLandmarks->GetSize() != 0 && m_MovingLandmarks->GetSize() == m_FixedLandmarks->GetSize())
{
for(int pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
point1 = m_MovingLandmarks->GetPoint(pointId);
point2 = m_FixedLandmarks->GetPoint(pointId);
p1[0] = point1[0]; p1[1] = point1[1]; p1[2] = point1[2];
p2[0] = point2[0]; p2[1] = point2[1]; p2[2] = point2[2];
totalDist += vtkMath::Distance2BetweenPoints(p1, p2);
}
m_Controls.m_MeanErrorLCD->display(sqrt(totalDist/m_FixedLandmarks->GetSize()));
m_Controls.m_MeanErrorLCD->show();
m_Controls.m_MeanError->show();
}
else
{
m_Controls.m_MeanErrorLCD->hide();
m_Controls.m_MeanError->hide();
}
}
}
void QmitkPointBasedRegistrationView::transformationChanged(int transform)
{
m_Transformation = transform;
this->checkCalculateEnabled();
this->checkLandmarkError();
}
// ICP with vtkLandmarkTransformation
void QmitkPointBasedRegistrationView::calculateLandmarkbasedWithICP()
{
if(CheckCalculate())
{
mitk::Geometry3D::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
mitk::AffineGeometryFrame3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(originalDataGeometry.GetPointer()));
vtkIdType pointId;
vtkPoints* vPointsSource=vtkPoints::New();
vtkCellArray* vCellsSource=vtkCellArray::New();
for(pointId=0; pointId<m_MovingLandmarks->GetSize();++pointId)
{
mitk::Point3D pointSource=m_MovingLandmarks->GetPoint(pointId);
vPointsSource->InsertNextPoint(pointSource[0],pointSource[1],pointSource[2]);
vCellsSource->InsertNextCell(1, &pointId);
}
vtkPoints* vPointsTarget=vtkPoints::New();
vtkCellArray* vCellsTarget = vtkCellArray::New();
for(pointId=0; pointId<m_FixedLandmarks->GetSize();++pointId)
{
mitk::Point3D pointTarget=m_FixedLandmarks->GetPoint(pointId);
vPointsTarget->InsertNextPoint(pointTarget[0],pointTarget[1],pointTarget[2]);
vCellsTarget->InsertNextCell(1, &pointId);
}
vtkPolyData* vPointSetSource=vtkPolyData::New();
vtkPolyData* vPointSetTarget=vtkPolyData::New();
vPointSetTarget->SetPoints(vPointsTarget);
vPointSetTarget->SetVerts(vCellsTarget);
vPointSetSource->SetPoints(vPointsSource);
vPointSetSource->SetVerts(vCellsSource);
vtkIterativeClosestPointTransform * icp=vtkIterativeClosestPointTransform::New();
icp->SetCheckMeanDistance(1);
icp->SetSource(vPointSetSource);
icp->SetTarget(vPointSetTarget);
icp->SetMaximumNumberOfIterations(50);
icp->StartByMatchingCentroidsOn();
vtkLandmarkTransform * transform=icp->GetLandmarkTransform();
if(m_Transformation==0)
{
transform->SetModeToRigidBody();
}
if(m_Transformation==1)
{
transform->SetModeToSimilarity();
}
if(m_Transformation==2)
{
transform->SetModeToAffine();
}
vtkMatrix4x4 * matrix=icp->GetMatrix();
double determinant = fabs(matrix->Determinant());
if((determinant < mitk::eps) || (determinant > 100) || (determinant < 0.01)
|| (determinant==itk::NumericTraits<double>::infinity())
|| (determinant==itk::NumericTraits<double>::quiet_NaN())
|| (determinant==itk::NumericTraits<double>::signaling_NaN())
|| (determinant==-itk::NumericTraits<double>::infinity())
|| (determinant==-itk::NumericTraits<double>::quiet_NaN())
|| (determinant==-itk::NumericTraits<double>::signaling_NaN())
|| (!(determinant <= 0) && !(determinant > 0)))
{
QMessageBox msgBox;
msgBox.setText("Suspicious determinant of matrix calculated by ICP.\n"
"Please select more points or other points!" );
msgBox.exec();
return;
}
pointsGeometry->Compose(matrix);
- m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
+ m_MovingLandmarks->GetTimeGeometry()->Update();
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0);
movingGeometry->Compose(matrix);
- movingData->GetTimeSlicedGeometry()->UpdateInformation();
+ movingData->GetTimeGeometry()->Update();
m_Controls.m_UndoTransformation->setEnabled(true);
m_Controls.m_RedoTransformation->setEnabled(false);
m_RedoGeometryList.clear();
m_RedoPointsGeometryList.clear();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
}
// only vtkLandmarkTransformation
void QmitkPointBasedRegistrationView::calculateLandmarkbased()
{
if(CheckCalculate())
{
mitk::Geometry3D::Pointer pointsGeometry = m_MovingLandmarks->GetGeometry(0);
mitk::AffineGeometryFrame3D::Pointer movingLandmarksGeometry = m_MovingLandmarks->GetGeometry(0)->Clone();
m_UndoPointsGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingLandmarksGeometry.GetPointer()));
mitk::BaseData::Pointer originalData = m_MovingNode->GetData();
mitk::AffineGeometryFrame3D::Pointer originalDataGeometry = originalData->GetGeometry(0)->Clone();
m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(originalDataGeometry.GetPointer()));
vtkIdType pointId;
vtkPoints* vPointsSource=vtkPoints::New();
for(pointId = 0; pointId < m_MovingLandmarks->GetSize(); ++pointId)
{
mitk::Point3D sourcePoint = m_MovingLandmarks->GetPoint(pointId);
vPointsSource->InsertNextPoint(sourcePoint[0],sourcePoint[1],sourcePoint[2]);
}
vtkPoints* vPointsTarget=vtkPoints::New();
for(pointId=0; pointId<m_FixedLandmarks->GetSize();++pointId)
{
mitk::Point3D targetPoint=m_FixedLandmarks->GetPoint(pointId);
vPointsTarget->InsertNextPoint(targetPoint[0],targetPoint[1],targetPoint[2]);
}
vtkLandmarkTransform * transform= vtkLandmarkTransform::New();
transform->SetSourceLandmarks(vPointsSource);
transform->SetTargetLandmarks(vPointsTarget);
if(m_Transformation==0)
{
transform->SetModeToRigidBody();
}
if(m_Transformation==1)
{
transform->SetModeToSimilarity();
}
if(m_Transformation==2)
{
transform->SetModeToAffine();
}
vtkMatrix4x4 * matrix=transform->GetMatrix();
double determinant = fabs(matrix->Determinant());
if((determinant < mitk::eps) || (determinant > 100) || (determinant < 0.01)
|| (determinant==itk::NumericTraits<double>::infinity())
|| (determinant==itk::NumericTraits<double>::quiet_NaN())
|| (determinant==itk::NumericTraits<double>::signaling_NaN())
|| (determinant==-itk::NumericTraits<double>::infinity())
|| (determinant==-itk::NumericTraits<double>::quiet_NaN())
|| (determinant==-itk::NumericTraits<double>::signaling_NaN())
|| (!(determinant <= 0) && !(determinant > 0)))
{
QMessageBox msgBox;
msgBox.setText("Suspicious determinant of matrix calculated.\n"
"Please select more points or other points!" );
msgBox.exec();
return;
}
pointsGeometry->Compose(matrix);
- m_MovingLandmarks->GetTimeSlicedGeometry()->UpdateInformation();
+ m_MovingLandmarks->GetTimeGeometry()->Update();
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
mitk::Geometry3D::Pointer movingGeometry = movingData->GetGeometry(0);
movingGeometry->Compose(matrix);
- movingData->GetTimeSlicedGeometry()->UpdateInformation();
+ movingData->GetTimeGeometry()->Update();
m_Controls.m_UndoTransformation->setEnabled(true);
m_Controls.m_RedoTransformation->setEnabled(false);
m_RedoGeometryList.clear();
m_RedoPointsGeometryList.clear();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->checkLandmarkError();
}
}
void QmitkPointBasedRegistrationView::calculateLandmarkWarping()
{
mitk::LandmarkWarping* registration = new mitk::LandmarkWarping();
mitk::LandmarkWarping::FixedImageType::Pointer fixedImage = mitk::LandmarkWarping::FixedImageType::New();
mitk::Image::Pointer fimage = dynamic_cast<mitk::Image*>(m_FixedNode->GetData());
mitk::LandmarkWarping::MovingImageType::Pointer movingImage = mitk::LandmarkWarping::MovingImageType::New();
mitk::Image::Pointer mimage = dynamic_cast<mitk::Image*>(m_MovingNode->GetData());
if (fimage.IsNotNull() && /*fimage->GetDimension() == 2 || */ fimage->GetDimension() == 3 && mimage.IsNotNull() && mimage->GetDimension() == 3)
{
mitk::CastToItkImage(fimage, fixedImage);
mitk::CastToItkImage(mimage, movingImage);
registration->SetFixedImage(fixedImage);
registration->SetMovingImage(movingImage);
unsigned int pointId;
mitk::Point3D sourcePoint, targetPoint;
mitk::LandmarkWarping::LandmarkContainerType::Pointer fixedLandmarks = mitk::LandmarkWarping::LandmarkContainerType::New();
mitk::LandmarkWarping::LandmarkPointType point;
for(pointId = 0; pointId < (unsigned int)m_FixedLandmarks->GetSize(); ++pointId)
{
fimage->GetGeometry(0)->WorldToItkPhysicalPoint(m_FixedLandmarks->GetPoint(pointId), point);
fixedLandmarks->InsertElement( pointId, point);
}
mitk::LandmarkWarping::LandmarkContainerType::Pointer movingLandmarks = mitk::LandmarkWarping::LandmarkContainerType::New();
for(pointId = 0; pointId < (unsigned int)m_MovingLandmarks->GetSize(); ++pointId)
{
mitk::BaseData::Pointer fixedData = m_FixedNode->GetData();
mitk::Geometry3D::Pointer fixedGeometry = fixedData->GetGeometry(0);
fixedGeometry->WorldToItkPhysicalPoint(m_MovingLandmarks->GetPoint(pointId), point);
movingLandmarks->InsertElement( pointId, point);
}
registration->SetLandmarks(fixedLandmarks.GetPointer(), movingLandmarks.GetPointer());
mitk::LandmarkWarping::MovingImageType::Pointer output = registration->Register();
if (output.IsNotNull())
{
mitk::Image::Pointer image = mitk::Image::New();
mitk::CastToMitkImage(output, image);
m_MovingNode->SetData(image);
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelWindow;
levelWindow.SetAuto( image );
levWinProp->SetLevelWindow(levelWindow);
m_MovingNode->GetPropertyList()->SetProperty("levelwindow",levWinProp);
movingLandmarks = registration->GetTransformedTargetLandmarks();
mitk::PointSet::PointDataIterator it;
it = m_MovingLandmarks->GetPointSet()->GetPointData()->Begin();
//increase the eventId to encapsulate the coming operations
mitk::OperationEvent::IncCurrObjectEventId();
mitk::OperationEvent::ExecuteIncrement();
for(pointId=0; pointId<movingLandmarks->Size();++pointId, ++it)
{
int position = it->Index();
mitk::PointSet::PointType pt = m_MovingLandmarks->GetPoint(position);
mitk::Point3D undoPoint = ( pt );
point = movingLandmarks->GetElement(pointId);
fimage->GetGeometry(0)->ItkPhysicalPointToWorld(point, pt);
mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVE, pt, position);
//undo operation
mitk::PointOperation* undoOp = new mitk::PointOperation(mitk::OpMOVE, undoPoint, position);
mitk::OperationEvent* operationEvent = new mitk::OperationEvent(m_MovingLandmarks, doOp, undoOp, "Move point");
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(operationEvent);
//execute the Operation
m_MovingLandmarks->ExecuteOperation(doOp);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->clearTransformationLists();
this->checkLandmarkError();
}
}
}
bool QmitkPointBasedRegistrationView::checkCalculateEnabled()
{
if (m_FixedLandmarks.IsNotNull() && m_MovingLandmarks.IsNotNull())
{
int fixedPoints = m_FixedLandmarks->GetSize();
int movingPoints = m_MovingLandmarks->GetSize();
if (m_Transformation == 0 || m_Transformation == 1 || m_Transformation == 2)
{
if (m_Controls.m_UseICP->isChecked())
{
if((movingPoints > 0 && fixedPoints > 0))
{
m_Controls.m_Calculate->setEnabled(true);
return true;
}
else
{
m_Controls.m_Calculate->setEnabled(false);
return false;
}
}
else
{
if ((movingPoints == fixedPoints) && movingPoints > 0)
{
m_Controls.m_Calculate->setEnabled(true);
return true;
}
else
{
m_Controls.m_Calculate->setEnabled(false);
return false;
}
}
}
else
{
m_Controls.m_Calculate->setEnabled(true);
return true;
}
}
else
{
return false;
}
}
void QmitkPointBasedRegistrationView::calculate()
{
if (m_Transformation == 0 || m_Transformation == 1 || m_Transformation == 2)
{
if (m_Controls.m_UseICP->isChecked())
{
if (m_MovingLandmarks->GetSize() == 1 && m_FixedLandmarks->GetSize() == 1)
{
this->calculateLandmarkbased();
}
else
{
this->calculateLandmarkbasedWithICP();
}
}
else
{
this->calculateLandmarkbased();
}
}
else
{
this->calculateLandmarkWarping();
}
}
void QmitkPointBasedRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
{
if (this->m_CurrentSelection->Size() == 0)
{
// show all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(true);
}
}
}
else
{
// hide all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(false);
}
}
}
}
void QmitkPointBasedRegistrationView::SwitchImages()
{
mitk::DataNode::Pointer newMoving = m_FixedNode;
mitk::DataNode::Pointer newFixed = m_MovingNode;
this->FixedSelected(newFixed);
this->MovingSelected(newMoving);
}
diff --git a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
index 3e74f9aba4..fcb0699c2a 100644
--- a/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.registration/src/internal/QmitkRigidRegistrationView.cpp
@@ -1,1410 +1,1410 @@
/*===================================================================
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 "QmitkRigidRegistrationView.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkCommonFunctionality.h"
#include "qinputdialog.h"
#include "qmessagebox.h"
#include "qcursor.h"
#include "qapplication.h"
#include "qradiobutton.h"
#include "qslider.h"
#include "qtooltip.h"
#include <vtkTransform.h>
#include "mitkDataNodeObject.h"
#include "berryIWorkbenchWindow.h"
#include "berryISelectionService.h"
#include <mitkShowSegmentationAsSurface.h>
#include "mitkManualSegmentationToSurfaceFilter.h"
#include <mitkSegmentationSink.h>
#include <mitkImageStatisticsHolder.h>
#include <itkBinaryThresholdImageFilter.h>
const std::string QmitkRigidRegistrationView::VIEW_ID = "org.mitk.views.rigidregistration";
using namespace berry;
struct SelListenerRigidRegistration : ISelectionListener
{
berryObjectMacro(SelListenerRigidRegistration);
SelListenerRigidRegistration(QmitkRigidRegistrationView* view)
{
m_View = view;
}
void DoSelectionChanged(ISelection::ConstPointer selection)
{
// if (!m_View->IsVisible())
// return;
// save current selection in member variable
m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
// do something with the selected items
if(m_View->m_CurrentSelection)
{
if (m_View->m_CurrentSelection->Size() != 2)
{
if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
m_View->m_Controls.TextLabelFixed->hide();
m_View->m_Controls.m_FixedLabel->hide();
m_View->m_Controls.TextLabelMoving->hide();
m_View->m_Controls.m_MovingLabel->hide();
m_View->m_Controls.m_OpacityLabel->setEnabled(false);
m_View->m_Controls.m_OpacitySlider->setEnabled(false);
m_View->m_Controls.label->setEnabled(false);
m_View->m_Controls.label_2->setEnabled(false);
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
m_View->m_Controls.m_SwitchImages->hide();
}
}
else
{
m_View->m_Controls.m_StatusLabel->hide();
bool foundFixedImage = false;
mitk::DataNode::Pointer fixedNode;
// iterate selection
for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
i != m_View->m_CurrentSelection->End(); ++i)
{
// extract datatree node
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
// only look at interesting types
if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
{
if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 4)
{
m_View->m_Controls.m_StatusLabel->show();
QMessageBox::information( NULL, "RigidRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
return;
}
if (foundFixedImage == false)
{
fixedNode = node;
foundFixedImage = true;
}
else
{
m_View->SetImagesVisible(selection);
m_View->FixedSelected(fixedNode);
m_View->MovingSelected(node);
m_View->m_Controls.m_StatusLabel->hide();
m_View->m_Controls.TextLabelFixed->show();
m_View->m_Controls.m_FixedLabel->show();
m_View->m_Controls.TextLabelMoving->show();
m_View->m_Controls.m_MovingLabel->show();
m_View->m_Controls.m_OpacityLabel->setEnabled(true);
m_View->m_Controls.m_OpacitySlider->setEnabled(true);
m_View->m_Controls.label->setEnabled(true);
m_View->m_Controls.label_2->setEnabled(true);
m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
}
}
else
{
m_View->m_Controls.m_StatusLabel->show();
return;
}
}
}
}
}
else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
{
m_View->m_Controls.m_StatusLabel->show();
}
}
void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
{
// check, if selection comes from datamanager
if (part)
{
QString partname(part->GetPartName().c_str());
if(partname.compare("Datamanager")==0)
{
// apply selection
DoSelectionChanged(selection);
}
}
}
QmitkRigidRegistrationView* m_View;
};
QmitkRigidRegistrationView::QmitkRigidRegistrationView(QObject * /*parent*/, const char * /*name*/)
: QmitkFunctionality(), m_MultiWidget(NULL), m_MovingNode(NULL), m_MovingMaskNode(NULL), m_FixedNode(NULL), m_FixedMaskNode(NULL),
m_ShowRedGreen(false), m_Opacity(0.5), m_OriginalOpacity(1.0), m_Deactivated(false),m_FixedDimension(0), m_MovingDimension(0)
{
m_TranslateSliderPos[0] = 0;
m_TranslateSliderPos[1] = 0;
m_TranslateSliderPos[2] = 0;
m_RotateSliderPos[0] = 0;
m_RotateSliderPos[1] = 0;
m_RotateSliderPos[2] = 0;
m_ScaleSliderPos[0] = 0;
m_ScaleSliderPos[1] = 0;
m_ScaleSliderPos[2] = 0;
translationParams = new int[3];
rotationParams = new int[3];
scalingParams = new int[3];
m_TimeStepperAdapter = NULL;
this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkRigidRegistrationView,
const mitk::DataNode*> ( this, &QmitkRigidRegistrationView::DataNodeHasBeenRemoved ));
}
QmitkRigidRegistrationView::~QmitkRigidRegistrationView()
{
if(m_SelListener.IsNotNull())
{
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
}
}
void QmitkRigidRegistrationView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_Controls.m_ManualFrame->hide();
m_Controls.timeSlider->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.m_UseFixedImageMask->hide();
m_Controls.m_UseMovingImageMask->hide();
m_Controls.m_OpacityLabel->setEnabled(false);
m_Controls.m_OpacitySlider->setEnabled(false);
m_Controls.label->setEnabled(false);
m_Controls.label_2->setEnabled(false);
m_Controls.m_ShowRedGreenValues->setEnabled(false);
m_Controls.m_SwitchImages->hide();
if (m_Controls.m_RigidTransform->currentIndex() == 1)
{
m_Controls.frame->show();
}
else
{
m_Controls.frame->hide();
}
m_Controls.m_ManualFrame->setEnabled(false);
m_Parent->setEnabled(false);
this->CreateConnections();
this->CheckCalculateEnabled();
}
void QmitkRigidRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_Parent->setEnabled(true);
m_MultiWidget = &stdMultiWidget;
m_MultiWidget->SetWidgetPlanesVisibility(true);
}
void QmitkRigidRegistrationView::StdMultiWidgetNotAvailable()
{
m_Parent->setEnabled(false);
m_MultiWidget = NULL;
}
void QmitkRigidRegistrationView::CreateConnections()
{
connect( m_Controls.m_ManualRegistrationCheckbox, SIGNAL(toggled(bool)), this, SLOT(ShowManualRegistrationFrame(bool)));
connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
connect(m_Controls.m_ShowRedGreenValues, SIGNAL(toggled(bool)), this, SLOT(ShowRedGreen(bool)));
connect(m_Controls.m_ShowContour, SIGNAL(toggled(bool)), this, SLOT(EnableContour(bool)));
connect(m_Controls.m_UseFixedImageMask, SIGNAL(toggled(bool)), this, SLOT(UseFixedMaskImageChecked(bool)));
connect(m_Controls.m_UseMovingImageMask, SIGNAL(toggled(bool)), this, SLOT(UseMovingMaskImageChecked(bool)));
connect(m_Controls.m_RigidTransform, SIGNAL(currentChanged(int)), this, SLOT(TabChanged(int)));
connect(m_Controls.m_OpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityUpdate(int)));
connect(m_Controls.m_ContourSlider, SIGNAL(sliderReleased()), this, SLOT(ShowContour()));
connect(m_Controls.m_CalculateTransformation, SIGNAL(clicked()), this, SLOT(Calculate()));
connect(m_Controls.m_UndoTransformation,SIGNAL(clicked()),this,SLOT(UndoTransformation()));
connect(m_Controls.m_RedoTransformation,SIGNAL(clicked()),this,SLOT(RedoTransformation()));
connect(m_Controls.m_AutomaticTranslation,SIGNAL(clicked()),this,SLOT(AlignCenters()));
connect(m_Controls.m_StopOptimization,SIGNAL(clicked()), this , SLOT(StopOptimizationClicked()));
connect(m_Controls.m_XTransSlider, SIGNAL(valueChanged(int)), this, SLOT(xTrans_valueChanged(int)));
connect(m_Controls.m_YTransSlider, SIGNAL(valueChanged(int)), this, SLOT(yTrans_valueChanged(int)));
connect(m_Controls.m_ZTransSlider, SIGNAL(valueChanged(int)), this, SLOT(zTrans_valueChanged(int)));
connect(m_Controls.m_XRotSlider, SIGNAL(valueChanged(int)), this, SLOT(xRot_valueChanged(int)));
connect(m_Controls.m_YRotSlider, SIGNAL(valueChanged(int)), this, SLOT(yRot_valueChanged(int)));
connect(m_Controls.m_ZRotSlider, SIGNAL(valueChanged(int)), this, SLOT(zRot_valueChanged(int)));
connect(m_Controls.m_XScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(xScale_valueChanged(int)));
connect(m_Controls.m_YScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(yScale_valueChanged(int)));
connect(m_Controls.m_ZScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(zScale_valueChanged(int)));
connect(m_Controls.m_LoadRigidRegistrationParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(LoadRigidRegistrationParameter()));
connect(m_Controls.m_SaveRigidRegistrationParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(SaveRigidRegistrationParameter()));
connect(m_Controls.m_LoadRigidRegistrationTestParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(LoadRigidRegistrationTestParameter()));
connect(m_Controls.m_SaveRigidRegistrationTestParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(SaveRigidRegistrationTestParameter()));
connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(OptimizerChanged(double)),this,SLOT(SetOptimizerValue( double )));
connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(TransformChanged()),this,SLOT(CheckCalculateEnabled()));
connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(AddNewTransformationToUndoList()),this,SLOT(AddNewTransformationToUndoList()));
}
void QmitkRigidRegistrationView::Activated()
{
m_Deactivated = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Activated();
if (m_SelListener.IsNull())
{
m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
}
this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
this->ClearTransformationLists();
this->CheckCalculateEnabled();
/*
m_Deactivated = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Activated();
if (m_SelListener.IsNull())
{
m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/ *"org.mitk.views.datamanager",* / m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
}
this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
this->ClearTransformationLists();
this->CheckCalculateEnabled();*/
}
void QmitkRigidRegistrationView::Visible()
{
/*
m_Deactivated = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Activated();
if (m_SelListener.IsNull())
{
m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener("org.mitk.views.datamanager", m_SelListener);
berry::ISelection::ConstPointer sel(
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
m_CurrentSelection = sel.Cast<const IStructuredSelection>();
m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
}
this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
this->ClearTransformationLists();
this->CheckCalculateEnabled();*/
}
void QmitkRigidRegistrationView::Deactivated()
{
m_Deactivated = true;
this->SetImageColor(false);
if (m_FixedNode.IsNotNull())
m_FixedNode->SetOpacity(1.0);
m_FixedNode = NULL;
m_MovingNode = NULL;
this->ClearTransformationLists();
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
/*
m_Deactivated = true;
this->SetImageColor(false);
m_FixedNode = NULL;
m_MovingNode = NULL;
this->ClearTransformationLists();
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QmitkFunctionality::Deactivated();*/
}
void QmitkRigidRegistrationView::Hidden()
{
/*m_Deactivated = true;
this->SetImageColor(false);
m_FixedNode = NULL;
m_MovingNode = NULL;
this->ClearTransformationLists();
berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
if(s)
s->RemovePostSelectionListener(m_SelListener);
m_SelListener = NULL;
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//QmitkFunctionality::Deactivated();*/
}
void QmitkRigidRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
{
if(node == m_FixedNode || node == m_MovingNode)
{
m_Controls.m_StatusLabel->show();
m_Controls.TextLabelFixed->hide();
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelMoving->hide();
m_Controls.m_MovingLabel->hide();
m_Controls.m_OpacityLabel->setEnabled(false);
m_Controls.m_OpacitySlider->setEnabled(false);
m_Controls.label->setEnabled(false);
m_Controls.label_2->setEnabled(false);
m_Controls.m_ShowRedGreenValues->setEnabled(false);
m_Controls.m_SwitchImages->hide();
}
else if(node == m_ContourHelperNode)
{
// can this cause a memory leak?
m_ContourHelperNode = NULL;
}
}
void QmitkRigidRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
{
if (m_FixedNode.IsNotNull())
{
this->SetImageColor(false);
m_FixedNode->SetOpacity(1.0);
}
m_FixedNode = fixedImage;
if (m_FixedNode.IsNotNull())
{
m_FixedNode->SetOpacity(0.5);
m_FixedNode->SetVisibility(true);
m_Controls.TextLabelFixed->setText(QString::fromStdString(m_FixedNode->GetName()));
m_Controls.m_FixedLabel->show();
m_Controls.TextLabelFixed->show();
m_Controls.m_SwitchImages->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_FixedColor = colorProperty->GetColor();
}
this->SetImageColor(m_ShowRedGreen);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
if (dynamic_cast<mitk::Image*>(m_FixedNode->GetData()))
{
m_FixedDimension = dynamic_cast<mitk::Image*>(m_FixedNode->GetData())->GetDimension();
m_Controls.qmitkRigidRegistrationSelector1->SetFixedDimension(m_FixedDimension);
m_Controls.qmitkRigidRegistrationSelector1->SetFixedNode(m_FixedNode);
}
bool hasMask = false;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_FixedNode);
unsigned long size;
size = children->Size();
for (unsigned long i = 0; i < size; ++i)
{
mitk::BoolProperty::Pointer isMaskProp = dynamic_cast<mitk::BoolProperty*>(children->GetElement(i)->GetProperty("binary"));
if(isMaskProp.IsNotNull() && isMaskProp->GetValue() == true)
{
m_FixedMaskNode = children->GetElement(i);
hasMask = true;
this->CheckForMaskImages();
break;
}
}
if (!hasMask)
{
this->CheckForMaskImages();
m_FixedMaskNode = NULL;
}
// Modify slider range
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_FixedNode->GetData());
int min = (int)image->GetStatistics()->GetScalarValueMin();
int max = (int)image->GetStatistics()->GetScalarValueMax();
m_Controls.m_ContourSlider->setRange(min, max);
// Set slider to a default value
int avg = (min+max) / 2;
m_Controls.m_ContourSlider->setSliderPosition(avg);
m_Controls.m_ThresholdLabel->setText(QString::number(avg));
}
else
{
m_Controls.m_FixedLabel->hide();
m_Controls.TextLabelFixed->hide();
m_Controls.m_SwitchImages->hide();
}
this->CheckCalculateEnabled();
if(this->GetActiveStdMultiWidget())
{
m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls.timeSlider, m_MultiWidget->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromRigidRegistration");
connect( m_TimeStepperAdapter, SIGNAL( Refetch() ), this, SLOT( UpdateTimestep() ) );
}
}
void QmitkRigidRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
{
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_OriginalOpacity);
if (m_FixedNode == m_MovingNode)
m_FixedNode->SetOpacity(0.5);
this->SetImageColor(false);
}
m_MovingNode = movingImage;
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetVisibility(true);
m_Controls.TextLabelMoving->setText(QString::fromStdString(m_MovingNode->GetName()));
m_Controls.m_MovingLabel->show();
m_Controls.TextLabelMoving->show();
mitk::ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
if ( colorProperty.IsNotNull() )
{
m_MovingColor = colorProperty->GetColor();
}
this->SetImageColor(m_ShowRedGreen);
m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
this->OpacityUpdate(m_Opacity);
bool hasMask = false;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
m_Controls.qmitkRigidRegistrationSelector1->SetMovingNodeChildren(children);
unsigned long size;
size = children->Size();
for (unsigned long i = 0; i < size; ++i)
{
mitk::BoolProperty::Pointer isMaskProp = dynamic_cast<mitk::BoolProperty*>(children->GetElement(i)->GetProperty("binary"));
if(isMaskProp.IsNotNull() && isMaskProp->GetValue() == true)
{
m_MovingMaskNode = children->GetElement(i);
hasMask = true;
this->CheckForMaskImages();
break;
}
}
if (!hasMask)
{
m_MovingMaskNode = NULL;
this->CheckForMaskImages();
}
}
else
{
m_Controls.m_MovingLabel->hide();
m_Controls.TextLabelMoving->hide();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->MovingImageChanged();
this->CheckCalculateEnabled();
}
bool QmitkRigidRegistrationView::CheckCalculate()
{
if(m_MovingNode==m_FixedNode)
return false;
return true;
}
void QmitkRigidRegistrationView::AddNewTransformationToUndoList()
{
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
unsigned long size;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
size = children->Size();
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
for (unsigned long i = 0; i < size; ++i)
{
childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
}
m_UndoChildGeometryList.push_back(childGeometries);
m_RedoGeometryList.clear();
m_RedoChildGeometryList.clear();
this->SetUndoEnabled(true);
this->SetRedoEnabled(false);
}
void QmitkRigidRegistrationView::UndoTransformation()
{
if(!m_UndoGeometryList.empty())
{
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
m_RedoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
unsigned long size;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
size = children->Size();
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
for (unsigned long i = 0; i < size; ++i)
{
childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
}
m_RedoChildGeometryList.push_back(childGeometries);
movingData->SetGeometry(m_UndoGeometryList.back());
m_UndoGeometryList.pop_back();
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> oldChildGeometries;
oldChildGeometries = m_UndoChildGeometryList.back();
m_UndoChildGeometryList.pop_back();
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
for (unsigned long j = 0; j < size; ++j)
{
iter = oldChildGeometries.find(children->GetElement(j));
children->GetElement(j)->GetData()->SetGeometry((*iter).second);
}
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingNode->SetMapper(1, NULL);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
- movingData->GetTimeSlicedGeometry()->UpdateInformation();
+ movingData->GetTimeGeometry()->Update();
this->SetRedoEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if(!m_UndoGeometryList.empty())
{
this->SetUndoEnabled(true);
}
else
{
this->SetUndoEnabled(false);
}
this->CheckCalculateEnabled();
}
void QmitkRigidRegistrationView::RedoTransformation()
{
if(!m_RedoGeometryList.empty())
{
mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
unsigned long size;
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
size = children->Size();
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
for (unsigned long i = 0; i < size; ++i)
{
childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
}
m_UndoChildGeometryList.push_back(childGeometries);
movingData->SetGeometry(m_RedoGeometryList.back());
m_RedoGeometryList.pop_back();
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> oldChildGeometries;
oldChildGeometries = m_RedoChildGeometryList.back();
m_RedoChildGeometryList.pop_back();
std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
for (unsigned long j = 0; j < size; ++j)
{
iter = oldChildGeometries.find(children->GetElement(j));
children->GetElement(j)->GetData()->SetGeometry((*iter).second);
}
//\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
//is still pointing to the old one. Workaround: delete mapper
m_MovingNode->SetMapper(1, NULL);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
- movingData->GetTimeSlicedGeometry()->UpdateInformation();
+ movingData->GetTimeGeometry()->Update();
this->SetUndoEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
if(!m_RedoGeometryList.empty())
{
this->SetRedoEnabled(true);
}
else
{
this->SetRedoEnabled(false);
}
}
void QmitkRigidRegistrationView::ShowRedGreen(bool redGreen)
{
m_ShowRedGreen = redGreen;
this->SetImageColor(m_ShowRedGreen);
}
void QmitkRigidRegistrationView::EnableContour(bool show)
{
if(show)
ShowContour();
// Can happen when the m_ContourHelperNode was deleted before and now the show contour checkbox is turned off
if(m_ContourHelperNode.IsNull())
return;
m_Controls.m_ContourSlider->setEnabled(show);
m_ContourHelperNode->SetProperty("visible", mitk::BoolProperty::New(show));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkRigidRegistrationView::ShowContour()
{
int threshold = m_Controls.m_ContourSlider->value();
bool show = m_Controls.m_ShowContour->isChecked();
if(m_FixedNode.IsNull() || !show)
return;
// Update the label next to the slider
m_Controls.m_ThresholdLabel->setText(QString::number(threshold));
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_FixedNode->GetData());
typedef itk::Image<float,3> FloatImageType;
typedef itk::Image<short,3> ShortImageType;
// Create a binary image using the given treshold
typedef itk::BinaryThresholdImageFilter<FloatImageType, ShortImageType> ThresholdFilterType;
FloatImageType::Pointer floatImage = FloatImageType::New();
mitk::CastToItkImage(image, floatImage);
ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
thresholdFilter->SetInput(floatImage);
thresholdFilter->SetLowerThreshold(threshold);
thresholdFilter->SetUpperThreshold((int)image->GetStatistics()->GetScalarValueMax());
thresholdFilter->SetInsideValue(1);
thresholdFilter->SetOutsideValue(0);
thresholdFilter->Update();
ShortImageType::Pointer binaryImage = thresholdFilter->GetOutput();
mitk::Image::Pointer mitkBinaryImage = mitk::Image::New();
mitk::CastToMitkImage(binaryImage, mitkBinaryImage);
// Create a contour from the binary image
mitk::ManualSegmentationToSurfaceFilter::Pointer surfaceFilter = mitk::ManualSegmentationToSurfaceFilter::New();
surfaceFilter->SetInput( mitkBinaryImage );
surfaceFilter->SetThreshold( 1 ); //expects binary image with zeros and ones
surfaceFilter->SetUseGaussianImageSmooth(false); // apply gaussian to thresholded image ?
surfaceFilter->SetMedianFilter3D(false); // apply median to segmentation before marching cubes ?
surfaceFilter->SetDecimate( mitk::ImageToSurfaceFilter::NoDecimation );
surfaceFilter->UpdateLargestPossibleRegion();
// calculate normals for nicer display
mitk::Surface::Pointer surface = surfaceFilter->GetOutput();
if(m_ContourHelperNode.IsNull())
{
m_ContourHelperNode = mitk::DataNode::New();
m_ContourHelperNode->SetData(surface);
m_ContourHelperNode->SetProperty("opacity", mitk::FloatProperty::New(1.0) );
m_ContourHelperNode->SetProperty("line width", mitk::IntProperty::New(2) );
m_ContourHelperNode->SetProperty("scalar visibility", mitk::BoolProperty::New(false) );
m_ContourHelperNode->SetProperty( "name", mitk::StringProperty::New("surface") );
m_ContourHelperNode->SetProperty("color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
m_ContourHelperNode->SetBoolProperty("helper object", true);
this->GetDataStorage()->Add(m_ContourHelperNode);
}
else
{
m_ContourHelperNode->SetData(surface);
}
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkRigidRegistrationView::SetImageColor(bool redGreen)
{
if (!redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(m_FixedColor);
}
if (!redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(m_MovingColor);
}
if (redGreen && m_FixedNode.IsNotNull())
{
m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
}
if (redGreen && m_MovingNode.IsNotNull())
{
m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkRigidRegistrationView::OpacityUpdate(float opacity)
{
m_Opacity = opacity;
if (m_MovingNode.IsNotNull())
{
m_MovingNode->SetOpacity(m_Opacity);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkRigidRegistrationView::OpacityUpdate(int opacity)
{
float fValue = ((float)opacity)/100.0f;
this->OpacityUpdate(fValue);
}
void QmitkRigidRegistrationView::ClearTransformationLists()
{
this->SetUndoEnabled(false);
this->SetRedoEnabled(false);
m_UndoGeometryList.clear();
m_UndoChildGeometryList.clear();
m_RedoGeometryList.clear();
m_RedoChildGeometryList.clear();
}
void QmitkRigidRegistrationView::Translate(int* translateVector)
{
if (m_MovingNode.IsNotNull())
{
mitk::Vector3D translateVec;
translateVec[0] = translateVector[0] - m_TranslateSliderPos[0];
translateVec[1] = translateVector[1] - m_TranslateSliderPos[1];
translateVec[2] = translateVector[2] - m_TranslateSliderPos[2];
m_TranslateSliderPos[0] = translateVector[0];
m_TranslateSliderPos[1] = translateVector[1];
m_TranslateSliderPos[2] = translateVector[2];
vtkMatrix4x4* translationMatrix = vtkMatrix4x4::New();
translationMatrix->Identity();
double (*transMatrix)[4] = translationMatrix->Element;
transMatrix[0][3] = -translateVec[0];
transMatrix[1][3] = -translateVec[1];
transMatrix[2][3] = -translateVec[2];
translationMatrix->Invert();
m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
m_MovingNode->GetData()->Modified();
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
unsigned long size;
size = children->Size();
mitk::DataNode::Pointer childNode;
for (unsigned long i = 0; i < size; ++i)
{
childNode = children->GetElement(i);
childNode->GetData()->GetGeometry()->Compose( translationMatrix );
childNode->GetData()->Modified();
}
m_RedoGeometryList.clear();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkRigidRegistrationView::Rotate(int* rotateVector)
{
if (m_MovingNode.IsNotNull())
{
mitk::Vector3D rotateVec;
rotateVec[0] = rotateVector[0] - m_RotateSliderPos[0];
rotateVec[1] = rotateVector[1] - m_RotateSliderPos[1];
rotateVec[2] = rotateVector[2] - m_RotateSliderPos[2];
m_RotateSliderPos[0] = rotateVector[0];
m_RotateSliderPos[1] = rotateVector[1];
m_RotateSliderPos[2] = rotateVector[2];
vtkMatrix4x4* rotationMatrix = vtkMatrix4x4::New();
vtkMatrix4x4* translationMatrix = vtkMatrix4x4::New();
rotationMatrix->Identity();
translationMatrix->Identity();
double (*rotMatrix)[4] = rotationMatrix->Element;
double (*transMatrix)[4] = translationMatrix->Element;
mitk::Point3D centerBB = m_MovingNode->GetData()->GetGeometry()->GetCenter();
transMatrix[0][3] = centerBB[0];
transMatrix[1][3] = centerBB[1];
transMatrix[2][3] = centerBB[2];
translationMatrix->Invert();
m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
unsigned long size;
size = children->Size();
mitk::DataNode::Pointer childNode;
for (unsigned long i = 0; i < size; ++i)
{
childNode = children->GetElement(i);
childNode->GetData()->GetGeometry()->Compose( translationMatrix );
childNode->GetData()->Modified();
}
double radianX = rotateVec[0] * vnl_math::pi / 180;
double radianY = rotateVec[1] * vnl_math::pi / 180;
double radianZ = rotateVec[2] * vnl_math::pi / 180;
if ( rotateVec[0] != 0 )
{
rotMatrix[1][1] = cos( radianX );
rotMatrix[1][2] = -sin( radianX );
rotMatrix[2][1] = sin( radianX );
rotMatrix[2][2] = cos( radianX );
}
else if ( rotateVec[1] != 0 )
{
rotMatrix[0][0] = cos( radianY );
rotMatrix[0][2] = sin( radianY );
rotMatrix[2][0] = -sin( radianY );
rotMatrix[2][2] = cos( radianY );
}
else if ( rotateVec[2] != 0 )
{
rotMatrix[0][0] = cos( radianZ );
rotMatrix[0][1] = -sin( radianZ );
rotMatrix[1][0] = sin( radianZ );
rotMatrix[1][1] = cos( radianZ );
}
m_MovingNode->GetData()->GetGeometry()->Compose( rotationMatrix );
for (unsigned long i = 0; i < size; ++i)
{
childNode = children->GetElement(i);
childNode->GetData()->GetGeometry()->Compose( rotationMatrix );
childNode->GetData()->Modified();
}
translationMatrix->Invert();
m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
for (unsigned long i = 0; i < size; ++i)
{
childNode = children->GetElement(i);
childNode->GetData()->GetGeometry()->Compose( rotationMatrix );
childNode->GetData()->Modified();
}
m_MovingNode->GetData()->Modified();
m_RedoGeometryList.clear();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkRigidRegistrationView::Scale(int* scaleVector)
{
if (m_MovingNode.IsNotNull())
{
mitk::Vector3D scaleVec;
scaleVec[0] = scaleVector[0] - m_ScaleSliderPos[0];
scaleVec[1] = scaleVector[1] - m_ScaleSliderPos[1];
scaleVec[2] = scaleVector[2] - m_ScaleSliderPos[2];
m_ScaleSliderPos[0] = scaleVector[0];
m_ScaleSliderPos[1] = scaleVector[1];
m_ScaleSliderPos[2] = scaleVector[2];
vtkMatrix4x4* scalingMatrix = vtkMatrix4x4::New();
scalingMatrix->Identity();
double (*scaleMatrix)[4] = scalingMatrix->Element;
if (scaleVec[0] >= 0)
{
for(int i = 0; i<scaleVec[0]; i++)
{
scaleMatrix[0][0] *= 0.95;
}
}
else
{
for(int i = 0; i<-scaleVec[0]; i++)
{
scaleMatrix[0][0] *= 1/0.95;
}
}
if (scaleVec[1] >= 0)
{
for(int i = 0; i<scaleVec[1]; i++)
{
scaleMatrix[1][1] *= 0.95;
}
}
else
{
for(int i = 0; i<-scaleVec[1]; i++)
{
scaleMatrix[1][1] *= 1/0.95;
}
}
if (scaleVec[2] >= 0)
{
for(int i = 0; i<scaleVec[2]; i++)
{
scaleMatrix[2][2] *= 0.95;
}
}
else
{
for(int i = 0; i<-scaleVec[2]; i++)
{
scaleMatrix[2][2] *= 1/0.95;
}
}
scalingMatrix->Invert();
m_MovingNode->GetData()->GetGeometry()->Compose( scalingMatrix );
m_MovingNode->GetData()->Modified();
mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
unsigned long size;
size = children->Size();
mitk::DataNode::Pointer childNode;
for (unsigned long i = 0; i < size; ++i)
{
childNode = children->GetElement(i);
childNode->GetData()->GetGeometry()->Compose( scalingMatrix );
childNode->GetData()->Modified();
}
m_RedoGeometryList.clear();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkRigidRegistrationView::AlignCenters()
{
if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
{
mitk::Point3D fixedPoint = m_FixedNode->GetData()->GetGeometry()->GetCenter();
mitk::Point3D movingPoint = m_MovingNode->GetData()->GetGeometry()->GetCenter();
mitk::Vector3D translateVec;
translateVec = fixedPoint - movingPoint;
m_Controls.m_XTransSlider->setValue((int)m_Controls.m_XTransSlider->value() + (int)translateVec[0]);
m_Controls.m_YTransSlider->setValue((int)m_Controls.m_YTransSlider->value() + (int)translateVec[1]);
m_Controls.m_ZTransSlider->setValue((int)m_Controls.m_ZTransSlider->value() + (int)translateVec[2]);
}
}
void QmitkRigidRegistrationView::SetUndoEnabled( bool enable )
{
m_Controls.m_UndoTransformation->setEnabled(enable);
}
void QmitkRigidRegistrationView::SetRedoEnabled( bool enable )
{
m_Controls.m_RedoTransformation->setEnabled(enable);
}
void QmitkRigidRegistrationView::CheckCalculateEnabled()
{
if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
{
m_Controls.m_ManualFrame->setEnabled(true);
m_Controls.m_CalculateTransformation->setEnabled(true);
if ( (m_FixedDimension != m_MovingDimension && std::max<int>(m_FixedDimension, m_MovingDimension) != 4) || m_FixedDimension < 2 /*|| m_FixedDimension > 3*/)
{
m_Controls.m_CalculateTransformation->setEnabled(false);
}
else if (m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() < 5 && (m_FixedDimension < 2) /*|| m_FixedDimension > 3)*/)
{
m_Controls.m_CalculateTransformation->setEnabled(false);
}
else if ((m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() > 4 && m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() < 13) && !(m_FixedDimension > 2))
{
m_Controls.m_CalculateTransformation->setEnabled(false);
}
else if (m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() > 12 && m_FixedDimension != 2)
{
m_Controls.m_CalculateTransformation->setEnabled(false);
}
}
else
{
m_Controls.m_CalculateTransformation->setEnabled(false);
m_Controls.m_ManualFrame->setEnabled(false);
}
}
void QmitkRigidRegistrationView::xTrans_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
translationParams[0]=v;
translationParams[1]=m_Controls.m_YTransSlider->value();
translationParams[2]=m_Controls.m_ZTransSlider->value();
Translate(translationParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::yTrans_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
translationParams[0]=m_Controls.m_XTransSlider->value();
translationParams[1]=v;
translationParams[2]=m_Controls.m_ZTransSlider->value();
Translate(translationParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::zTrans_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
translationParams[0]=m_Controls.m_XTransSlider->value();
translationParams[1]=m_Controls.m_YTransSlider->value();
translationParams[2]=v;
Translate(translationParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::xRot_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
rotationParams[0]=v;
rotationParams[1]=m_Controls.m_YRotSlider->value();
rotationParams[2]=m_Controls.m_ZRotSlider->value();
Rotate(rotationParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::yRot_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
rotationParams[0]=m_Controls.m_XRotSlider->value();
rotationParams[1]=v;
rotationParams[2]=m_Controls.m_ZRotSlider->value();
Rotate(rotationParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::zRot_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
rotationParams[0]=m_Controls.m_XRotSlider->value();
rotationParams[1]=m_Controls.m_YRotSlider->value();
rotationParams[2]=v;
Rotate(rotationParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::xScale_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
scalingParams[0]=v;
scalingParams[1]=m_Controls.m_YScaleSlider->value();
scalingParams[2]=m_Controls.m_ZScaleSlider->value();
Scale(scalingParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::yScale_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
scalingParams[0]=m_Controls.m_XScaleSlider->value();
scalingParams[1]=v;
scalingParams[2]=m_Controls.m_ZScaleSlider->value();
Scale(scalingParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::zScale_valueChanged( int v )
{
if (m_MovingNode.IsNotNull())
{
scalingParams[0]=m_Controls.m_XScaleSlider->value();
scalingParams[1]=m_Controls.m_YScaleSlider->value();
scalingParams[2]=v;
Scale(scalingParams);
}
else
{
MovingImageChanged();
}
}
void QmitkRigidRegistrationView::MovingImageChanged()
{
if (dynamic_cast<mitk::Image*>(m_MovingNode->GetData()))
{
m_Controls.m_XTransSlider->setValue(0);
m_Controls.m_YTransSlider->setValue(0);
m_Controls.m_ZTransSlider->setValue(0);
translationParams[0]=0;
translationParams[1]=0;
translationParams[2]=0;
m_Controls.m_XRotSlider->setValue(0);
m_Controls.m_YRotSlider->setValue(0);
m_Controls.m_ZRotSlider->setValue(0);
rotationParams[0]=0;
rotationParams[1]=0;
rotationParams[2]=0;
m_Controls.m_XScaleSlider->setValue(0);
m_Controls.m_YScaleSlider->setValue(0);
m_Controls.m_ZScaleSlider->setValue(0);
scalingParams[0]=0;
scalingParams[1]=0;
scalingParams[2]=0;
m_MovingDimension = dynamic_cast<mitk::Image*>(m_MovingNode->GetData())->GetDimension();
m_Controls.qmitkRigidRegistrationSelector1->SetMovingDimension(m_MovingDimension);
m_Controls.qmitkRigidRegistrationSelector1->SetMovingNode(m_MovingNode);
this->CheckCalculateEnabled();
}
}
void QmitkRigidRegistrationView::Calculate()
{
m_Controls.qmitkRigidRegistrationSelector1->SetFixedNode(m_FixedNode);
m_Controls.qmitkRigidRegistrationSelector1->SetMovingNode(m_MovingNode);
if (m_FixedMaskNode.IsNotNull() && m_Controls.m_UseFixedImageMask->isChecked())
{
m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(m_FixedMaskNode);
}
else
{
m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(NULL);
}
if (m_MovingMaskNode.IsNotNull() && m_Controls.m_UseMovingImageMask->isChecked())
{
m_Controls.qmitkRigidRegistrationSelector1->SetMovingMaskNode(m_MovingMaskNode);
}
else
{
m_Controls.qmitkRigidRegistrationSelector1->SetMovingMaskNode(NULL);
}
m_Controls.frame_2->setEnabled(false);
m_Controls.frame_3->setEnabled(false);
m_Controls.m_CalculateTransformation->setEnabled(false);
m_Controls.m_StopOptimization->setEnabled(true);
m_Controls.qmitkRigidRegistrationSelector1->CalculateTransformation(((QmitkSliderNavigatorWidget*)m_Controls.timeSlider)->GetPos());
m_Controls.m_StopOptimization->setEnabled(false);
m_Controls.frame_2->setEnabled(true);
m_Controls.frame_3->setEnabled(true);
m_Controls.m_CalculateTransformation->setEnabled(true);
m_Controls.qmitkRigidRegistrationSelector1->StopOptimization(false);
}
void QmitkRigidRegistrationView::SetOptimizerValue( double value )
{
m_Controls.m_OptimizerValueLCD->display(value);
}
void QmitkRigidRegistrationView::StopOptimizationClicked()
{
m_Controls.qmitkRigidRegistrationSelector1->StopOptimization(true);
}
void QmitkRigidRegistrationView::UpdateTimestep()
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkRigidRegistrationView::ShowManualRegistrationFrame(bool show)
{
if (show)
{
m_Controls.m_ManualFrame->show();
}
else
{
m_Controls.m_ManualFrame->hide();
}
}
void QmitkRigidRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
{
if (this->m_CurrentSelection->Size() == 0)
{
// show all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(true);
}
}
}
else
{
// hide all images
mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
; nodeIt != setOfObjects->End(); ++nodeIt) // for each node
{
if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
{
nodeIt->Value()->SetVisibility(false);
}
}
}
}
void QmitkRigidRegistrationView::CheckForMaskImages()
{
if (m_FixedMaskNode.IsNotNull())
{
m_Controls.m_UseFixedImageMask->show();
}
else
{
m_Controls.m_UseFixedImageMask->hide();
}
if (m_MovingMaskNode.IsNotNull())
{
m_Controls.m_UseMovingImageMask->show();
}
else
{
m_Controls.m_UseMovingImageMask->hide();
}
}
void QmitkRigidRegistrationView::UseFixedMaskImageChecked(bool checked)
{
if (checked)
{
m_FixedMaskNode->SetVisibility(true);
}
else
{
m_FixedMaskNode->SetVisibility(false);
}
}
void QmitkRigidRegistrationView::UseMovingMaskImageChecked(bool checked)
{
if (checked)
{
m_MovingMaskNode->SetVisibility(true);
}
else
{
m_MovingMaskNode->SetVisibility(false);
}
}
void QmitkRigidRegistrationView::TabChanged(int index)
{
if (index == 0)
{
m_Controls.frame->hide();
}
else
{
m_Controls.frame->show();
}
}
void QmitkRigidRegistrationView::SwitchImages()
{
mitk::DataNode::Pointer newMoving = m_FixedNode;
mitk::DataNode::Pointer newFixed = m_MovingNode;
this->FixedSelected(newFixed);
this->MovingSelected(newMoving);
if(m_ContourHelperNode.IsNotNull())
{
// Update the contour
ShowContour();
}
}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
index a659c3c1df..fd4f8096f7 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropAction.cpp
@@ -1,196 +1,196 @@
/*===================================================================
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 "QmitkAutocropAction.h"
#include "mitkAutoCropImageFilter.h"
#include "mitkImageCast.h"
#include "mitkRenderingManager.h"
#include "mitkProgressBar.h"
#include <itkConstantPadImageFilter.h>
//needed for qApp
#include <qcoreapplication.h>
QmitkAutocropAction::QmitkAutocropAction()
{
}
QmitkAutocropAction::~QmitkAutocropAction()
{
}
void QmitkAutocropAction::Run( const QList<mitk::DataNode::Pointer> &selectedNodes )
{
foreach ( mitk::DataNode::Pointer node, selectedNodes )
{
if (node)
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
if (image.IsNull()) return;
mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
mitk::ProgressBar::GetInstance()->Progress(2);
qApp->processEvents();
mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
cropFilter->SetInput( image );
cropFilter->SetBackgroundValue( 0 );
try
{
cropFilter->Update();
image = cropFilter->GetOutput();
if (image.IsNotNull())
{
if (image->GetDimension() == 4)
{
MITK_INFO << "4D AUTOCROP DOES NOT WORK AT THE MOMENT";
throw "4D AUTOCROP DOES NOT WORK AT THE MOMENT";
unsigned int timesteps = image->GetDimension(3);
for (unsigned int i = 0; i < timesteps; i++)
{
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput(image);
imageTimeSelector->SetTimeNr(i);
imageTimeSelector->UpdateLargestPossibleRegion();
// We split a long nested code line into separate calls for debugging:
mitk::ImageSource::OutputImageType *_3dSlice = imageTimeSelector->GetOutput();
mitk::Image::Pointer _cropped3dSlice = this->IncreaseCroppedImageSize(_3dSlice);
// +++ BUG +++ BUG +++ BUG +++ BUG +++ BUG +++ BUG +++ BUG +++
void *_data = _cropped3dSlice->GetData();
// <ToBeRemoved>
// We write some stripes into the image
if ((i & 1) == 0)
{
int depth = _cropped3dSlice->GetDimension(2);
int height = _cropped3dSlice->GetDimension(1);
int width = _cropped3dSlice->GetDimension(0);
for (int z = 0; z < depth; ++z)
for (int y = 0; y < height; ++y)
for (int x = 0; x < width; ++x)
reinterpret_cast<unsigned char *>(_data)[(width * height * z) + (width * y) + x] = x & 1;
// </ToBeRemoved>
}
image->SetVolume(_data, i);
}
node->SetData( image ); // bug fix 3145
}
else
{
node->SetData( this->IncreaseCroppedImageSize(image) ); // bug fix 3145
}
// Reinit node
mitk::RenderingManager::GetInstance()->InitializeViews(
- node->GetData()->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ node->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
catch(...)
{
MITK_ERROR << "Cropping image failed...";
}
mitk::ProgressBar::GetInstance()->Progress(8);
}
else
{
MITK_INFO << " a NULL node selected";
}
}
}
mitk::Image::Pointer QmitkAutocropAction::IncreaseCroppedImageSize( mitk::Image::Pointer image )
{
typedef itk::Image< short, 3 > ImageType;
typedef itk::Image< unsigned char, 3 > PADOutputImageType;
ImageType::Pointer itkTransformImage = ImageType::New();
mitk::CastToItkImage( image, itkTransformImage );
typedef itk::ConstantPadImageFilter< ImageType, PADOutputImageType > PadFilterType;
PadFilterType::Pointer padFilter = PadFilterType::New();
unsigned long upperPad[3];
unsigned long lowerPad[3];
int borderLiner = 3;
mitk::Point3D mitkOriginPoint;
double origin[3];
origin[0]=0;
origin[1]=0;
origin[2]=0;
itkTransformImage->SetOrigin(origin);
lowerPad[0]=borderLiner;
lowerPad[1]=borderLiner;
lowerPad[2]=borderLiner;
upperPad[0]=borderLiner;
upperPad[1]=borderLiner;
upperPad[2]=borderLiner;
padFilter->SetInput(itkTransformImage);
padFilter->SetConstant(0);
padFilter->SetPadUpperBound(upperPad);
padFilter->SetPadLowerBound(lowerPad);
padFilter->UpdateLargestPossibleRegion();
mitk::Image::Pointer paddedImage = mitk::Image::New();
paddedImage->InitializeByItk(padFilter->GetOutput());
mitk::CastToMitkImage(padFilter->GetOutput(), paddedImage);
//calculate translation according to padding to get the new origin
mitk::Point3D paddedOrigin = image->GetGeometry()->GetOrigin();
mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
paddedOrigin[0] -= (borderLiner)*spacing[0];
paddedOrigin[1] -= (borderLiner)*spacing[1];
paddedOrigin[2] -= (borderLiner)*spacing[2];
paddedImage->GetGeometry()->SetOrigin( paddedOrigin );
return paddedImage;
}
void QmitkAutocropAction::SetSmoothed(bool /*smoothed*/)
{
//not needed
}
void QmitkAutocropAction::SetDecimated(bool /*decimated*/)
{
//not needed
}
void QmitkAutocropAction::SetDataStorage(mitk::DataStorage* /*dataStorage*/)
{
//not needed
}
void QmitkAutocropAction::SetFunctionality(berry::QtViewPart* /*functionality*/)
{
//not needed
}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index e0410c695d..bed480f319 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1252 +1,1247 @@
/*===================================================================
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 "mitkDataNodeObject.h"
#include "mitkProperties.h"
#include "mitkSegTool2D.h"
#include "mitkGlobalInteraction.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkNewSegmentationDialog.h"
#include <QMessageBox>
#include <berryIWorkbenchPage.h>
#include "QmitkSegmentationView.h"
#include "QmitkSegmentationPostProcessing.h"
#include "QmitkSegmentationOrganNamesHandling.cpp"
#include <mitkSurfaceToImageFilter.h>
#include <vtkPolyData.h>
//For Segmentation in rotated slices
//TODO clean up includes
#include "mitkVtkResliceInterpolationProperty.h"
#include "mitkPlanarCircle.h"
#include "mitkGetModuleContext.h"
#include "mitkModule.h"
#include "mitkModuleRegistry.h"
#include "mitkSegmentationObjectFactory.h"
const std::string QmitkSegmentationView::VIEW_ID =
"org.mitk.views.segmentation";
// public methods
QmitkSegmentationView::QmitkSegmentationView()
:m_Parent(NULL)
,m_Controls(NULL)
,m_MultiWidget(NULL)
,m_RenderingManagerObserverTag(0)
,m_DataSelectionChanged(false)
{
RegisterSegmentationObjectFactory();
}
QmitkSegmentationView::~QmitkSegmentationView()
{
// delete m_PostProcessing;
delete m_Controls;
}
void QmitkSegmentationView::NewNodesGenerated()
{
// ForceDisplayPreferencesUponAllImages();
}
void QmitkSegmentationView::NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType* nodes)
{
if (!nodes) return;
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
if (!toolManager) return;
for (mitk::ToolManager::DataVectorType::iterator iter = nodes->begin(); iter != nodes->end(); ++iter)
{
this->FireNodeSelected( *iter );
// only last iteration meaningful, multiple generated objects are not taken into account here
}
}
void QmitkSegmentationView::Visible()
{
if (m_DataSelectionChanged)
{
this->OnSelectionChanged(this->GetDataManagerSelection());
}
}
void QmitkSegmentationView::Activated()
{
// should be moved to ::BecomesVisible() or similar
if( m_Controls )
{
m_Controls->m_ManualToolSelectionBox->setEnabled( true );
m_Controls->m_OrganToolSelectionBox->setEnabled( true );
m_Controls->m_LesionToolSelectionBox->setEnabled( true );
m_Controls->m_SlicesInterpolator->Enable3DInterpolation( m_Controls->widgetStack->currentWidget() == m_Controls->pageManual );
//TODO Remove Observer
itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command1 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
command1->SetCallbackFunction( this, &QmitkSegmentationView::RenderingManagerReinitialized );
m_RenderingManagerObserverTag = mitk::RenderingManager::GetInstance()->AddObserver( mitk::RenderingManagerViewsInitializedEvent(), command1 );
//Adding observers for node visibility to existing segmentations
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateAnd::Pointer isSegmentation = mitk::NodePredicateAnd::New( isImage, isBinary );
mitk::DataStorage::SetOfObjects::ConstPointer segmentations = this->GetDefaultDataStorage()->GetSubset( isSegmentation );
mitk::DataStorage::SetOfObjects::ConstPointer image = this->GetDefaultDataStorage()->GetSubset( isImage );
if (!image->empty()) {
OnSelectionChanged(*image->begin());
}
for ( mitk::DataStorage::SetOfObjects::const_iterator iter = segmentations->begin();
iter != segmentations->end();
++iter)
{
mitk::DataNode* node = *iter;
itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
}
if(segmentations->Size() > 0)
{
FireNodeSelected(segmentations->ElementAt(0));
segmentations->ElementAt(0)->GetProperty("visible")->Modified();
}
}
}
void QmitkSegmentationView::Deactivated()
{
if( m_Controls )
{
mitk::RenderingManager::GetInstance()->RemoveObserver( m_RenderingManagerObserverTag );
m_Controls->m_ManualToolSelectionBox->setEnabled( false );
//deactivate all tools
m_Controls->m_ManualToolSelectionBox->GetToolManager()->ActivateTool(-1);
m_Controls->m_OrganToolSelectionBox->setEnabled( false );
m_Controls->m_LesionToolSelectionBox->setEnabled( false );
m_Controls->m_SlicesInterpolator->EnableInterpolation( false );
//Removing all observers
for ( NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter )
{
(*dataIter).first->GetProperty("visible")->RemoveObserver( (*dataIter).second );
}
m_WorkingDataObserverTags.clear();
if (m_MultiWidget)
{
mitk::SlicesCoordinator *coordinator = m_MultiWidget->GetSlicesRotator();
if (coordinator)
coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
coordinator = m_MultiWidget->GetSlicesSwiveller();
if (coordinator)
coordinator->RemoveObserver(m_SlicesRotationObserverTag2);
}
// gets the context of the "Mitk" (Core) module (always has id 1)
// TODO Workaround until CTL plugincontext is available
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
// Workaround end
mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
//mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
service->RemoveAllPlanePositions();
}
}
void QmitkSegmentationView::StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget )
{
SetMultiWidget(&stdMultiWidget);
}
void QmitkSegmentationView::StdMultiWidgetNotAvailable()
{
SetMultiWidget(NULL);
}
void QmitkSegmentationView::StdMultiWidgetClosed( QmitkStdMultiWidget& /*stdMultiWidget*/ )
{
SetMultiWidget(NULL);
}
void QmitkSegmentationView::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
{
if (m_MultiWidget)
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if (coordinator)
{
coordinator->RemoveObserver( m_SlicesRotationObserverTag1 );
}
coordinator = m_MultiWidget->GetSlicesSwiveller();
if (coordinator)
{
coordinator->RemoveObserver( m_SlicesRotationObserverTag2 );
}
}
// save the current multiwidget as the working widget
m_MultiWidget = multiWidget;
//TODO Remove Observers
if (m_MultiWidget)
{
mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
if (coordinator)
{
itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
}
coordinator = m_MultiWidget->GetSlicesSwiveller();
if (coordinator)
{
itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
}
}
//TODO End Remove Observers
if (m_Parent)
{
m_Parent->setEnabled(m_MultiWidget);
}
// tell the interpolation about toolmanager and multiwidget (and data storage)
if (m_Controls && m_MultiWidget)
{
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
m_Controls->m_SlicesInterpolator->SetDataStorage( *(this->GetDefaultDataStorage()));
m_Controls->m_SlicesInterpolator->Initialize( toolManager, m_MultiWidget );
}
}
void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences*)
{
ForceDisplayPreferencesUponAllImages();
}
//TODO remove function
void QmitkSegmentationView::RenderingManagerReinitialized(const itk::EventObject&)
{
CheckImageAlignment();
}
//TODO remove function
void QmitkSegmentationView::SliceRotation(const itk::EventObject&)
{
CheckImageAlignment();
}
// protected slots
void QmitkSegmentationView::CreateNewSegmentation()
{
mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
if (node.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
if (image.IsNotNull())
{
if (image->GetDimension()>1)
{
// ask about the name and organ type of the new segmentation
QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( m_Parent ); // needs a QWidget as parent, "this" is not QWidget
QString storedList = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
QStringList organColors;
if (storedList.isEmpty())
{
organColors = GetDefaultOrganColorString();
}
else
{
/*
a couple of examples of how organ names are stored:
a simple item is built up like 'name#AABBCC' where #AABBCC is the hexadecimal notation of a color as known from HTML
items are stored separated by ';'
this makes it necessary to escape occurrences of ';' in name.
otherwise the string "hugo;ypsilon#AABBCC;eugen#AABBCC" could not be parsed as two organs
but we would get "hugo" and "ypsilon#AABBCC" and "eugen#AABBCC"
so the organ name "hugo;ypsilon" is stored as "hugo\;ypsilon"
and must be unescaped after loading
the following lines could be one split with Perl's negative lookbehind
*/
// recover string list from BlueBerry view's preferences
QString storedString = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
MITK_DEBUG << "storedString: " << storedString.toStdString();
// match a string consisting of any number of repetitions of either "anything but ;" or "\;". This matches everything until the next unescaped ';'
QRegExp onePart("(?:[^;]|\\\\;)*");
MITK_DEBUG << "matching " << onePart.pattern().toStdString();
int count = 0;
int pos = 0;
while( (pos = onePart.indexIn( storedString, pos )) != -1 )
{
++count;
int length = onePart.matchedLength();
if (length == 0) break;
QString matchedString = storedString.mid(pos, length);
MITK_DEBUG << " Captured length " << length << ": " << matchedString.toStdString();
pos += length + 1; // skip separating ';'
// unescape possible occurrences of '\;' in the string
matchedString.replace("\\;", ";");
// add matched string part to output list
organColors << matchedString;
}
MITK_DEBUG << "Captured " << count << " organ name/colors";
}
dialog->SetSuggestionList( organColors );
int dialogReturnValue = dialog->exec();
if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
// ask the user about an organ type and name, add this information to the image's (!) propertylist
// create a new image of the same dimensions and smallest possible pixel type
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
mitk::Tool* firstTool = toolManager->GetToolById(0);
if (firstTool)
{
try
{
mitk::DataNode::Pointer emptySegmentation =
firstTool->CreateEmptySegmentationNode( image, dialog->GetSegmentationName().toStdString(), dialog->GetColor() );
//Here we change the reslice interpolation mode for a segmentation, so that contours in rotated slice can be shown correctly
emptySegmentation->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST) );
// initialize showVolume to false to prevent recalculating the volume while working on the segmentation
emptySegmentation->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
if (!emptySegmentation) return; // could be aborted by user
UpdateOrganList( organColors, dialog->GetSegmentationName(), dialog->GetColor() );
/*
escape ';' here (replace by '\;'), see longer comment above
*/
std::string stringForStorage = organColors.replaceInStrings(";","\\;").join(";").toStdString();
MITK_DEBUG << "Will store: " << stringForStorage;
this->GetPreferences()->PutByteArray("Organ-Color-List", stringForStorage );
this->GetPreferences()->Flush();
if(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
{
m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetSelected(false);
}
emptySegmentation->SetSelected(true);
this->GetDefaultDataStorage()->Add( emptySegmentation, node ); // add as a child, because the segmentation "derives" from the original
this->FireNodeSelected( emptySegmentation );
this->OnSelectionChanged( emptySegmentation );
this->SetToolManagerSelection(node, emptySegmentation);
}
catch (std::bad_alloc)
{
QMessageBox::warning(NULL,"Create new segmentation","Could not allocate memory for new segmentation");
}
}
}
else
{
QMessageBox::information(NULL,"Segmentation","Segmentation is currently not supported for 2D images");
}
}
}
else
{
MITK_ERROR << "'Create new segmentation' button should never be clickable unless a patient image is selected...";
}
}
void QmitkSegmentationView::OnWorkingNodeVisibilityChanged(/*const itk::Object* caller, const itk::EventObject& e*/)
{
if (!m_Parent || !m_Parent->isVisible()) return;
// The new selection behaviour is:
//
// When clicking on the checkbox of a segmentation the node will e selected and its reference node either
// The previous selected segmentation (if there is one) will be deselected. Additionally a reinit on the
// selected segmenation will be performed.
// If more than one segmentation is selected the tools will be disabled.
if (!m_Controls) return; // might happen on initialization (preferences loaded)
mitk::DataNode::Pointer referenceDataNew;
mitk::DataNode::Pointer workingData;
bool workingNodeIsVisible (true);
unsigned int numberOfSelectedSegmentations (0);
// iterate all images
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
iter != allImages->end();
++iter)
{
mitk::DataNode* node = *iter;
// apply display preferences
ApplyDisplayOptions(node);
bool isSegmentation(false);
node->GetBoolProperty("binary", isSegmentation);
if (node->IsSelected() && isSegmentation)
{
workingNodeIsVisible = node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
if (!workingNodeIsVisible)
return;
numberOfSelectedSegmentations++;
workingData = node;
if (this->GetDefaultDataStorage()->GetSources(node)->Size() != 0)
{
referenceDataNew = this->GetDefaultDataStorage()->GetSources(node)->ElementAt(0);
}
bool isBinary(false);
//Find topmost source or first source which is no binary image
while (referenceDataNew.IsNotNull() && this->GetDefaultDataStorage()->GetSources(referenceDataNew)->Size() != 0)
{
referenceDataNew = this->GetDefaultDataStorage()->GetSources(referenceDataNew)->ElementAt(0);
referenceDataNew->GetBoolProperty("binary",isBinary);
if (!isBinary)
break;
}
if (workingNodeIsVisible && referenceDataNew)
{
//Since the binary property of a segmentation can be set to false and afterwards you can create a new segmentation out of it
//->could lead to a deadloop
NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( referenceDataNew );
if ( searchIter != m_WorkingDataObserverTags.end())
{
referenceDataNew->GetProperty("visible")->RemoveObserver( (*searchIter).second );
}
referenceDataNew->SetVisibility(true);
}
//set comboBox to reference image
disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceDataNew) );
connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
continue;
}
if (workingData.IsNull() || (workingNodeIsVisible && node != referenceDataNew))
{
node->SetVisibility((false));
}
}
if(numberOfSelectedSegmentations == 1)
SetToolManagerSelection(referenceDataNew, workingData);
mitk::DataStorage::SetOfObjects::Pointer temp = mitk::DataStorage::SetOfObjects::New();
temp->InsertElement(0,workingData);
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(temp);
+// mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(temp);
-
- // Reinit current node
ForceDisplayPreferencesUponAllImages();
- // initialize the views to the bounding geometry
- /*mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();*/
}
void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
{
bool isSeg(false);
bool isHelperObject(false);
node->GetBoolProperty("helper object", isHelperObject);
node->GetBoolProperty("binary", isSeg);
mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
if(isSeg && !isHelperObject && image)
{
mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(node, mitk::NodePredicateProperty::New("isContourMarker"
, mitk::BoolProperty::New(true)));
// gets the context of the "Mitk" (Core) module (always has id 1)
// TODO Workaround until CTL plugincontext is available
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
// Workaround end
mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
//mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
{
std::string nodeName = node->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
service->RemovePlanePosition(id);
this->GetDataStorage()->Remove(it->Value());
}
mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
node->GetProperty("visible")->RemoveObserver( m_WorkingDataObserverTags[tempNode] );
m_WorkingDataObserverTags.erase(tempNode);
mitk::SurfaceInterpolationController::GetInstance()->RemoveSegmentationFromContourList(image);
}
if((m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0) == node)||
(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0) == node))
{
//as we don't know which node was actually remove e.g. our reference node, disable 'New Segmentation' button.
//consider the case that there is no more image in the datastorage
this->SetToolManagerSelection(NULL, NULL);
}
}
void QmitkSegmentationView::CreateSegmentationFromSurface()
{
mitk::DataNode::Pointer surfaceNode =
m_Controls->MaskSurfaces->GetSelectedNode();
mitk::Surface::Pointer surface(0);
if(surfaceNode.IsNotNull())
surface = dynamic_cast<mitk::Surface*> ( surfaceNode->GetData() );
if(surface.IsNull())
{
this->HandleException( "No surface selected.", m_Parent, true);
return;
}
mitk::DataNode::Pointer imageNode
= m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
mitk::Image::Pointer image(0);
if (imageNode.IsNotNull())
image = dynamic_cast<mitk::Image*>( imageNode->GetData() );
if(image.IsNull())
{
this->HandleException( "No image selected.", m_Parent, true);
return;
}
mitk::SurfaceToImageFilter::Pointer s2iFilter
= mitk::SurfaceToImageFilter::New();
s2iFilter->MakeOutputBinaryOn();
s2iFilter->SetInput(surface);
s2iFilter->SetImage(image);
s2iFilter->Update();
mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
std::string nameOfResultImage = imageNode->GetName();
nameOfResultImage.append(surfaceNode->GetName());
resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
resultNode->SetData( s2iFilter->GetOutput() );
this->GetDataStorage()->Add(resultNode, imageNode);
}
void QmitkSegmentationView::ToolboxStackPageChanged(int id)
{
// interpolation only with manual tools visible
m_Controls->m_SlicesInterpolator->EnableInterpolation( id == 0 );
if( id == 0 )
{
mitk::DataNode::Pointer workingData = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0);
if( workingData.IsNotNull() )
{
m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
m_Controls->lblSegImage->show();
m_Controls->lblSegmentation->show();
}
}
else
{
m_Controls->lblSegImage->hide();
m_Controls->lblSegmentation->hide();
}
// this is just a workaround, should be removed when all tools support 3D+t
if (id==2) // lesions
{
mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
if (node.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
if (image.IsNotNull())
{
if (image->GetDimension()>3)
{
m_Controls->widgetStack->setCurrentIndex(0);
QMessageBox::information(NULL,"Segmentation","Lesion segmentation is currently not supported for 4D images");
}
}
}
}
}
// protected
void QmitkSegmentationView::OnComboBoxSelectionChanged( const mitk::DataNode* node )
{
mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
if( selectedNode != NULL )
{
m_Controls->refImageSelector->show();
m_Controls->lblReferenceImageSelectionWarning->hide();
bool isBinary(false);
selectedNode->GetBoolProperty("binary", isBinary);
if ( isBinary )
{
FireNodeSelected(selectedNode);
selectedNode->SetVisibility(true);
}
else if (node != m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
{
if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0)->SetVisibility(false);
if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
{
m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetVisibility(false);
}
FireNodeSelected(selectedNode);
selectedNode->SetVisibility(true);
SetToolManagerSelection(selectedNode, NULL);
}
}
else
{
m_Controls->refImageSelector->hide();
m_Controls->lblReferenceImageSelectionWarning->show();
}
}
void QmitkSegmentationView::OnShowMarkerNodes (bool state)
{
mitk::SegTool2D::Pointer manualSegmentationTool;
unsigned int numberOfExistingTools = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetTools().size();
for(unsigned int i = 0; i < numberOfExistingTools; i++)
{
manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetToolById(i));
if (manualSegmentationTool)
{
if(state == true)
{
manualSegmentationTool->SetShowMarkerNodes( true );
}
else
{
manualSegmentationTool->SetShowMarkerNodes( false );
}
}
}
}
void QmitkSegmentationView::OnSelectionChanged(mitk::DataNode* node)
{
std::vector<mitk::DataNode*> nodes;
nodes.push_back( node );
this->OnSelectionChanged( nodes );
}
void QmitkSegmentationView::OnSurfaceSelectionChanged()
{
// if Image and Surface are selected, enable button
if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
(m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
m_Controls->CreateSegmentationFromSurface->setEnabled(false);
else
m_Controls->CreateSegmentationFromSurface->setEnabled(true);
}
void QmitkSegmentationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
{
// if the selected node is a contourmarker
if ( !nodes.empty() )
{
std::string markerName = "Position";
unsigned int numberOfNodes = nodes.size();
std::string nodeName = nodes.at( 0 )->GetName();
if ( ( numberOfNodes == 1 ) && ( nodeName.find( markerName ) == 0) )
{
this->OnContourMarkerSelected( nodes.at( 0 ) );
}
}
// if Image and Surface are selected, enable button
if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
(m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
m_Controls->CreateSegmentationFromSurface->setEnabled(false);
else
m_Controls->CreateSegmentationFromSurface->setEnabled(true);
m_DataSelectionChanged = false;
if (!m_Parent || !m_Parent->isVisible())
{
m_DataSelectionChanged = true;
return;
}
// reaction to BlueBerry selection events
// this method will try to figure out if a relevant segmentation and its corresponding original image were selected
// a warning is issued if the selection is invalid
// appropriate reactions are triggered otherwise
mitk::DataNode::Pointer referenceData = FindFirstRegularImage( nodes ); //m_Controls->refImageSelector->GetSelectedNode(); //FindFirstRegularImage( nodes );
mitk::DataNode::Pointer workingData = FindFirstSegmentation( nodes );
if(referenceData.IsNull() && workingData.IsNull())
return;
bool invalidSelection( !nodes.empty() &&
(
nodes.size() > 2 || // maximum 2 selected nodes
(nodes.size() == 2 && (workingData.IsNull() || referenceData.IsNull()) ) || // with two nodes, one must be the original image, one the segmentation
( workingData.GetPointer() == referenceData.GetPointer() ) //one node is selected as reference and working image
// one item is always ok (might be working or reference or nothing
)
);
if (invalidSelection)
{
// TODO visible warning when two images are selected
MITK_ERROR << "WARNING: No image, too many (>2) or two equal images were selected.";
workingData = NULL;
if( m_Controls->refImageSelector->GetSelectedNode().IsNull() )
referenceData = NULL;
}
if ( workingData.IsNotNull() && referenceData.IsNull() )
{
// find the DataStorage parent of workingData
// try to find a "normal image" parent, select this as reference image
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( workingData, isNormalImage );
if (possibleParents->size() > 0)
{
if (possibleParents->size() > 1)
{
// TODO visible warning for this rare case
MITK_ERROR << "Selected binary image has multiple parents. Using arbitrary first one for segmentation.";
}
referenceData = (*possibleParents)[0];
}
NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( workingData );
if ( searchIter == m_WorkingDataObserverTags.end() )
{
//MITK_INFO<<"Creating new observer";
itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( workingData, workingData->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
workingData->GetProperty("visible")->Modified();
return;
}
if(workingData->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))))
{
//set comboBox to reference image
disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(workingData) );
connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
// if Image and Surface are selected, enable button
if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
(m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
(!referenceData))
m_Controls->CreateSegmentationFromSurface->setEnabled(false);
else
m_Controls->CreateSegmentationFromSurface->setEnabled(true);
SetToolManagerSelection(referenceData, workingData);
FireNodeSelected(workingData);
}
else
{
SetToolManagerSelection(NULL, NULL);
FireNodeSelected(workingData);
}
}
else
{
//set comboBox to reference image
disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceData) );
connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
// if Image and Surface are selected, enable button
if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
(m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
(!referenceData))
m_Controls->CreateSegmentationFromSurface->setEnabled(false);
else
m_Controls->CreateSegmentationFromSurface->setEnabled(true);
SetToolManagerSelection(referenceData, workingData);
FireNodeSelected(referenceData);
}
}
void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode *node)
{
//TODO renderWindow anders bestimmen, siehe CheckAlignment
QmitkRenderWindow* selectedRenderWindow = 0;
QmitkRenderWindow* RenderWindow1 =
this->GetActiveStdMultiWidget()->GetRenderWindow1();
QmitkRenderWindow* RenderWindow2 =
this->GetActiveStdMultiWidget()->GetRenderWindow2();
QmitkRenderWindow* RenderWindow3 =
this->GetActiveStdMultiWidget()->GetRenderWindow3();
QmitkRenderWindow* RenderWindow4 =
this->GetActiveStdMultiWidget()->GetRenderWindow4();
bool PlanarFigureInitializedWindow = false;
// find initialized renderwindow
if (node->GetBoolProperty("PlanarFigureInitializedWindow",
PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
{
selectedRenderWindow = RenderWindow1;
}
if (!selectedRenderWindow && node->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow2->GetRenderer()))
{
selectedRenderWindow = RenderWindow2;
}
if (!selectedRenderWindow && node->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow3->GetRenderer()))
{
selectedRenderWindow = RenderWindow3;
}
if (!selectedRenderWindow && node->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow4->GetRenderer()))
{
selectedRenderWindow = RenderWindow4;
}
// make node visible
if (selectedRenderWindow)
{
std::string nodeName = node->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
// gets the context of the "Mitk" (Core) module (always has id 1)
// TODO Workaround until CTL plugincontext is available
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
// Workaround end
mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
//mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
selectedRenderWindow->GetRenderer()->GetDisplayGeometry()->Fit();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
mitk::DataNode::Pointer QmitkSegmentationView::FindFirstRegularImage( std::vector<mitk::DataNode*> nodes )
{
if (nodes.empty()) return NULL;
for(unsigned int i = 0; i < nodes.size(); ++i)
{
//mitk::DataNode::Pointer node = i.value()
bool isImage(false);
if (nodes.at(i)->GetData())
{
isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
}
// make sure this is not a binary image
bool isSegmentation(false);
nodes.at(i)->GetBoolProperty("binary", isSegmentation);
// return first proper mitk::Image
if (isImage && !isSegmentation) return nodes.at(i);
}
return NULL;
}
mitk::DataNode::Pointer QmitkSegmentationView::FindFirstSegmentation( std::vector<mitk::DataNode*> nodes )
{
if (nodes.empty()) return NULL;
for(unsigned int i = 0; i < nodes.size(); ++i)
{
bool isImage(false);
if (nodes.at(i)->GetData())
{
isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
}
bool isSegmentation(false);
nodes.at(i)->GetBoolProperty("binary", isSegmentation);
// return first proper binary mitk::Image
if (isImage && isSegmentation)
{
return nodes.at(i);
}
}
return NULL;
}
void QmitkSegmentationView::SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData)
{
// called as a result of new BlueBerry selections
// tells the ToolManager for manual segmentation about new selections
// updates GUI information about what the user should select
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
toolManager->SetWorkingData( const_cast<mitk::DataNode*>(workingData));
// check original image
m_Controls->btnNewSegmentation->setEnabled(referenceData != NULL);
if (referenceData)
{
m_Controls->lblReferenceImageSelectionWarning->hide();
}
else
{
m_Controls->lblReferenceImageSelectionWarning->show();
m_Controls->lblWorkingImageSelectionWarning->hide();
m_Controls->lblSegImage->hide();
m_Controls->lblSegmentation->hide();
}
//TODO remove statement
// check, wheter reference image is aligned like render windows. Otherwise display a visible warning (because 2D tools will probably not work)
CheckImageAlignment();
// check segmentation
if (referenceData)
{
if (!workingData)
{
m_Controls->lblWorkingImageSelectionWarning->show();
if( m_Controls->widgetStack->currentIndex() == 0 )
{
m_Controls->lblSegImage->hide();
m_Controls->lblSegmentation->hide();
}
}
else
{
m_Controls->lblWorkingImageSelectionWarning->hide();
this->FireNodeSelected(const_cast<mitk::DataNode*>(workingData));
if( m_Controls->widgetStack->currentIndex() == 0 )
{
m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
m_Controls->lblSegmentation->show();
m_Controls->lblSegImage->show();
}
}
}
}
//TODO remove function
void QmitkSegmentationView::CheckImageAlignment()
{
bool wrongAlignment(true);
mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
if (node.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
if (image.IsNotNull() && m_MultiWidget)
{
wrongAlignment = !( IsRenderWindowAligned(m_MultiWidget->GetRenderWindow1(), image )
&& IsRenderWindowAligned(m_MultiWidget->GetRenderWindow2(), image )
&& IsRenderWindowAligned(m_MultiWidget->GetRenderWindow3(), image )
);
}
}
m_Controls->lblAlignmentWarning->setVisible(wrongAlignment);
}
//TODO remove function
bool QmitkSegmentationView::IsRenderWindowAligned(QmitkRenderWindow* renderWindow, mitk::Image* image)
{
if (!renderWindow) return false;
// for all 2D renderwindows of m_MultiWidget check alignment
mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( renderWindow->GetRenderer()->GetCurrentWorldGeometry2D() );
if (displayPlane.IsNull()) return false;
int affectedDimension(-1);
int affectedSlice(-1);
return mitk::SegTool2D::DetermineAffectedImageSlice( image, displayPlane, affectedDimension, affectedSlice );
}
//TODO remove function
void QmitkSegmentationView::ForceDisplayPreferencesUponAllImages()
{
if (!m_Parent || !m_Parent->isVisible()) return;
// check all images and segmentations in DataStorage:
// (items in brackets are implicitly done by previous steps)
// 1.
// if a reference image is selected,
// show the reference image
// and hide all other images (orignal and segmentation),
// (and hide all segmentations of the other original images)
// and show all the reference's segmentations
// if no reference image is selected, do do nothing
//
// 2.
// if a segmentation is selected,
// show it
// (and hide all all its siblings (childs of the same parent, incl, NULL parent))
// if no segmentation is selected, do nothing
if (!m_Controls) return; // might happen on initialization (preferences loaded)
mitk::DataNode::Pointer referenceData = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
// 1.
if (referenceData.IsNotNull())
{
// iterate all images
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
//mitk::DataStorage::SetOfObjects::ConstPointer allSegmentationChilds = this->GetDefaultDataStorage()->GetDerivations(referenceData, isImage );
for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
iter != allImages->end();
++iter)
{
mitk::DataNode* node = *iter;
// apply display preferences
ApplyDisplayOptions(node);
// set visibility
if(!node->IsSelected() || (node->IsSelected() && !node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")))))
node->SetVisibility((node == referenceData) || node->IsSelected() );
}
// Reinit current node
mitk::RenderingManager::GetInstance()->InitializeViews(
- referenceData->GetData()->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ referenceData->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
}
// 2.
//if (workingData.IsNotNull() && !workingData->IsSelected())
//{
// workingData->SetVisibility(true);
//}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
{
if (!node) return;
bool isBinary(false);
node->GetPropertyValue("binary", isBinary);
if (isBinary)
{
node->SetProperty( "outline binary", mitk::BoolProperty::New( this->GetPreferences()->GetBool("draw outline", true)) );
node->SetProperty( "outline width", mitk::FloatProperty::New( 2.0 ) );
node->SetProperty( "opacity", mitk::FloatProperty::New( this->GetPreferences()->GetBool("draw outline", true) ? 1.0 : 0.3 ) );
node->SetProperty( "volumerendering", mitk::BoolProperty::New( this->GetPreferences()->GetBool("volume rendering", false) ) );
}
}
void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
{
// setup the basic GUI of this view
m_Parent = parent;
m_Controls = new Ui::QmitkSegmentationControls;
m_Controls->setupUi(parent);
m_Controls->lblWorkingImageSelectionWarning->hide();
m_Controls->lblAlignmentWarning->hide();
m_Controls->lblSegImage->hide();
m_Controls->lblSegmentation->hide();
m_Controls->refImageSelector->SetDataStorage(this->GetDefaultDataStorage());
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::NodePredicateOr::Pointer isImage = mitk::NodePredicateOr::New(isDiffusionImage, isMitkImage);
m_Controls->refImageSelector->SetPredicate(isImage);
if( m_Controls->refImageSelector->GetSelectedNode().IsNotNull() )
m_Controls->lblReferenceImageSelectionWarning->hide();
else
m_Controls->refImageSelector->hide();
mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
toolManager->SetDataStorage( *(this->GetDefaultDataStorage()) );
assert ( toolManager );
// all part of open source MITK
m_Controls->m_ManualToolSelectionBox->SetGenerateAccelerators(true);
m_Controls->m_ManualToolSelectionBox->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer );
m_Controls->m_ManualToolSelectionBox->SetDisplayedToolGroups("Add Subtract Paint Wipe 'Region Growing' Correction Fill Erase");
m_Controls->m_ManualToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingData );
// available only in the 3M application
if ( !m_Controls->m_OrganToolSelectionBox->children().count() )
{
m_Controls->widgetStack->setItemEnabled( 1, false );
}
m_Controls->m_OrganToolSelectionBox->SetToolManager( *toolManager );
m_Controls->m_OrganToolSelectionBox->SetToolGUIArea( m_Controls->m_OrganToolGUIContainer );
m_Controls->m_OrganToolSelectionBox->SetDisplayedToolGroups("'Hippocampus left' 'Hippocampus right' 'Lung left' 'Lung right' 'Liver' 'Heart LV' 'Endocard LV' 'Epicard LV' 'Prostate'");
m_Controls->m_OrganToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
// available only in the 3M application
if ( !m_Controls->m_LesionToolSelectionBox->children().count() )
{
m_Controls->widgetStack->setItemEnabled( 2, false );
}
m_Controls->m_LesionToolSelectionBox->SetToolManager( *toolManager );
m_Controls->m_LesionToolSelectionBox->SetToolGUIArea( m_Controls->m_LesionToolGUIContainer );
m_Controls->m_LesionToolSelectionBox->SetDisplayedToolGroups("'Lymph Node'");
m_Controls->m_LesionToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
toolManager->NewNodesGenerated +=
mitk::MessageDelegate<QmitkSegmentationView>( this, &QmitkSegmentationView::NewNodesGenerated ); // update the list of segmentations
toolManager->NewNodeObjectsGenerated +=
mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>( this, &QmitkSegmentationView::NewNodeObjectsGenerated ); // update the list of segmentations
// create signal/slot connections
connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
connect( m_Controls->btnNewSegmentation, SIGNAL(clicked()), this, SLOT(CreateNewSegmentation()) );
connect( m_Controls->CreateSegmentationFromSurface, SIGNAL(clicked()), this, SLOT(CreateSegmentationFromSurface()) );
connect( m_Controls->widgetStack, SIGNAL(currentChanged(int)), this, SLOT(ToolboxStackPageChanged(int)) );
connect(m_Controls->MaskSurfaces, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnSurfaceSelectionChanged( ) ) );
connect(m_Controls->MaskSurfaces, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
this, SLOT( OnSurfaceSelectionChanged( ) ) );
connect(m_Controls->m_SlicesInterpolator, SIGNAL(SignalShowMarkerNodes(bool)), this, SLOT(OnShowMarkerNodes(bool)));
m_Controls->MaskSurfaces->SetDataStorage(this->GetDefaultDataStorage());
m_Controls->MaskSurfaces->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
//// create helper class to provide context menus for segmentations in data manager
// m_PostProcessing = new QmitkSegmentationPostProcessing(this->GetDefaultDataStorage(), this, m_Parent);
}
//void QmitkSegmentationView::OnPlaneModeChanged(int i)
//{
// //if plane mode changes, disable all tools
// if (m_MultiWidget)
// {
// mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
//
// if (toolManager)
// {
// if (toolManager->GetActiveToolID() >= 0)
// {
// toolManager->ActivateTool(-1);
// }
// else
// {
// m_MultiWidget->EnableNavigationControllerEventListening();
// }
// }
// }
//}
// ATTENTION some methods for handling the known list of (organ names, colors) are defined in QmitkSegmentationOrganNamesHandling.cpp