diff --git a/Core/Code/DataManagement/mitkDataStorage.cpp b/Core/Code/DataManagement/mitkDataStorage.cpp
index 4de51e3dc8..c33bd27fb8 100644
--- a/Core/Code/DataManagement/mitkDataStorage.cpp
+++ b/Core/Code/DataManagement/mitkDataStorage.cpp
@@ -1,499 +1,499 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkDataStorage.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkNodePredicateBase.h"
#include "mitkNodePredicateProperty.h"
#include "mitkGroupTagProperty.h"
#include "itkMutexLockHolder.h"
#include "itkCommand.h"
mitk::DataStorage::DataStorage() : itk::Object()
, m_BlockNodeModifiedEvents(false)
{
}
mitk::DataStorage::~DataStorage()
{
///// we can not call GetAll() in destructor, because it is implemented in a subclass
//SetOfObjects::ConstPointer all = this->GetAll();
//for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
// this->RemoveListeners(it->Value());
//m_NodeModifiedObserverTags.clear();
//m_NodeDeleteObserverTags.clear();
}
void mitk::DataStorage::Add(mitk::DataNode* node, mitk::DataNode* parent)
{
mitk::DataStorage::SetOfObjects::Pointer parents = mitk::DataStorage::SetOfObjects::New();
parents->InsertElement(0, parent);
this->Add(node, parents);
}
void mitk::DataStorage::Remove(const mitk::DataStorage::SetOfObjects* nodes)
{
if (nodes == NULL)
return;
for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); it++)
this->Remove(it.Value());
}
mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::GetSubset(const NodePredicateBase* condition) const
{
mitk::DataStorage::SetOfObjects::ConstPointer result = this->FilterSetOfObjects(this->GetAll(), condition);
return result;
}
mitk::DataNode* mitk::DataStorage::GetNamedNode(const char* name) const
{
if (name == NULL)
return NULL;
mitk::StringProperty::Pointer s(mitk::StringProperty::New(name));
mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("name", s);
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(p);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return NULL;
}
mitk::DataNode* mitk::DataStorage::GetNode(const NodePredicateBase* condition) const
{
if (condition == NULL)
return NULL;
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(condition);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return NULL;
}
mitk::DataNode* mitk::DataStorage::GetNamedDerivedNode(const char* name, const mitk::DataNode* sourceNode, bool onlyDirectDerivations) const
{
if (name == NULL)
return NULL;
mitk::StringProperty::Pointer s(mitk::StringProperty::New(name));
mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("name", s);
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDerivations(sourceNode, p, onlyDirectDerivations);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return NULL;
}
void mitk::DataStorage::PrintSelf(std::ostream& os, itk::Indent indent) const
{
//Superclass::PrintSelf(os, indent);
mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetAll();
os << indent << "DataStorage " << this << " is managing " << all->Size() << " objects. List of objects:" << std::endl;
for (mitk::DataStorage::SetOfObjects::ConstIterator allIt = all->Begin(); allIt != all->End(); allIt++)
{
std::string name;
allIt.Value()->GetName(name);
std::string datatype;
if (allIt.Value()->GetData() != NULL)
datatype = allIt.Value()->GetData()->GetNameOfClass();
os << indent << " " << allIt.Value().GetPointer() << "<" << datatype << ">: " << name << std::endl;
mitk::DataStorage::SetOfObjects::ConstPointer parents = this->GetSources(allIt.Value());
if (parents->Size() > 0)
{
os << indent << " Direct sources: ";
for (mitk::DataStorage::SetOfObjects::ConstIterator parentIt = parents->Begin(); parentIt != parents->End(); parentIt++)
os << parentIt.Value().GetPointer() << ", ";
os << std::endl;
}
mitk::DataStorage::SetOfObjects::ConstPointer derivations = this->GetDerivations(allIt.Value());
if (derivations->Size() > 0)
{
os << indent << " Direct derivations: ";
for (mitk::DataStorage::SetOfObjects::ConstIterator derivationIt = derivations->Begin(); derivationIt != derivations->End(); derivationIt++)
os << derivationIt.Value().GetPointer() << ", ";
os << std::endl;
}
}
os << std::endl;
}
mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::FilterSetOfObjects(const SetOfObjects* set, const NodePredicateBase* condition) const
{
if (set == NULL)
return NULL;
mitk::DataStorage::SetOfObjects::Pointer result = mitk::DataStorage::SetOfObjects::New();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = set->Begin(); it != set->End(); it++)
if (condition == NULL || condition->CheckNode(it.Value()) == true) //alway copy the set, otherwise the iterator in mitk::DataStorage::Remove() will crash
result->InsertElement(result->Size(), it.Value());
return mitk::DataStorage::SetOfObjects::ConstPointer(result);
}
const mitk::DataNode::GroupTagList mitk::DataStorage::GetGroupTags() const
{
DataNode::GroupTagList result;
SetOfObjects::ConstPointer all = this->GetAll();
if (all.IsNull())
return result;
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = all->Begin(); nodeIt != all->End(); nodeIt++) // for each node
{
mitk::PropertyList* pl = nodeIt.Value()->GetPropertyList();
for (mitk::PropertyList::PropertyMap::const_iterator propIt = pl->GetMap()->begin(); propIt != pl->GetMap()->end(); propIt++)
if (dynamic_cast<mitk::GroupTagProperty*>(propIt->second.GetPointer()) != NULL)
result.insert(propIt->first);
}
return result;
}
void mitk::DataStorage::EmitAddNodeEvent(const mitk::DataNode* node)
{
AddNodeEvent.Send(node);
}
void mitk::DataStorage::EmitRemoveNodeEvent(const mitk::DataNode* node)
{
RemoveNodeEvent.Send(node);
}
void mitk::DataStorage::OnNodeModifiedOrDeleted( const itk::Object *caller, const itk::EventObject &event )
{
if(m_BlockNodeModifiedEvents)
return;
const mitk::DataNode* _Node = dynamic_cast<const mitk::DataNode*>(caller);
if(_Node)
{
const itk::ModifiedEvent* modEvent = dynamic_cast<const itk::ModifiedEvent*>(&event);
if(modEvent)
ChangedNodeEvent.Send(_Node);
else
DeleteNodeEvent.Send(_Node);
}
}
void mitk::DataStorage::AddListeners( const mitk::DataNode* _Node )
{
itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne);
// node must not be 0 and must not be yet registered
mitk::DataNode* NonConstNode = const_cast<mitk::DataNode*>(_Node);
if(_Node && m_NodeModifiedObserverTags
.find(NonConstNode) == m_NodeModifiedObserverTags.end())
{
itk::MemberCommand<mitk::DataStorage>::Pointer nodeModifiedCommand =
itk::MemberCommand<mitk::DataStorage>::New();
nodeModifiedCommand->SetCallbackFunction(this
, &mitk::DataStorage::OnNodeModifiedOrDeleted);
m_NodeModifiedObserverTags[NonConstNode]
= NonConstNode->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
// add itk delete listener on datastorage
itk::MemberCommand<mitk::DataStorage>::Pointer deleteCommand =
itk::MemberCommand<mitk::DataStorage>::New();
deleteCommand->SetCallbackFunction(this, &mitk::DataStorage::OnNodeModifiedOrDeleted);
// add observer
m_NodeDeleteObserverTags[NonConstNode]
= NonConstNode->AddObserver(itk::DeleteEvent(), deleteCommand);
}
}
void mitk::DataStorage::RemoveListeners( const mitk::DataNode* _Node )
{
itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne) ;
// node must not be 0 and must be registered
mitk::DataNode* NonConstNode = const_cast<mitk::DataNode*>(_Node);
if(_Node && m_NodeModifiedObserverTags
.find(NonConstNode) != m_NodeModifiedObserverTags.end())
{
// const cast is bad! but sometimes it is necessary. removing an observer does not really
// touch the internal state
NonConstNode->RemoveObserver(m_NodeModifiedObserverTags
.find(NonConstNode)->second);
NonConstNode->RemoveObserver(m_NodeDeleteObserverTags
.find(NonConstNode)->second);
m_NodeModifiedObserverTags.erase(NonConstNode);
m_NodeDeleteObserverTags.erase(NonConstNode);
}
}
mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const SetOfObjects* input, const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
if (input == NULL)
throw std::invalid_argument("DataStorage: input is invalid");
BoundingBox::PointsContainer::Pointer pointscontainer=BoundingBox::PointsContainer::New();
BoundingBox::PointIdentifier pointid=0;
Point3D point;
Vector3D minSpacing;
minSpacing.Fill(ScalarTypeNumericTraits::max());
ScalarType stmin, stmax;
stmin= ScalarTypeNumericTraits::NonpositiveMin();
stmax= ScalarTypeNumericTraits::max();
ScalarType minimalIntervallSize = stmax;
ScalarType minimalTime = stmax;
ScalarType maximalTime = 0;
// Needed for check of zero bounding boxes
mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
for (SetOfObjects::ConstIterator it = input->Begin(); it != input->End(); ++it)
{
DataNode::Pointer node = it->Value();
if((node.IsNotNull()) && (node->GetData() != NULL) &&
(node->GetData()->IsEmpty()==false) &&
node->IsOn(boolPropertyKey, renderer) &&
node->IsOn(boolPropertyKey2, renderer)
)
{
const TimeGeometry* timeGeometry = node->GetData()->GetUpdatedTimeGeometry();
if (timeGeometry != NULL )
{
// bounding box (only if non-zero)
BoundingBox::BoundsArrayType itkBounds = timeGeometry->GetBoundingBoxInWorld()->GetBounds();
if (itkBounds == itkBoundsZero)
{
continue;
}
unsigned char i;
for(i=0; i<8; ++i)
{
point = timeGeometry->GetCornerPointInWorld(i);
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. Node: " << node );
}
}
try
{
// time bounds
// iterate over all time steps
// Attention: Objects with zero bounding box are not respected in time bound calculation
for (TimeStepType i=0; i<timeGeometry->GetNumberOfTimeSteps(); i++)
{
Vector3D spacing = node->GetData()->GetGeometry(i)->GetSpacing();
for (int axis = 0; axis < 3; ++ axis)
{
if (spacing[axis] < minSpacing[axis]) minSpacing[axis] = spacing[axis];
}
const TimeBounds & curTimeBounds = node->GetData()->GetGeometry(i)->GetTimeBounds();
TimePointType currentTimePoint = node->GetData()->GetTimeGeometry()->TimeStepToTimePoint(i);
// get the minimal time of all objects in the DataStorage
- if ((curTimeBounds[0]+currentTimePoint<minimalTime)&&(curTimeBounds[0]+currentTimePoint>stmin))
+ if ((curTimeBounds[0]<minimalTime)&&(curTimeBounds[0]>stmin))
{
- minimalTime=curTimeBounds[0]+currentTimePoint;
+ minimalTime=curTimeBounds[0];
}
// get the maximal time of all objects in the DataStorage
- if ((curTimeBounds[1]+currentTimePoint>maximalTime)&&(curTimeBounds[1]<stmax))
+ if ((curTimeBounds[1]>maximalTime)&&(curTimeBounds[1]<stmax))
{
- maximalTime = curTimeBounds[1]+currentTimePoint;
+ maximalTime = curTimeBounds[1];
}
// get the minimal TimeBound of all time steps of the current DataNode
if (curTimeBounds[1]-curTimeBounds[0]<minimalIntervallSize)
{
minimalIntervallSize = curTimeBounds[1]-curTimeBounds[0];
}
}
}
catch(itk::ExceptionObject e)
{
MITK_ERROR << e << std::endl;
}
}
}
}
BoundingBox::Pointer result = BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
// minimal time bounds of a single time step for all geometries
TimeBounds minTimeBounds;
minTimeBounds[0] = 0;
minTimeBounds[1] = 1;
// compute the number of time steps
unsigned int numberOfTimeSteps = 1;
if (maximalTime!=0) // make sure that there is at least one time sliced geometry in the data storage
{
minTimeBounds[0] = minimalTime;
minTimeBounds[1] = minimalTime + minimalIntervallSize;
numberOfTimeSteps = static_cast<unsigned int>((maximalTime-minimalTime)/minimalIntervallSize);
}
TimeGeometry::Pointer timeGeometry = NULL;
if ( result->GetPoints()->Size()>0 )
{
// Initialize a geometry of a single time step
Geometry3D::Pointer geometry = Geometry3D::New();
geometry->Initialize();
// correct bounding-box (is now in mm, should be in index-coordinates)
// according to spacing
BoundingBox::BoundsArrayType bounds = result->GetBounds();
int i;
for(i = 0; i < 6; ++i)
{
bounds[i] /= minSpacing[i/2];
}
geometry->SetBounds(bounds);
geometry->SetSpacing(minSpacing);
geometry->SetTimeBounds(minTimeBounds);
// Initialize the time sliced geometry
timeGeometry = ProportionalTimeGeometry::New();
dynamic_cast<ProportionalTimeGeometry*>(timeGeometry.GetPointer())->Initialize(geometry,numberOfTimeSteps);
}
return timeGeometry;
}
mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
return this->ComputeBoundingGeometry3D(this->GetAll(), boolPropertyKey, renderer, boolPropertyKey2);
}
mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeVisibleBoundingGeometry3D( mitk::BaseRenderer* renderer, const char* boolPropertyKey )
{
return ComputeBoundingGeometry3D( "visible", renderer, boolPropertyKey );
}
mitk::BoundingBox::Pointer mitk::DataStorage::ComputeBoundingBox( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
BoundingBox::PointsContainer::Pointer pointscontainer=BoundingBox::PointsContainer::New();
BoundingBox::PointIdentifier pointid=0;
Point3D point;
// Needed for check of zero bounding boxes
mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
SetOfObjects::ConstPointer all = this->GetAll();
for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
DataNode::Pointer node = it->Value();
if((node.IsNotNull()) && (node->GetData() != NULL) &&
(node->GetData()->IsEmpty()==false) &&
node->IsOn(boolPropertyKey, renderer) &&
node->IsOn(boolPropertyKey2, renderer)
)
{
const TimeGeometry* geometry = node->GetData()->GetUpdatedTimeGeometry();
if (geometry != NULL )
{
// bounding box (only if non-zero)
BoundingBox::BoundsArrayType itkBounds = geometry->GetBoundingBoxInWorld()->GetBounds();
if (itkBounds == itkBoundsZero)
{
continue;
}
unsigned char i;
for(i=0; i<8; ++i)
{
point = geometry->GetCornerPointInWorld(i);
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. Node: " << node );
}
}
}
}
}
BoundingBox::Pointer result = BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
return result;
}
mitk::TimeBounds mitk::DataStorage::ComputeTimeBounds( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
TimeBounds timeBounds;
ScalarType stmin, stmax, cur;
stmin= ScalarTypeNumericTraits::NonpositiveMin();
stmax= ScalarTypeNumericTraits::max();
timeBounds[0]=stmax; timeBounds[1]=stmin;
SetOfObjects::ConstPointer all = this->GetAll();
for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
DataNode::Pointer node = it->Value();
if((node.IsNotNull()) && (node->GetData() != NULL) &&
(node->GetData()->IsEmpty()==false) &&
node->IsOn(boolPropertyKey, renderer) &&
node->IsOn(boolPropertyKey2, renderer)
)
{
const TimeGeometry* geometry = node->GetData()->GetUpdatedTimeGeometry();
if (geometry != NULL )
{
const TimeBounds & curTimeBounds = geometry->GetTimeBounds();
cur=curTimeBounds[0];
//is it after -infinity, but before everything else that we found until now?
if((cur > stmin) && (cur < timeBounds[0]))
timeBounds[0] = cur;
cur=curTimeBounds[1];
//is it before infinity, but after everything else that we found until now?
if((cur < stmax) && (cur > timeBounds[1]))
timeBounds[1] = cur;
}
}
}
if(!(timeBounds[0] < stmax))
{
timeBounds[0] = stmin;
timeBounds[1] = stmax;
}
return timeBounds;
}
diff --git a/Core/Code/DataManagement/mitkDisplayGeometry.cpp b/Core/Code/DataManagement/mitkDisplayGeometry.cpp
index 518a99ca0a..f8873400d0 100644
--- a/Core/Code/DataManagement/mitkDisplayGeometry.cpp
+++ b/Core/Code/DataManagement/mitkDisplayGeometry.cpp
@@ -1,635 +1,637 @@
/*===================================================================
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 "mitkDisplayGeometry.h"
mitk::AffineGeometryFrame3D::Pointer mitk::DisplayGeometry::Clone() const
{
- itkExceptionMacro(<<"calling mitk::DisplayGeometry::Clone does not make much sense.");
+// itkExceptionMacro(<<"calling mitk::DisplayGeometry::Clone does not make much sense.");
+ DisplayGeometry* returnValue = const_cast<DisplayGeometry *>(this);
+ return returnValue;
}
bool mitk::DisplayGeometry::IsValid() const
{
return m_Valid && m_WorldGeometry.IsNotNull() && m_WorldGeometry->IsValid();
}
unsigned long mitk::DisplayGeometry::GetMTime() const
{
if((m_WorldGeometry.IsNotNull()) && (Geometry2D::GetMTime() < m_WorldGeometry->GetMTime()))
{
Modified();
}
return Geometry2D::GetMTime();
}
const mitk::TimeBounds& mitk::DisplayGeometry::GetTimeBounds() const
{
if(m_WorldGeometry.IsNull())
{
return m_TimeBounds;
}
return m_WorldGeometry->GetTimeBounds();
}
// size definition methods
void mitk::DisplayGeometry::SetWorldGeometry(const Geometry2D* aWorldGeometry)
{
m_WorldGeometry = aWorldGeometry;
Modified();
}
bool mitk::DisplayGeometry::SetOriginInMM(const Vector2D& origin_mm)
{
m_OriginInMM = origin_mm;
WorldToDisplay(m_OriginInMM, m_OriginInDisplayUnits);
Modified();
return !this->RefitVisibleRect();
}
mitk::Vector2D mitk::DisplayGeometry::GetOriginInMM() const
{
return m_OriginInMM;
}
mitk::Vector2D mitk::DisplayGeometry::GetOriginInDisplayUnits() const
{
return m_OriginInDisplayUnits;
}
void mitk::DisplayGeometry::SetSizeInDisplayUnits(unsigned int width, unsigned int height, bool keepDisplayedRegion)
{
Vector2D oldSizeInMM( m_SizeInMM );
Point2D oldCenterInMM;
if(keepDisplayedRegion)
{
Point2D centerInDisplayUnits;
centerInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
centerInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;
DisplayToWorld(centerInDisplayUnits, oldCenterInMM);
}
m_SizeInDisplayUnits[0]=width;
m_SizeInDisplayUnits[1]=height;
if(m_SizeInDisplayUnits[0] <= 0)
m_SizeInDisplayUnits[0] = 1;
if(m_SizeInDisplayUnits[1] <= 0)
m_SizeInDisplayUnits[1] = 1;
DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);
if(keepDisplayedRegion)
{
Point2D positionOfOldCenterInCurrentDisplayUnits;
WorldToDisplay(oldCenterInMM, positionOfOldCenterInCurrentDisplayUnits);
Point2D currentNewCenterInDisplayUnits;
currentNewCenterInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
currentNewCenterInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;
Vector2D shift;
shift=positionOfOldCenterInCurrentDisplayUnits.GetVectorFromOrigin()-currentNewCenterInDisplayUnits;
MoveBy(shift);
Zoom(m_SizeInMM.GetNorm()/oldSizeInMM.GetNorm(), currentNewCenterInDisplayUnits);
}
Modified();
}
mitk::Vector2D mitk::DisplayGeometry::GetSizeInDisplayUnits() const
{
return m_SizeInDisplayUnits;
}
mitk::Vector2D mitk::DisplayGeometry::GetSizeInMM() const
{
return m_SizeInMM;
}
unsigned int mitk::DisplayGeometry::GetDisplayWidth() const
{
assert(m_SizeInDisplayUnits[0] >= 0);
return (unsigned int)m_SizeInDisplayUnits[0];
}
unsigned int mitk::DisplayGeometry::GetDisplayHeight() const
{
assert(m_SizeInDisplayUnits[1] >= 0);
return (unsigned int)m_SizeInDisplayUnits[1];
}
// zooming, panning, restriction of both
void mitk::DisplayGeometry::SetConstrainZoomingAndPanning(bool constrain)
{
m_ConstrainZoomingAndPanning = constrain;
if (m_ConstrainZoomingAndPanning)
{
this->RefitVisibleRect();
}
}
bool mitk::DisplayGeometry::GetConstrainZommingAndPanning() const
{
return m_ConstrainZoomingAndPanning;
}
bool mitk::DisplayGeometry::SetScaleFactor(ScalarType mmPerDisplayUnit)
{
if(mmPerDisplayUnit<0.0001)
{
mmPerDisplayUnit=0.0001;
}
m_ScaleFactorMMPerDisplayUnit = mmPerDisplayUnit;
assert(m_ScaleFactorMMPerDisplayUnit < ScalarTypeNumericTraits::infinity());
DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);
return !this->RefitVisibleRect();
}
mitk::ScalarType mitk::DisplayGeometry::GetScaleFactorMMPerDisplayUnit() const
{
return m_ScaleFactorMMPerDisplayUnit;
}
// Zooms with a factor (1.0=identity) around the specified center in display units
bool mitk::DisplayGeometry::Zoom(ScalarType factor, const Point2D& centerInDisplayUnits)
{
assert(factor > 0);
if ( SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor) )
{
return SetOriginInMM(m_OriginInMM-centerInDisplayUnits.GetVectorFromOrigin()*(1-factor)*m_ScaleFactorMMPerDisplayUnit);
}
else
{
return false;
}
}
// Zooms with a factor (1.0=identity) around the specified center, but tries (if its within view contraints) to match the center in display units with the center in world coordinates.
bool mitk::DisplayGeometry::ZoomWithFixedWorldCoordinates(ScalarType factor, const Point2D& focusDisplayUnits, const Point2D& focusUnitsInMM )
{
assert(factor > 0);
SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor);
SetOriginInMM(focusUnitsInMM.GetVectorFromOrigin()-focusDisplayUnits.GetVectorFromOrigin()*m_ScaleFactorMMPerDisplayUnit);
return true;
}
bool mitk::DisplayGeometry::MoveBy(const Vector2D& shiftInDisplayUnits)
{
SetOriginInMM(m_OriginInMM+shiftInDisplayUnits*m_ScaleFactorMMPerDisplayUnit);
Modified();
return !this->RefitVisibleRect();
}
void mitk::DisplayGeometry::Fit()
{
if((m_WorldGeometry.IsNull()) || (m_WorldGeometry->IsValid() == false)) return;
/// \FIXME: try to remove all the casts
int width=(int)m_SizeInDisplayUnits[0];
int height=(int)m_SizeInDisplayUnits[1];
ScalarType w = width;
ScalarType h = height;
const ScalarType& widthInMM = m_WorldGeometry->GetParametricExtentInMM(0);
const ScalarType& heightInMM = m_WorldGeometry->GetParametricExtentInMM(1);
ScalarType aspRatio=((ScalarType)widthInMM)/heightInMM;
ScalarType x = (ScalarType)w/widthInMM;
ScalarType y = (ScalarType)h/heightInMM;
if (x > y)
{
w = (int) (aspRatio*h);
}
else
{
h = (int) (w/aspRatio);
}
if(w>0)
{
SetScaleFactor(widthInMM/w);
}
Vector2D origin_display;
origin_display[0]=-(width-w)/2.0;
origin_display[1]=-(height-h)/2.0;
SetOriginInMM(origin_display*m_ScaleFactorMMPerDisplayUnit);
this->RefitVisibleRect();
Modified();
}
// conversion methods
void mitk::DisplayGeometry::DisplayToWorld(const Point2D &pt_display, Point2D &pt_mm) const
{
pt_mm[0]=m_ScaleFactorMMPerDisplayUnit*pt_display[0]+m_OriginInMM[0];
pt_mm[1]=m_ScaleFactorMMPerDisplayUnit*pt_display[1]+m_OriginInMM[1];
}
void mitk::DisplayGeometry::WorldToDisplay(const Point2D &pt_mm, Point2D &pt_display) const
{
pt_display[0]=(pt_mm[0]-m_OriginInMM[0])*(1.0/m_ScaleFactorMMPerDisplayUnit);
pt_display[1]=(pt_mm[1]-m_OriginInMM[1])*(1.0/m_ScaleFactorMMPerDisplayUnit);
}
void mitk::DisplayGeometry::DisplayToWorld(const Vector2D &vec_display, Vector2D &vec_mm) const
{
vec_mm=vec_display*m_ScaleFactorMMPerDisplayUnit;
}
void mitk::DisplayGeometry::WorldToDisplay(const Vector2D &vec_mm, Vector2D &vec_display) const
{
vec_display=vec_mm*(1.0/m_ScaleFactorMMPerDisplayUnit);
}
void mitk::DisplayGeometry::ULDisplayToMM(const Point2D &pt_ULdisplay, Point2D &pt_mm) const
{
ULDisplayToDisplay(pt_ULdisplay, pt_mm);
DisplayToWorld(pt_mm, pt_mm);
}
void mitk::DisplayGeometry::MMToULDisplay(const Point2D &pt_mm, Point2D &pt_ULdisplay) const
{
WorldToDisplay(pt_mm, pt_ULdisplay);
DisplayToULDisplay(pt_ULdisplay, pt_ULdisplay);
}
void mitk::DisplayGeometry::ULDisplayToMM(const Vector2D &vec_ULdisplay, Vector2D &vec_mm) const
{
ULDisplayToDisplay(vec_ULdisplay, vec_mm);
DisplayToWorld(vec_mm, vec_mm);
}
void mitk::DisplayGeometry::MMToULDisplay(const Vector2D &vec_mm, Vector2D &vec_ULdisplay) const
{
WorldToDisplay(vec_mm, vec_ULdisplay);
DisplayToULDisplay(vec_ULdisplay, vec_ULdisplay);
}
void mitk::DisplayGeometry::ULDisplayToDisplay(const Point2D &pt_ULdisplay, Point2D &pt_display) const
{
pt_display[0]=pt_ULdisplay[0];
pt_display[1]=GetDisplayHeight()-pt_ULdisplay[1];
}
void mitk::DisplayGeometry::DisplayToULDisplay(const Point2D &pt_display, Point2D &pt_ULdisplay) const
{
ULDisplayToDisplay(pt_display, pt_ULdisplay);
}
void mitk::DisplayGeometry::ULDisplayToDisplay(const Vector2D &vec_ULdisplay, Vector2D &vec_display) const
{
vec_display[0]= vec_ULdisplay[0];
vec_display[1]=-vec_ULdisplay[1];
}
void mitk::DisplayGeometry::DisplayToULDisplay(const Vector2D &vec_display, Vector2D &vec_ULdisplay) const
{
ULDisplayToDisplay(vec_display, vec_ULdisplay);
}
bool mitk::DisplayGeometry::Project(const Point3D &pt3d_mm, Point3D &projectedPt3d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Project(pt3d_mm, projectedPt3d_mm);
}
else
{
return false;
}
}
bool mitk::DisplayGeometry::Project(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Project(atPt3d_mm, vec3d_mm, projectedVec3d_mm);
}
else
{
return false;
}
}
bool mitk::DisplayGeometry::Project(const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Project(vec3d_mm, projectedVec3d_mm);
}
else
{
return false;
}
}
bool mitk::DisplayGeometry::Map(const Point3D &pt3d_mm, Point2D &pt2d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Map(pt3d_mm, pt2d_mm);
}
else
{
return false;
}
}
void mitk::DisplayGeometry::Map(const Point2D &pt2d_mm, Point3D &pt3d_mm) const
{
if(m_WorldGeometry.IsNull()) return;
m_WorldGeometry->Map(pt2d_mm, pt3d_mm);
}
bool mitk::DisplayGeometry::Map(const Point3D & atPt3d_mm, const Vector3D &vec3d_mm, Vector2D &vec2d_mm) const
{
if(m_WorldGeometry.IsNotNull())
{
return m_WorldGeometry->Map(atPt3d_mm, vec3d_mm, vec2d_mm);
}
else
{
return false;
}
}
void mitk::DisplayGeometry::Map(const Point2D & atPt2d_mm, const Vector2D &vec2d_mm, Vector3D &vec3d_mm) const
{
if(m_WorldGeometry.IsNull()) return;
m_WorldGeometry->Map(atPt2d_mm, vec2d_mm, vec3d_mm);
}
// protected methods
mitk::DisplayGeometry::DisplayGeometry()
:m_ScaleFactorMMPerDisplayUnit(1.0)
,m_WorldGeometry(NULL)
,m_ConstrainZoomingAndPanning(true)
,m_MaxWorldViewPercentage(1.0)
,m_MinWorldViewPercentage(0.1)
{
m_OriginInMM.Fill(0.0);
m_OriginInDisplayUnits.Fill(0.0);
m_SizeInMM.Fill(1.0);
m_SizeInDisplayUnits.Fill(10.0);
}
mitk::DisplayGeometry::~DisplayGeometry()
{
}
bool mitk::DisplayGeometry::RefitVisibleRect()
{
// do nothing if not asked to
if (!m_ConstrainZoomingAndPanning) return false;
// don't allow recursion (need to be fixed, singleton)
static bool inRecalculate = false;
if (inRecalculate) return false;
inRecalculate = true;
// rename some basic measures of the current viewport and world geometry (MM = milimeters Px = Pixels = display units)
float displayXMM = m_OriginInMM[0];
float displayYMM = m_OriginInMM[1];
float displayWidthPx = m_SizeInDisplayUnits[0];
float displayHeightPx = m_SizeInDisplayUnits[1];
float displayWidthMM = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
float displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;
float worldWidthMM = m_WorldGeometry->GetParametricExtentInMM(0);
float worldHeightMM = m_WorldGeometry->GetParametricExtentInMM(1);
// reserve variables for the correction logic to save a corrected origin and zoom factor
Vector2D newOrigin = m_OriginInMM;
bool correctPanning = false;
float newScaleFactor = m_ScaleFactorMMPerDisplayUnit;
bool correctZooming = false;
// start of the correction logic
// zoom to big means:
// at a given percentage of the world's width/height should be visible. Otherwise
// the whole screen could show only one pixel
//
// zoom to small means:
// zooming out should be limited at the point where the smaller of the world's sides is completely visible
bool zoomXtooSmall = displayWidthPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldWidthMM;
bool zoomXtooBig = displayWidthPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldWidthMM;
bool zoomYtooSmall = displayHeightPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldHeightMM;
bool zoomYtooBig = displayHeightPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldHeightMM;
// constrain zooming in both direction
if ( zoomXtooBig && zoomYtooBig)
{
double fx = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
double fy = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
newScaleFactor = fx < fy ? fx : fy;
correctZooming = true;
}
// constrain zooming in x direction
else if ( zoomXtooBig )
{
newScaleFactor = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
correctZooming = true;
}
// constrain zooming in y direction
else if ( zoomYtooBig )
{
newScaleFactor = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
correctZooming = true;
}
// constrain zooming out
// we stop zooming out at these situations:
//
// *** display
// --- image
//
// **********************
// * * x side maxed out
// * *
// *--------------------*
// *| |*
// *| |*
// *--------------------*
// * *
// * *
// * *
// **********************
//
// **********************
// * |------| * y side maxed out
// * | | *
// * | | *
// * | | *
// * | | *
// * | | *
// * | | *
// * | | *
// * |------| *
// **********************
//
// In both situations we center the not-maxed out direction
//
if ( zoomXtooSmall && zoomYtooSmall )
{
// determine and set the bigger scale factor
float fx = worldWidthMM * m_MaxWorldViewPercentage / displayWidthPx;
float fy = worldHeightMM * m_MaxWorldViewPercentage / displayHeightPx;
newScaleFactor = fx > fy ? fx : fy;
correctZooming = true;
}
// actually execute correction
if (correctZooming)
{
SetScaleFactor(newScaleFactor);
}
displayWidthMM = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;
// constrain panning
if(worldWidthMM<displayWidthMM)
{
// zoomed out too much in x (but tolerated because y is still ok)
// --> center x
newOrigin[0] = (worldWidthMM - displayWidthMM) / 2.0;
correctPanning = true;
}
else
{
// make sure left display border inside our world
if (displayXMM < 0)
{
newOrigin[0] = 0;
correctPanning = true;
}
// make sure right display border inside our world
else if (displayXMM + displayWidthMM > worldWidthMM)
{
newOrigin[0] = worldWidthMM - displayWidthMM;
correctPanning = true;
}
}
if (worldHeightMM<displayHeightMM)
{
// zoomed out too much in y (but tolerated because x is still ok)
// --> center y
newOrigin[1] = (worldHeightMM - displayHeightMM) / 2.0;
correctPanning = true;
}
else
{
// make sure top display border inside our world
if (displayYMM + displayHeightMM > worldHeightMM)
{
newOrigin[1] = worldHeightMM - displayHeightMM;
correctPanning = true;
}
// make sure bottom display border inside our world
else
if (displayYMM < 0)
{
newOrigin[1] = 0;
correctPanning = true;
}
}
if (correctPanning)
{
SetOriginInMM( newOrigin );
}
inRecalculate = false;
if ( correctPanning || correctZooming )
{
Modified();
}
// return true if any correction has been made
return correctPanning || correctZooming;
}
void mitk::DisplayGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
{
if(m_WorldGeometry.IsNull())
{
os << indent << " WorldGeometry: " << "NULL" << std::endl;
}
else
{
m_WorldGeometry->Print(os, indent);
os << indent << " OriginInMM: " << m_OriginInMM << std::endl;
os << indent << " OriginInDisplayUnits: " << m_OriginInDisplayUnits << std::endl;
os << indent << " SizeInMM: " << m_SizeInMM << std::endl;
os << indent << " SizeInDisplayUnits: " << m_SizeInDisplayUnits << std::endl;
os << indent << " ScaleFactorMMPerDisplayUni: " << m_ScaleFactorMMPerDisplayUnit << std::endl;
}
Superclass::PrintSelf(os,indent);
}
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
index 6837a3d712..65cf4fce18 100644
--- a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
@@ -1,179 +1,202 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkProportionalTimeGeometry.h>
+#include <limits>
-mitk::ProportionalTimeGeometry::ProportionalTimeGeometry()
+mitk::ProportionalTimeGeometry::ProportionalTimeGeometry() :
+ m_FirstTimePoint(0.0),
+ m_StepDuration(1.0)
{
}
mitk::ProportionalTimeGeometry::~ProportionalTimeGeometry()
{
}
void mitk::ProportionalTimeGeometry::Initialize()
{
+ m_FirstTimePoint = 0.0;
+ m_StepDuration = 1.0;
}
mitk::TimeStepType mitk::ProportionalTimeGeometry::GetNumberOfTimeSteps () const
{
return static_cast<TimeStepType>(m_GeometryVector.size() );
}
mitk::TimePointType mitk::ProportionalTimeGeometry::GetMinimumTimePoint () const
{
return m_FirstTimePoint;
}
mitk::TimePointType mitk::ProportionalTimeGeometry::GetMaximumTimePoint () const
{
return m_FirstTimePoint + m_StepDuration * GetNumberOfTimeSteps();
}
mitk::TimeBounds mitk::ProportionalTimeGeometry::GetTimeBounds () const
{
TimeBounds bounds;
bounds[0] = this->GetMinimumTimePoint();
bounds[1] = this->GetMaximumTimePoint();
return bounds;
}
bool mitk::ProportionalTimeGeometry::IsValidTimePoint (TimePointType timePoint) const
{
return this->GetMinimumTimePoint() <= timePoint && timePoint < this->GetMaximumTimePoint();
}
bool mitk::ProportionalTimeGeometry::IsValidTimeStep (TimeStepType timeStep) const
{
return 0 <= timeStep && timeStep < this->GetNumberOfTimeSteps();
}
mitk::TimePointType mitk::ProportionalTimeGeometry::TimeStepToTimePoint( TimeStepType timeStep) const
{
return m_FirstTimePoint + timeStep * m_StepDuration;
}
mitk::TimeStepType mitk::ProportionalTimeGeometry::TimePointToTimeStep( TimePointType timePoint) const
{
assert(timePoint >= m_FirstTimePoint);
return static_cast<TimeStepType>((timePoint -m_FirstTimePoint) / m_StepDuration);
}
mitk::Geometry3D* mitk::ProportionalTimeGeometry::GetGeometryForTimeStep( TimeStepType timeStep) const
{
if (IsValidTimeStep(timeStep))
{
return dynamic_cast<Geometry3D*>(m_GeometryVector[timeStep].GetPointer());
}
else
{
return NULL;
}
}
mitk::Geometry3D* mitk::ProportionalTimeGeometry::GetGeometryForTimePoint(TimePointType timePoint) const
{
TimeStepType timeStep = this->TimePointToTimeStep(timePoint);
return this->GetGeometryForTimeStep(timeStep);
}
mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryCloneForTimeStep( TimeStepType timeStep) const
{
return m_GeometryVector[timeStep].GetPointer();
}
bool mitk::ProportionalTimeGeometry::IsValid()
{
bool isValid = true;
isValid &= m_GeometryVector.size() > 0;
isValid &= m_StepDuration > 0;
return isValid;
}
void mitk::ProportionalTimeGeometry::ClearAllGeometries()
{
m_GeometryVector.clear();
}
void mitk::ProportionalTimeGeometry::ReserveSpaceForGeometries(TimeStepType numberOfGeometries)
{
m_GeometryVector.reserve(numberOfGeometries);
}
void mitk::ProportionalTimeGeometry::Expand(mitk::TimeStepType size)
{
m_GeometryVector.reserve(size);
while (m_GeometryVector.size() < size)
{
m_GeometryVector.push_back(Geometry3D::New());
}
}
void mitk::ProportionalTimeGeometry::SetTimeStepGeometry(Geometry3D *geometry, TimeStepType timeStep)
{
assert(timeStep<=m_GeometryVector.size());
assert(timeStep >= 0);
if (timeStep == m_GeometryVector.size())
m_GeometryVector.push_back(geometry);
m_GeometryVector[timeStep] = geometry;
}
mitk::TimeGeometry::Pointer mitk::ProportionalTimeGeometry::Clone() const
{
ProportionalTimeGeometry::Pointer newTimeGeometry = ProportionalTimeGeometry::New();
newTimeGeometry->m_BoundingBox = m_BoundingBox->DeepCopy();
newTimeGeometry->m_FirstTimePoint = this->m_FirstTimePoint;
newTimeGeometry->m_StepDuration = this->m_StepDuration;
newTimeGeometry->m_GeometryVector.clear();
newTimeGeometry->Expand(this->GetNumberOfTimeSteps());
for (TimeStepType i =0; i < GetNumberOfTimeSteps(); ++i)
{
AffineGeometryFrame3D::Pointer pointer = GetGeometryForTimeStep(i)->Clone();
Geometry3D* tempGeometry = dynamic_cast<Geometry3D*> (pointer.GetPointer());
newTimeGeometry->SetTimeStepGeometry(tempGeometry,i);
}
TimeGeometry::Pointer finalPointer = dynamic_cast<TimeGeometry*>(newTimeGeometry.GetPointer());
return finalPointer;
}
void mitk::ProportionalTimeGeometry::Initialize (Geometry3D * geometry, TimeStepType timeSteps)
{
timeSteps = (timeSteps > 0) ? timeSteps : 1;
m_FirstTimePoint = geometry->GetTimeBounds()[0];
m_StepDuration = geometry->GetTimeBounds()[1] - geometry->GetTimeBounds()[0];
this->ReserveSpaceForGeometries(timeSteps);
+ try{
for (TimeStepType currentStep = 0; currentStep < timeSteps; ++currentStep)
{
- //AffineGeometryFrame3D::Pointer clonedGeometry = geometry->Clone();
- this->SetTimeStepGeometry(geometry, currentStep);
+ mitk::TimeBounds timeBounds;
+ if (timeSteps > 1)
+ {
+ timeBounds[0] = m_FirstTimePoint + currentStep * m_StepDuration;
+ timeBounds[1] = m_FirstTimePoint + (currentStep+1) * m_StepDuration;
+ }
+ else
+ {
+ timeBounds = geometry->GetTimeBounds();
+ }
+
+ AffineGeometryFrame3D::Pointer clonedGeometry = geometry->Clone();
+ this->SetTimeStepGeometry(dynamic_cast<Geometry3D*> (clonedGeometry.GetPointer()), currentStep);
+ GetGeometryForTimeStep(currentStep)->SetTimeBounds(timeBounds);
+ }
+ }
+ catch (...)
+ {
+ MITK_INFO << "Cloning of geometry produced an error!";
}
Update();
}
void mitk::ProportionalTimeGeometry::Initialize (TimeStepType timeSteps)
{
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->Initialize();
if ( timeSteps > 1 )
{
mitk::ScalarType timeBounds[] = {0.0, 1.0};
geometry->SetTimeBounds( timeBounds );
}
this->Initialize(geometry.GetPointer(), timeSteps);
}
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.cpp b/Core/Code/DataManagement/mitkTimeGeometry.cpp
index 407b55d9df..530f6c4779 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkTimeGeometry.cpp
@@ -1,153 +1,153 @@
/*===================================================================
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 <mitkTimeGeometry.h>
mitk::TimeGeometry::TimeGeometry() :
m_BoundingBox(BoundingBox::New())
{
typedef BoundingBox::PointsContainer ContainerType;
ContainerType::Pointer points = ContainerType::New();
m_BoundingBox->SetPoints(points.GetPointer());
}
mitk::TimeGeometry::~TimeGeometry()
{
}
void mitk::TimeGeometry::Initialize()
{
}
/* \brief short description
* parameters
*
*/
mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorld(int id) const
{
assert(id >= 0);
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
Point3D cornerpoint;
switch(id)
{
case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break;
case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break;
case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break;
case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break;
case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break;
case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break;
case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break;
case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break;
default:
{
itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7.");
return NULL;
}
}
// TimeGeometry has no Transformation. Therefore the bounding box
// contains all data in world coordinates
return cornerpoint;
}
mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorld(bool xFront, bool yFront, bool zFront) const
{
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
Point3D cornerpoint;
cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
return cornerpoint;
}
mitk::Point3D mitk::TimeGeometry::GetCenterInWorld() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox->GetCenter();
}
double mitk::TimeGeometry::GetDiagonalLength2InWorld() const
{
Vector3D diagonalvector = GetCornerPointInWorld()-GetCornerPointInWorld(false, false, false);
return diagonalvector.GetSquaredNorm();
}
double mitk::TimeGeometry::GetDiagonalLengthinWorld() const
{
return sqrt(GetDiagonalLength2InWorld());
}
bool mitk::TimeGeometry::IsWorldPointInside(const mitk::Point3D& p) const
{
return m_BoundingBox->IsInside(p);
}
void mitk::TimeGeometry::UpdateBoundingBox ()
{
assert(m_BoundingBox.IsNotNull());
typedef BoundingBox::PointsContainer ContainerType;
unsigned long lastModifiedTime = 0;
unsigned long currentModifiedTime = 0;
ContainerType::Pointer points = ContainerType::New();
points->reserve(2*GetNumberOfTimeSteps());
for (TimeStepType step = 0; step <GetNumberOfTimeSteps(); ++step)
{
currentModifiedTime = GetGeometryForTimeStep(step)->GetMTime();
if (currentModifiedTime > lastModifiedTime)
lastModifiedTime = currentModifiedTime;
-
Point3D minimum = GetGeometryForTimeStep(step)->GetCornerPoint(false,false,false);
Point3D maximum = GetGeometryForTimeStep(step)->GetCornerPoint(true,true,true);
points->push_back(minimum);
points->push_back(maximum);
}
m_BoundingBox->SetPoints(points);
m_BoundingBox->ComputeBoundingBox();
- this->Modified();
+ if (this->GetMTime() < lastModifiedTime)
+ this->Modified();
}
mitk::ScalarType mitk::TimeGeometry::GetExtendInWorld (unsigned int direction) const
{
assert(direction < 3);
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
return bounds[direction * 2 + 1] - bounds[direction * 2];
}
void mitk::TimeGeometry::Update()
{
this->UpdateBoundingBox();
this->UpdateWithoutBoundingBox();
}
void mitk::TimeGeometry::ExecuteOperation(mitk::Operation* op)
{
for (TimeStepType step = 0; step < GetNumberOfTimeSteps(); ++step)
{
GetGeometryForTimeStep(step)->ExecuteOperation(op);
}
}
diff --git a/Core/Code/Interactions/mitkPointSetInteractor.cpp b/Core/Code/Interactions/mitkPointSetInteractor.cpp
index 1fbee816a6..d3c4695f15 100644
--- a/Core/Code/Interactions/mitkPointSetInteractor.cpp
+++ b/Core/Code/Interactions/mitkPointSetInteractor.cpp
@@ -1,1119 +1,1119 @@
/*===================================================================
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 "mitkPointSetInteractor.h"
#include "mitkPointOperation.h"
#include "mitkPositionEvent.h"
#include "mitkPointSet.h"
//#include "mitkStatusBar.h"
#include "mitkDataNode.h"
#include "mitkInteractionConst.h"
#include "mitkAction.h"
#include "mitkStateEvent.h"
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#include "mitkStateMachineFactory.h"
#include "mitkStateTransitionOperation.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
//how precise must the user pick the point
//default value
const int PRECISION = 5;
mitk::PointSetInteractor
::PointSetInteractor(const char * type, DataNode* dataNode, int n)
:Interactor(type, dataNode), m_Precision(PRECISION), m_N(n)
{
if (m_N==0)
{
STATEMACHINE_WARN<<"Instanciation of PointSetInteractor which takes care of 0 points does't make sense!\n";
STATEMACHINE_WARN<<"Setting number of points to 1!\n";
m_N = 1;
}
m_LastPoint.Fill(0);
m_SumVec.Fill(0);
this->InitAccordingToNumberOfPoints();
}
mitk::PointSetInteractor::~PointSetInteractor()
{
}
//##Documentation
//## overwritten cause this class can handle it better!
float mitk::PointSetInteractor::CanHandleEvent(StateEvent const* stateEvent) const
{
float returnValue = 0.0;
//if it is a key event that can be handled in the current state, then return 0.5
mitk::DisplayPositionEvent const *disPosEvent =
dynamic_cast <const mitk::DisplayPositionEvent *> (stateEvent->GetEvent());
//Key event handling:
if (disPosEvent == NULL)
{
//check, if the current state has a transition waiting for that key event.
if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
{return 0.5;}
else
{return 0;}
}
//on MouseMove do nothing!
if (stateEvent->GetEvent()->GetType() == mitk::Type_MouseMove)
{return 0;}
//get the time of the sender to look for the right transition.
mitk::BaseRenderer* sender = stateEvent->GetEvent()->GetSender();
if (sender != NULL)
{
- unsigned int timeStep = sender->GetTimeStep(m_DataNode->GetData());
+ int timeStep = sender->GetTimeStep(m_DataNode->GetData());
//if the event can be understood and if there is a transition waiting for that event
mitk::State const* state = this->GetCurrentState(timeStep);
if (state!= NULL)
if (state->GetTransition(stateEvent->GetId())!=NULL)
returnValue = 0.5;//it can be understood
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if ( pointSet != NULL )
{
//if we have one point or more, then check if the have been picked
if ( (pointSet->GetSize( timeStep ) > 0)
&& (pointSet->SearchPoint(
disPosEvent->GetWorldPosition(), m_Precision, timeStep) > -1) )
{returnValue = 1.0;}
}
}
return returnValue;
}
//TODO: add a new calculation of precision here! Input: StateEvent and Precision
//the method does a 2D picking with display coordinates and display geometry.
//Here the distance between the mouse position and the point is not as relative anymore!
//float mitk::PointSetInteractor::CalculatePrecision(float precision, mitk::StateEvent stateEvent)
//{
// mitk::BaseRenderer *renderer = stateEvent->GetEvent()->GetSender();
// if (renderer != NULL)
// {
// const mitk::DisplayGeometry* displayGeometry = renderer->GetDisplayGeometry();
// if (displayGeometry != NULL)
// displayGeometry->WorldToDisplay(, lineFrom);
// precision =
// }
//
// return precision;
//
//}
void mitk::PointSetInteractor::UnselectAll( unsigned int timeStep, ScalarType timeInMS )
{
mitk::PointSet *pointSet =
dynamic_cast<mitk::PointSet*>( m_DataNode->GetData() );
if ( pointSet == NULL )
{
return;
}
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet( timeStep );
if ( itkPointSet == NULL )
{
return;
}
mitk::PointSet::PointsContainer::Iterator it, end;
end = itkPointSet->GetPoints()->End();
for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
{
int position = it->Index();
PointSet::PointDataType pointData = {0, false, PTUNDEFINED};
itkPointSet->GetPointData( position, &pointData );
//then declare an operation which unselects this point;
//UndoOperation as well!
if ( pointData.selected )
{
mitk::Point3D noPoint;
noPoint.Fill( 0 );
mitk::PointOperation *doOp = new mitk::PointOperation(
OpDESELECTPOINT, timeInMS, noPoint, position);
if ( m_UndoEnabled )
{
mitk::PointOperation *undoOp =
new mitk::PointOperation(OpSELECTPOINT, timeInMS, noPoint, position);
OperationEvent *operationEvent =
new OperationEvent( pointSet, doOp, undoOp );
m_UndoController->SetOperationEvent( operationEvent );
}
pointSet->ExecuteOperation( doOp );
if ( !m_UndoEnabled )
delete doOp;
}
}
}
void mitk::PointSetInteractor::SelectPoint( int position, unsigned int timeStep, ScalarType timeInMS )
{
mitk::PointSet *pointSet = dynamic_cast< mitk::PointSet * >(
m_DataNode->GetData() );
//if List is empty, then no select of a point can be done!
if ( (pointSet == NULL) || (pointSet->GetSize( timeStep ) <= 0) )
{
return;
}
//dummyPoint... not needed anyway
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation *doOp = new mitk::PointOperation(
OpSELECTPOINT, timeInMS, noPoint, position);
if ( m_UndoEnabled )
{
mitk::PointOperation* undoOp = new mitk::PointOperation(
OpDESELECTPOINT, timeInMS, noPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
pointSet->ExecuteOperation( doOp );
if ( !m_UndoEnabled )
delete doOp;
}
bool mitk::PointSetInteractor::ExecuteAction( Action* action, mitk::StateEvent const* stateEvent )
{
bool ok = false;//for return type bool
//checking corresponding Data; has to be a PointSet or a subclass
mitk::PointSet* pointSet =
dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if ( pointSet == NULL )
{
return false;
}
//get the timestep to support 3D+T
const mitk::Event *theEvent = stateEvent->GetEvent();
mitk::ScalarType timeInMS = 0.0;
//check if the current timestep has to be changed
if ( theEvent )
{
if (theEvent->GetSender() != NULL)
{
//additionaly to m_TimeStep we need timeInMS to satisfy the execution of the operations
timeInMS = theEvent->GetSender()->GetTime();
}
}
//for reading on the points, Id's etc
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet( m_TimeStep );
if ( itkPointSet == NULL )
{
return false;
}
mitk::PointSet::PointsContainer *points = itkPointSet->GetPoints();
/*Each case must watch the type of the event!*/
switch (action->GetActionId())
{
case AcDONOTHING:
ok = true;
break;
case AcCHECKOPERATION:
//to check if the given Event is a DisplayPositionEvent.
{
mitk::DisplayPositionEvent const *dispPosEvent =
dynamic_cast <const mitk::DisplayPositionEvent *> (
stateEvent->GetEvent());
if (dispPosEvent != NULL)
{
mitk::StateEvent newStateEvent(EIDYES, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
}
else
{
mitk::StateEvent newStateEvent(EIDNO, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
}
ok = true;
break;
}
case AcADDPOINT:
// Declare two operations: one for the selected state: deselect the last
// one selected and select the new one the other operation is the add
// operation: There the first empty place have to be found and the new
// point inserted into that space
{
mitk::DisplayPositionEvent const *posEvent =
dynamic_cast < const mitk::DisplayPositionEvent * >
(stateEvent->GetEvent());
// Check if it is a DisplayEvent thrown in a 3D window. Then the
// z-information is missing. Returning false might end in the state
// full, but the last point couldn't be added, so the set wouldn't be
// full. So a extra Action that checks the operationtype has been added.
if ( posEvent == NULL )
{
return false;
}
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
// undo-supported deselect of all points in the DataList; if List is
// empty, then nothing will be unselected
this->UnselectAll( m_TimeStep, timeInMS );
// find the position, the point is to be added to: first entry with
// empty index. If the Set is empty, then start with 0. if not empty,
// then take the first index not occupied
int lastPosition = 0;
if (!points->empty())
{
mitk::PointSet::PointsIterator it, end;
it = points->Begin();
end = points->End();
while( it != end )
{
if (!points->IndexExists(lastPosition))
break;
++it;
++lastPosition;
}
}
PointOperation* doOp = new mitk::PointOperation(
OpINSERT, timeInMS, itkPoint, lastPosition);
if (m_UndoEnabled)
{
// difference between OpDELETE and OpREMOVE is, that OpDELETE deletes
// a point at the end, and OpREMOVE deletes it from the given position
// remove is better, cause we need the position to add or remove the
// point anyway. We can get the last position from size()
PointOperation *undoOp = new mitk::PointOperation(
OpREMOVE, timeInMS, itkPoint, lastPosition);
OperationEvent *operationEvent =
new OperationEvent(pointSet, doOp, undoOp, "Add point");
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
//the point is added and directly selected in PintSet. So no need to call OpSELECTPOINT
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcINITMOVEMENT:
{
mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
// start of the Movement is stored to calculate the undoKoordinate
// in FinishMovement
m_LastPoint = posEvent->GetWorldPosition();
// initialize a value to calculate the movement through all
// MouseMoveEvents from MouseClick to MouseRelease
m_SumVec.Fill(0);
ok = true;
break;
}
case AcMOVESELECTED://moves all selected Elements
{
mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
mitk::Point3D newPoint, resultPoint;
newPoint = posEvent->GetWorldPosition();
// search the elements in the list that are selected then calculate the
// vector, because only with the vector we can move several elements in
// the same direction
// newPoint - lastPoint = vector
// then move all selected and set the lastPoint = newPoint.
// then add all vectors to a summeryVector (to be able to calculate the
// startpoint for undoOperation)
mitk::Vector3D dirVector = newPoint - m_LastPoint;
//sum up all Movement for Undo in FinishMovement
m_SumVec = m_SumVec + dirVector;
mitk::PointSet::PointsIterator it, end;
it = points->Begin();
end = points->End();
while( it != end )
{
int position = it->Index();
if ( pointSet->GetSelectInfo(position, m_TimeStep) )//if selected
{
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
mitk::Point3D sumVec;
sumVec[0] = pt[0];
sumVec[1] = pt[1];
sumVec[2] = pt[2];
resultPoint = sumVec + dirVector;
PointOperation doOp(OpMOVE, timeInMS, resultPoint, position);
//execute the Operation
//here no undo is stored, because the movement-steps aren't interesting.
// only the start and the end is interisting to store for undo.
pointSet->ExecuteOperation(&doOp);
}
++it;
}
m_LastPoint = newPoint;//for calculation of the direction vector
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcREMOVEPOINT://remove the given Point from the list
{
//if the point to be removed is given by the positionEvent:
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent != NULL)
{
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
//search the point in the list
int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
//distance set to 0, cause we already got the exact point from last
//State checkpointbut we also need the position in the list to remove it
if (position>=0)//found a point
{
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
//Undo
PointOperation* doOp = new mitk::PointOperation(OpREMOVE,
timeInMS, itkPoint, position);
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpINSERT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet,
doOp, undoOp, "Remove point");
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
/*now select the point "position-1",
and if it is the first in list,
then contine at the last in list*/
//only then a select of a point is possible!
if (pointSet->GetSize( m_TimeStep ) > 0)
{
if (position>0)//not the first in list
{
this->SelectPoint( position-1, m_TimeStep, timeInMS );
}
//it was the first point in list, that was removed, so select
//the last in list
else
{
position = pointSet->GetSize( m_TimeStep ) - 1; //last in list
this->SelectPoint( position, m_TimeStep, timeInMS );
}//else
}//if
ok = true;
}
}
else //no position is given so remove all selected elements
{
//delete all selected points
//search for the selected one and then declare the operations!
mitk::PointSet::PointsContainer::Iterator it, end;
it = points->Begin();
end = points->End();
int position = 0;
int previousExistingPosition = -1;//to recognize the last existing position; needed because the iterator gets invalid if the point is deleted!
int lastDelPrevExistPosition = -1; //the previous position of the last deleted point
while (it != end)
{
if (points->IndexExists(it->Index()))
{
//if point is selected
if ( pointSet->GetSelectInfo(it->Index(), m_TimeStep) )
{
//get the coordinates of that point to be undoable
PointSet::PointType selectedPoint = it->Value();
mitk::Point3D itkPoint;
itkPoint[0] = selectedPoint[0];
itkPoint[1] = selectedPoint[1];
itkPoint[2] = selectedPoint[2];
position = it->Index();
PointOperation* doOp = new mitk::PointOperation(OpREMOVE,
timeInMS, itkPoint, position);
//Undo
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpINSERT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet,
doOp, undoOp, "Remove point");
m_UndoController->SetOperationEvent(operationEvent);
}
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
//after delete the iterator is undefined, so start again
//count to the last existing entry
if (points->Size()>1 && points->IndexExists(previousExistingPosition))
{
for (it = points->Begin(); it != points->End(); it++)
{
if (it->Index() == (unsigned int) previousExistingPosition)
{
lastDelPrevExistPosition = previousExistingPosition;
break; //return if the iterator on the last existing position is found
}
}
}
else // size <= 1 or no previous existing position set
{
//search for the first existing position
for (it = points->Begin(); it != points->End(); it++)
if (points->IndexExists(it->Index()))
{
previousExistingPosition = it->Index();
break;
}
}
//now that we have set the iterator, lets get sure, that the next it++ will not crash!
if (it == end) { break; }
}//if
else
{
previousExistingPosition = it->Index();
}
}//if index exists
it++;
}//while
if (lastDelPrevExistPosition < 0)//the var has not been set because the first element was deleted and there was no prev position
lastDelPrevExistPosition = previousExistingPosition; //go to the end
/*
* now select the point before the point/points that was/were deleted
*/
if (pointSet->GetSize( m_TimeStep ) > 0) //only then a select of a point is possible!
{
if (points->IndexExists(lastDelPrevExistPosition))
{
this->SelectPoint( lastDelPrevExistPosition, m_TimeStep, timeInMS );
}
else
{
//select the first existing element
for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); it++)
if (points->IndexExists(it->Index()))
{
this->SelectPoint( it->Index(), m_TimeStep, timeInMS );
break;
}
}
}//if
ok = true;
}//else
}//case
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
// Remove all Points that have been set at once.
// TODO: Undo function not supported yet.
case AcREMOVEALL:
{
if ( !points->empty() )
{
PointSet::PointType pt;
mitk::PointSet::PointsContainer::Iterator it, end;
it = points->Begin();
end = points->End();
int position = 0;
while ( it != end )
{
position = it->Index();
if ( points->IndexExists( position ) )
{
pt = pointSet->GetPoint( position, m_TimeStep );
PointOperation doOp( OpREMOVE, timeInMS, pt, position );
++it;
pointSet->ExecuteOperation( &doOp );
}
else it++;
}
}
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
//Checking if the Point transmitted is close enough to one point. Then
//generate a new event with the point and let this statemaschine
//handle the event.
case AcCHECKELEMENT:
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent != NULL)
{
mitk::Point3D worldPoint = posEvent->GetWorldPosition();
int position = pointSet->SearchPoint( worldPoint, m_Precision, m_TimeStep );
if (position>=0)//found a point near enough to the given point
{
//get that point, the one meant by the user!
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
mitk::Point2D displPoint;
displPoint[0] = worldPoint[0]; displPoint[1] = worldPoint[1];
//new Event with information YES and with the correct point
mitk::PositionEvent newPosEvent(posEvent->GetSender(), Type_None,
BS_NoButton, BS_NoButton, Key_none, displPoint, pt);
mitk::StateEvent newStateEvent(EIDYES, &newPosEvent);
//call HandleEvent to leave the guard-state
this->HandleEvent( &newStateEvent );
ok = true;
}
else
{
//new Event with information NO
mitk::StateEvent newStateEvent(EIDNO, posEvent);
this->HandleEvent(&newStateEvent );
ok = true;
}
}
else
{
MITK_DEBUG("OperationError")<<this->GetType()<<" AcCHECKELEMENT expected PointOperation.";
mitk::DisplayPositionEvent const *disPosEvent =
dynamic_cast <const mitk::DisplayPositionEvent *> (
stateEvent->GetEvent());
if (disPosEvent != NULL)
{ //2d Koordinates for 3D Interaction; return false to redo
//the last statechange
mitk::StateEvent newStateEvent(EIDNO, disPosEvent);
this->HandleEvent(&newStateEvent);
ok = true;
}
}
break;
}
case AcCHECKONESELECTED:
//check if there is a point that is selected
{
if (pointSet->GetNumberOfSelected(m_TimeStep)>0)
{
mitk::StateEvent newStateEvent( EIDYES, theEvent);
this->HandleEvent( &newStateEvent );
}
else //not selected then call event EIDNO
{
//new Event with information NO
mitk::StateEvent newStateEvent( EIDNO, theEvent);
this->HandleEvent( &newStateEvent );
}
ok = true;
break;
}
case AcCHECKSELECTED:
/*check, if the given point is selected:
if no, then send EIDNO
if yes, then send EIDYES*/
// check, if: because of the need to look up the point again, it is
// possible, that we grab the wrong point in case there are two same points
// so maybe we do have to set a global index for further computation,
// as long, as the mouse is moved...
{
int position = -1;
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
mitk::Point3D worldPoint = posEvent->GetWorldPosition();
position = pointSet->SearchPoint(worldPoint, m_Precision, m_TimeStep);
if (position>=0)
{
mitk::PositionEvent const *newPosEvent =
new mitk::PositionEvent(posEvent->GetSender(),
posEvent->GetType(), posEvent->GetButton(),
posEvent->GetButtonState(), posEvent->GetKey(),
posEvent->GetDisplayPosition(), posEvent->GetWorldPosition());
//if selected on true, then call Event EIDYES
if (pointSet->GetSelectInfo(position, m_TimeStep))
{
mitk::StateEvent newStateEvent( EIDYES, newPosEvent );
this->HandleEvent( &newStateEvent );
ok = true;
//saving the spot for calculating the direction vector in moving
m_LastPoint = posEvent->GetWorldPosition();
}
else //not selected then call event EIDNO
{
//new Event with information NO
mitk::StateEvent newStateEvent( EIDNO, newPosEvent );
this->HandleEvent( &newStateEvent );
ok = true;
}
delete newPosEvent;
}
//the position wasn't set properly. If necessary: search the given
//point in list and set var position
else
{
/*
mitk::StatusBar::GetInstance()->DisplayText(
"Message from mitkPointSetInteractor: Error in Actions! Check Config XML-file",
10000);
*/
ok = false;
}
break;
}
//generate Events if the set will be full after the addition of the
// point or not.
case AcCHECKNMINUS1:
{
// number of points not limited->pass on
// "Amount of points in Set is smaller then N-1"
if (m_N<0)
{
mitk::StateEvent newStateEvent(EIDSTSMALERNMINUS1, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else
{
if (pointSet->GetSize( m_TimeStep ) < m_N-1 )
//pointset after addition won't be full
{
mitk::StateEvent newStateEvent(EIDSTSMALERNMINUS1, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else
//after the addition of a point, the container will be full
{
mitk::StateEvent newStateEvent(EIDSTLARGERNMINUS1, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}//else
}//else
}
break;
case AcCHECKEQUALS1:
{
//the number of points in the list is 1 (or smaler)
if (pointSet->GetSize( m_TimeStep ) <= 1)
{
mitk::StateEvent newStateEvent(EIDYES, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else //more than 1 points in list, so stay in the state!
{
mitk::StateEvent newStateEvent(EIDNO, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
}
break;
case AcCHECKNUMBEROFPOINTS:
{
//the number of points in the list is 1 (or smaler), so will be empty after delete
if (pointSet->GetSize( m_TimeStep ) <= 1)
{
mitk::StateEvent newStateEvent(EIDEMPTY, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else if (pointSet->GetSize( m_TimeStep ) <= m_N || m_N <= -1)
//m_N is set to unlimited points allowed or more than 1 points in list, but not full, so stay in the state!
{
// if the number of points equals m_N and no point of the point set is selected switch to state EIDEQUALSN
if ((pointSet->GetSize( m_TimeStep ) == m_N)&&(pointSet->GetNumberOfSelected()==0))
{
mitk::StateEvent newStateEvent(EIDEQUALSN, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
// if the number of points is small than or equal m_N and point(s) are selected stay in state
else
{
mitk::StateEvent newStateEvent(EIDSMALLERN, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
}
else
//pointSet->GetSize( m_TimeStep ) >=m_N.
// This can happen if the points were not added
// by interaction but by loading a .mps file
{
mitk::StateEvent newStateEvent(EIDEQUALSN, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
}
break;
case AcSELECTPICKEDOBJECT://and deselect others
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL) return false;
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
//search the point in the list
int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
//distance set to 0, cause we already got the exact point from last
//State checkpoint but we also need the position in the list to move it
if (position>=0)//found a point
{
//first deselect the other points
//undoable deselect of all points in the DataList
this->UnselectAll( m_TimeStep, timeInMS);
PointOperation* doOp = new mitk::PointOperation(OpSELECTPOINT,
timeInMS, itkPoint, position);
//Undo
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent =
new OperationEvent(pointSet, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
ok = true;
}
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcDESELECTOBJECT:
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
//search the point in the list
int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
//distance set to 0, cause we already got the exact point from last
// State checkpoint but we also need the position in the list to move it
if (position>=0)//found a point
{
//Undo
PointOperation* doOp = new mitk::PointOperation(OpDESELECTPOINT,
timeInMS, itkPoint, position);
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
ok = true;
}
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcDESELECTALL:
{
//undo-supported able deselect of all points in the DataList
this->UnselectAll( m_TimeStep, timeInMS );
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcFINISHMOVEMENT:
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
//finish the movement:
//the final point is m_LastPoint
//m_SumVec stores the movement in a vector
//the operation would not be necessary, but we need it for the undo Operation.
//m_LastPoint is for the Operation
//the point for undoOperation calculates from all selected
//elements (point) - m_SumVec
//search all selected elements and move them with undo-functionality.
mitk::PointSet::PointsIterator it, end;
it = points->Begin();
end = points->End();
while( it != end )
{
int position = it->Index();
if ( pointSet->GetSelectInfo(position, m_TimeStep) )//if selected
{
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
Point3D itkPoint;
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
PointOperation* doOp = new mitk::PointOperation(OpMOVE,
timeInMS, itkPoint, position);
if ( m_UndoEnabled )//&& (posEvent->GetType() == mitk::Type_MouseButtonRelease)
{
//set the undo-operation, so the final position is undo-able
//calculate the old Position from the already moved position - m_SumVec
mitk::Point3D undoPoint = ( itkPoint - m_SumVec );
PointOperation* undoOp =
new mitk::PointOperation(OpMOVE, timeInMS, undoPoint, position);
OperationEvent *operationEvent =
new OperationEvent(pointSet, doOp, undoOp, "Move point");
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
}
++it;
}
//set every variable for movement calculation to zero
// commented out: increases usebility in derived classes.
/*m_LastPoint.Fill(0);
m_SumVec.Fill(0);*/
//increase the GroupEventId, so that the Undo goes to here
this->IncCurrGroupEventId();
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcCLEAR:
{
this->Clear( m_TimeStep, timeInMS );
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
default:
return Superclass::ExecuteAction( action, stateEvent );
}
// indicate modification of data tree node
m_DataNode->Modified();
return ok;
}
void mitk::PointSetInteractor::Clear( unsigned int timeStep, ScalarType timeInMS )
{
mitk::Point3D point;
point.Fill(0);
mitk::PointSet *pointSet =
dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if ( pointSet == NULL )
{
return;
}
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet( timeStep );
if ( itkPointSet == NULL )
{
return;
}
//for reading on the points, Id's etc
mitk::PointSet::PointsContainer *points = itkPointSet->GetPoints();
mitk::PointSet::PointsIterator it, end;
it = points->Begin();
end = points->End();
while( (it != end) && (pointSet->GetSize( timeStep ) > 0) )
{
point = pointSet->GetPoint( it->Index(), timeStep );
PointOperation *doOp = new mitk::PointOperation(
OpREMOVE, timeInMS, point, it->Index());
//write to UndoMechanism
if ( m_UndoEnabled )
{
PointOperation *undoOp = new mitk::PointOperation(
OpINSERT, timeInMS, point, it->Index());
OperationEvent *operationEvent =
new OperationEvent( pointSet, doOp, undoOp );
m_UndoController->SetOperationEvent( operationEvent );
}
//execute the Operation
++it;
pointSet->ExecuteOperation( doOp );
if ( !m_UndoEnabled )
delete doOp;
}
//reset the statemachine
this->ResetStatemachineToStartState(timeStep);
}
void mitk::PointSetInteractor::InitAccordingToNumberOfPoints()
{
if (m_DataNode == NULL)
return;
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if ( pointSet != NULL )
{
//resize the CurrentStateVector
this->ExpandStartStateVector(pointSet->GetPointSetSeriesSize());
for (unsigned int timestep = 0; timestep < pointSet->GetPointSetSeriesSize(); timestep++)
{
//go to new timestep
this->UpdateTimeStep(timestep);
int numberOfPoints = pointSet->GetSize( timestep );
if (numberOfPoints == 0)
continue; //pointset is empty
else
{
//we have a set of loaded points. Deselect all points, because they are all set to selected when added!
this->UnselectAll(timestep);
if (numberOfPoints<m_N || m_N <= -1)//if less than specified or specified as unlimited
{
//get the currentState to state "SpaceLeft"
const mitk::Event nullEvent(NULL, Type_User, BS_NoButton, BS_NoButton, Key_none);
mitk::StateEvent newStateEvent(EIDSMALLERN, &nullEvent);
this->HandleEvent( &newStateEvent );
}
else if (numberOfPoints>=m_N)
{
if (numberOfPoints>m_N)
{
STATEMACHINE_WARN<<"Point Set contains more points than needed!\n";//display a warning that there are too many points
}
//get the currentState to state "Set full"
const mitk::Event nullEvent(NULL, Type_User, BS_NoButton, BS_NoButton, Key_none);
mitk::StateEvent newStateEvent(EIDEQUALSN, &nullEvent);
this->HandleEvent( &newStateEvent );
}
}
}
}
return;
}
void mitk::PointSetInteractor::DataChanged()
{
this->InitAccordingToNumberOfPoints();
return;
}
diff --git a/Core/Code/Testing/mitkImageTest.cpp b/Core/Code/Testing/mitkImageTest.cpp
index 808757b76f..1ef628bdfe 100644
--- a/Core/Code/Testing/mitkImageTest.cpp
+++ b/Core/Code/Testing/mitkImageTest.cpp
@@ -1,375 +1,381 @@
/*===================================================================
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.
===================================================================*/
// mitk includes
#include <mitkImage.h>
#include <mitkImageDataItem.h>
#include <mitkImageCast.h>
#include "mitkItkImageFileReader.h"
#include <mitkTestingMacros.h>
#include <mitkImageStatisticsHolder.h>
// itk includes
#include <itkImage.h>
#include <itkMersenneTwisterRandomVariateGenerator.h>
// stl includes
#include <fstream>
// vtk includes
#include <vtkImageData.h>
// Checks if reference count is correct after using GetVtkImageData()
bool ImageVtkDataReferenceCheck(const char* fname) {
const std::string filename = std::string(fname);
mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
try
{
imageReader->SetFileName(filename);
imageReader->Update();
}
catch(...) {
MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
return false;
}
{
mitk::Image::Pointer image = imageReader->GetOutput();
vtkImageData* vtk = image->GetVtkImageData();
if(vtk == NULL)
return false;
if(image->GetExternalReferenceCount() != 1)
return false;
}
return true;
}
int mitkImageTest(int argc, char* argv[])
{
MITK_TEST_BEGIN(mitkImageTest);
//Create Image out of nowhere
mitk::Image::Pointer imgMem = mitk::Image::New();
mitk::PixelType pt = mitk::MakeScalarPixelType<int>();
unsigned int dim[]={100,100,20};
MITK_TEST_CONDITION_REQUIRED( imgMem.IsNotNull(), "An image was created. ");
// Initialize image
imgMem->Initialize( pt, 3, dim);
MITK_TEST_CONDITION_REQUIRED( imgMem->IsInitialized(), "Image::IsInitialized() ?");
MITK_TEST_CONDITION_REQUIRED( imgMem->GetPixelType() == pt, "PixelType was set correctly.");
int *p = (int*)imgMem->GetData();
MITK_TEST_CONDITION( p != NULL, "GetData() returned not-NULL pointer.");
// FIXME: this is directly changing the image data
// filling image
const unsigned int size = dim[0]*dim[1]*dim[2];
for(unsigned int i=0; i<size; ++i, ++p)
*p= (signed int)i;
// Getting it again and compare with filled values:
int *p2 = (int*)imgMem->GetData();
MITK_TEST_CONDITION( p2 != NULL, "GetData() returned not-NULL pointer.");
bool isEqual = true;
for(unsigned int i=0; i<size; ++i, ++p2)
{
if(*p2 != (signed int) i )
{
isEqual = false;
}
}
MITK_TEST_CONDITION( isEqual, "The values previously set as data are correct [pixelwise comparison].");
// Testing GetSliceData() and compare with filled values:
p2 = (int*)imgMem->GetSliceData(dim[2]/2)->GetData();
MITK_TEST_CONDITION_REQUIRED( p2 != NULL, "Valid slice data returned");
unsigned int xy_size = dim[0]*dim[1];
unsigned int start_mid_slice = (dim[2]/2)*xy_size;
isEqual = true;
for(unsigned int i=0; i<xy_size; ++i, ++p2)
{
if(*p2!=(signed int)(i+start_mid_slice))
{
isEqual = false;
}
}
MITK_TEST_CONDITION( isEqual, "The SliceData are correct [pixelwise comparison]. ");
imgMem = mitk::Image::New();
// testing re-initialization of test image
mitk::PixelType pType = mitk::MakePixelType<int, int, 1>();
imgMem->Initialize( pType , 3, dim);
MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension()== 3, "Testing initialization parameter dimension!");
MITK_TEST_CONDITION_REQUIRED(imgMem->GetPixelType() == pType, "Testing initialization parameter pixeltype!");
MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension(0) == dim[0] &&
imgMem->GetDimension(1)== dim[1] && imgMem->GetDimension(2)== dim[2], "Testing initialization of dimensions!");
MITK_TEST_CONDITION( imgMem->IsInitialized(), "Image is initialized.");
// Setting volume again:
imgMem->SetVolume(imgMem->GetData());
//-----------------
// geometry information for image
mitk::Point3D origin;
mitk::Vector3D right, bottom;
mitk::Vector3D spacing;
mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
mitk::FillVector3D(right, 1.0, 2.0, 3.0);
mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
//InitializeStandardPlane(rightVector, downVector, spacing)
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
planegeometry->SetOrigin(origin);
// Testing Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int slices) with PlaneGeometry and GetData(): ";
imgMem->Initialize( mitk::MakePixelType<int, int, 1>(), *planegeometry);
MITK_TEST_CONDITION_REQUIRED( imgMem->GetGeometry()->GetOrigin() == static_cast<mitk::Geometry3D*>(planegeometry)->GetOrigin(), "Testing correct setting of geometry via initialize!");
p = (int*)imgMem->GetData();
MITK_TEST_CONDITION_REQUIRED( p!=NULL, "GetData() returned valid pointer.");
// Testing Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry) and GetData(): ";
imgMem->Initialize( mitk::MakePixelType<int, int, 1>() , 40, *planegeometry);
p = (int*)imgMem->GetData();
MITK_TEST_CONDITION_REQUIRED( p!=NULL, "GetData() returned valid pointer.");
//-----------------
// testing origin information and methods
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of origin via GetGeometry()->GetOrigin(): ");
// Setting origin via SetOrigin(origin): ";
mitk::FillVector3D(origin, 37.0, 17.92, 27.83); imgMem->SetOrigin(origin);
// Test origin
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of changed origin via GetGeometry()->GetOrigin(): ");
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(), origin), "Testing correctness of changed origin via GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(): ");
//-----------------
// testing spacing information and methods
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correct spacing from Geometry3D!");
mitk::FillVector3D(spacing, 7.0, 0.92, 1.83);
imgMem->SetSpacing(spacing);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correctness of changed spacing via GetGeometry()->GetSpacing(): ");
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(), spacing), "Testing correctness of changed spacing via GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(): ");
mitk::Image::Pointer vecImg = mitk::Image::New();
vecImg->Initialize( imgMem->GetPixelType(), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/ );
vecImg->SetImportChannel(imgMem->GetData(), 0, mitk::Image::CopyMemory );
vecImg->SetImportChannel(imgMem->GetData(), 1, mitk::Image::CopyMemory );
MITK_TEST_CONDITION_REQUIRED(vecImg->GetChannelData(0)->GetData() != NULL && vecImg->GetChannelData(1)->GetData() != NULL, "Testing set and return of channel data!");
MITK_TEST_CONDITION_REQUIRED( vecImg->IsValidSlice(0,0,1) , "");
MITK_TEST_OUTPUT(<< " Testing whether CopyMemory worked");
MITK_TEST_CONDITION_REQUIRED(imgMem->GetData() != vecImg->GetData(), "");
MITK_TEST_OUTPUT(<< " Testing destruction after SetImportChannel");
vecImg = NULL;
MITK_TEST_CONDITION_REQUIRED(vecImg.IsNull() , "testing destruction!");
//-----------------
MITK_TEST_OUTPUT(<< "Testing initialization via vtkImageData");
MITK_TEST_OUTPUT(<< " Setting up vtkImageData");
vtkImageData* vtkimage = vtkImageData::New();
vtkimage->Initialize();
vtkimage->SetDimensions( 2, 3, 4);
double vtkorigin[] = {-350,-358.203, -1363.5};
vtkimage->SetOrigin(vtkorigin);
mitk::Point3D vtkoriginAsMitkPoint;
mitk::vtk2itk(vtkorigin, vtkoriginAsMitkPoint);
double vtkspacing[] = {1.367, 1.367, 2};
vtkimage->SetSpacing(vtkspacing);
vtkimage->SetScalarType( VTK_SHORT );
vtkimage->AllocateScalars();
std::cout<<"[PASSED]"<<std::endl;
MITK_TEST_OUTPUT(<< " Testing mitk::Image::Initialize(vtkImageData*, ...)");
mitk::Image::Pointer mitkByVtkImage = mitk::Image::New();
mitkByVtkImage ->Initialize(vtkimage);
MITK_TEST_CONDITION_REQUIRED(mitkByVtkImage->IsInitialized(), "");
vtkimage->Delete();
MITK_TEST_OUTPUT(<< " Testing whether spacing has been correctly initialized from vtkImageData");
mitk::Vector3D spacing2 = mitkByVtkImage->GetGeometry()->GetSpacing();
mitk::Vector3D vtkspacingAsMitkVector;
mitk::vtk2itk(vtkspacing, vtkspacingAsMitkVector);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(spacing2,vtkspacingAsMitkVector), "");
MITK_TEST_OUTPUT(<< " Testing whether GetSlicedGeometry(0)->GetOrigin() has been correctly initialized from vtkImageData");
mitk::Point3D origin2 = mitkByVtkImage->GetSlicedGeometry(0)->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
MITK_TEST_OUTPUT(<< " Testing whether GetGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
origin2 = mitkByVtkImage->GetGeometry()->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
// TODO test the following initializers on channel-incorporation
// void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions, unsigned int channels)
// void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
// void mitk::Image::Initialize(const mitk::Image* image)
// void mitk::Image::Initialize(const mitkIpPicDescriptor* pic, int channels, int tDim, int sDim)
//mitk::Image::Pointer vecImg = mitk::Image::New();
//vecImg->Initialize(PixelType(typeid(float), 6, itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
//vecImg->Initialize(PixelType(typeid(itk::Vector<float,6>)), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
// testing access by index coordinates and by world coordinates
MITK_TEST_CONDITION_REQUIRED(argc == 2, "Check if test image is accessible!");
const std::string filename = std::string(argv[1]);
mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
try
{
imageReader->SetFileName(filename);
imageReader->Update();
}
catch(...) {
MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
return 0;
}
mitk::Image::Pointer image = imageReader->GetOutput();
// generate a random point in world coordinates
mitk::Point3D xMax, yMax, zMax, xMaxIndex, yMaxIndex, zMaxIndex;
xMaxIndex.Fill(0.0f);
yMaxIndex.Fill(0.0f);
zMaxIndex.Fill(0.0f);
xMaxIndex[0] = image->GetLargestPossibleRegion().GetSize()[0];
yMaxIndex[1] = image->GetLargestPossibleRegion().GetSize()[1];
zMaxIndex[2] = image->GetLargestPossibleRegion().GetSize()[2];
image->GetGeometry()->IndexToWorld(xMaxIndex, xMax);
image->GetGeometry()->IndexToWorld(yMaxIndex, yMax);
image->GetGeometry()->IndexToWorld(zMaxIndex, zMax);
MITK_INFO << "Origin " << image->GetGeometry()->GetOrigin()[0] << " "<< image->GetGeometry()->GetOrigin()[1] << " "<< image->GetGeometry()->GetOrigin()[2] << "";
MITK_INFO << "MaxExtend " << xMax[0] << " "<< yMax[1] << " "<< zMax[2] << "";
mitk::Point3D point;
itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
randomGenerator->Initialize( std::rand() ); // initialize with random value, to get sensible random points for the image
point[0] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[0], xMax[0]);
point[1] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[1], yMax[1]);
point[2] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[2], zMax[2]);
MITK_INFO << "RandomPoint " << point[0] << " "<< point[1] << " "<< point[2] << "";
// test values and max/min
mitk::ScalarType imageMin = image->GetStatistics()->GetScalarValueMin();
mitk::ScalarType imageMax = image->GetStatistics()->GetScalarValueMax();
mitk::ScalarType value = image->GetPixelValueByWorldCoordinate(point);
MITK_INFO << imageMin << " "<< imageMax << " "<< value << "";
MITK_TEST_CONDITION( (value >= imageMin && value <= imageMax), "Value returned is between max/min");
// test accessing PixelValue with coordinate leading to a negative index
const mitk::Point3D geom_origin = image->GetGeometry()->GetOrigin();
const mitk::Point3D geom_center = image->GetGeometry()->GetCenter();
const unsigned int timestep = 0;
// shift position from origin outside of the image ( in the opposite direction to [center-origin] vector which points in the inside)
mitk::Point3D position = geom_origin + (geom_origin - geom_center);
MITK_TEST_CONDITION_REQUIRED( image->GetPixelValueByWorldCoordinate(position, timestep) == 0, "Test access to the outside of the image")
-
+ {
// testing the clone method of mitk::Image
mitk::Image::Pointer cloneImage = image->Clone();
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension() == image->GetDimension(), "Clone (testing dimension)");
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetPixelType() == image->GetPixelType(), "Clone (testing pixel type)");
// After cloning an image the geometry of both images should be equal too
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetOrigin() == image->GetGeometry()->GetOrigin(), "Clone (testing origin)");
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetSpacing() == image->GetGeometry()->GetSpacing(), "Clone (testing spacing)");
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetGeometry()->GetIndexToWorldTransform()->GetMatrix(), image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix()),
"Clone (testing transformation matrix)");
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetTimeGeometry()->GetGeometryForTimeStep(cloneImage->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix(),
cloneImage->GetTimeGeometry()->GetGeometryForTimeStep(image->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix()), "Clone(testing time sliced geometry)");
for (unsigned int i = 0u; i < cloneImage->GetDimension(); ++i)
{
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension(i) == image->GetDimension(i), "Clone (testing dimension " << i << ")");
}
-
+ }
//access via itk
if(image->GetDimension()> 3) // CastToItk only works with 3d images so we need to check for 4d images
{
mitk::ImageTimeSelector::Pointer selector = mitk::ImageTimeSelector::New();
selector->SetTimeNr(0);
selector->SetInput(image);
selector->Update();
image = selector->GetOutput();
}
if(image->GetDimension()==3)
{
- typedef itk::Image<float,3> ItkFloatImage3D;
+ typedef itk::Image<double,3> ItkFloatImage3D;
ItkFloatImage3D::Pointer itkimage;
+ try
+ {
mitk::CastToItkImage(image, itkimage);
MITK_TEST_CONDITION_REQUIRED(itkimage.IsNotNull(), "Test conversion to itk::Image!");
-
+ }
+ catch (std::exception& e)
+ {
+ MITK_INFO << e.what();
+ }
mitk::Point3D itkPhysicalPoint;
image->GetGeometry()->WorldToItkPhysicalPoint(point, itkPhysicalPoint);
MITK_INFO << "ITKPoint " << itkPhysicalPoint[0] << " "<< itkPhysicalPoint[1] << " "<< itkPhysicalPoint[2] << "";
mitk::Point3D backTransformedPoint;
image->GetGeometry()->ItkPhysicalPointToWorld(itkPhysicalPoint, backTransformedPoint);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(point,backTransformedPoint), "Testing world->itk-physical->world consistency");
itk::Index<3> idx;
bool status = itkimage->TransformPhysicalPointToIndex(itkPhysicalPoint, idx);
MITK_INFO << "ITK Index " << idx[0] << " "<< idx[1] << " "<< idx[2] << "";
if(status)
{
float valByItk = itkimage->GetPixel(idx);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(valByItk, value), "Compare value of pixel returned by mitk in comparison to itk");
}
else
{
MITK_WARN<< "Index is out buffered region!";
}
}
else
{
MITK_INFO << "Image does not contain three dimensions, some test cases are skipped!";
}
// clone generated 3D image with one slice in z direction (cf. bug 11058)
unsigned int* threeDdim = new unsigned int[3];
threeDdim[0] = 100;
threeDdim[1] = 200;
threeDdim[2] = 1;
mitk::Image::Pointer threeDImage = mitk::Image::New();
threeDImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, threeDdim);
mitk::Image::Pointer cloneThreeDImage = threeDImage->Clone();
// check that the clone image has the same dimensionality as the source image
MITK_TEST_CONDITION_REQUIRED( cloneThreeDImage->GetDimension() == 3, "Testing if the clone image initializes with 3D!");
MITK_TEST_CONDITION_REQUIRED( ImageVtkDataReferenceCheck(argv[1]), "Checking reference count of Image after using GetVtkImageData()");
MITK_TEST_END();
}