diff --git a/Core/Code/Controllers/mitkSliceNavigationController.cpp b/Core/Code/Controllers/mitkSliceNavigationController.cpp
index aa35c2545c..1cac802cfb 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,754 +1,759 @@
/*===================================================================
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 "mitkSliceNavigationController.h"
#include "mitkBaseRenderer.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkPlaneGeometry.h"
#include "mitkOperation.h"
#include "mitkOperationActor.h"
#include "mitkStateEvent.h"
#include "mitkCrosshairPositionEvent.h"
#include "mitkPositionEvent.h"
#include "mitkProportionalTimeGeometry.h"
#include "mitkInteractionConst.h"
#include "mitkAction.h"
#include "mitkGlobalInteraction.h"
#include "mitkEventMapper.h"
#include "mitkFocusManager.h"
#include "mitkVtkPropRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkInteractionConst.h"
#include "mitkPointOperation.h"
#include "mitkPlaneOperation.h"
#include "mitkUndoController.h"
#include "mitkOperationEvent.h"
#include "mitkNodePredicateDataType.h"
#include "mitkStatusBar.h"
#include "mitkMemoryUtilities.h"
#include <itkCommand.h>
namespace mitk {
SliceNavigationController::SliceNavigationController( const char *type )
: BaseController( type ),
m_InputWorldGeometry3D( NULL ),
m_InputWorldTimeGeometry( NULL ),
m_CreatedWorldGeometry( NULL ),
m_ViewDirection( Axial ),
m_DefaultViewDirection( Axial ),
m_RenderingManager( NULL ),
m_Renderer( NULL ),
m_Top( false ),
m_FrontSide( false ),
m_Rotated( false ),
m_BlockUpdate( false ),
m_SliceLocked( false ),
m_SliceRotationLocked( false ),
m_OldPos(0)
{
typedef itk::SimpleMemberCommand< SliceNavigationController > SNCCommandType;
SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
sliceStepperChangedCommand = SNCCommandType::New();
timeStepperChangedCommand = SNCCommandType::New();
sliceStepperChangedCommand->SetCallbackFunction(
this, &SliceNavigationController::SendSlice );
timeStepperChangedCommand->SetCallbackFunction(
this, &SliceNavigationController::SendTime );
m_Slice->AddObserver( itk::ModifiedEvent(), sliceStepperChangedCommand );
m_Time->AddObserver( itk::ModifiedEvent(), timeStepperChangedCommand );
m_Slice->SetUnitName( "mm" );
m_Time->SetUnitName( "ms" );
m_Top = false;
m_FrontSide = false;
m_Rotated = false;
}
SliceNavigationController::~SliceNavigationController()
{
}
void
SliceNavigationController::SetInputWorldGeometry3D( const Geometry3D *geometry )
{
if ( geometry != NULL )
{
if ( const_cast< BoundingBox * >( geometry->GetBoundingBox())
->GetDiagonalLength2() < eps )
{
itkWarningMacro( "setting an empty bounding-box" );
geometry = NULL;
}
}
if ( m_InputWorldGeometry3D != geometry )
{
m_InputWorldGeometry3D = geometry;
m_InputWorldTimeGeometry = NULL;
this->Modified();
}
}
void
SliceNavigationController::SetInputWorldTimeGeometry( const TimeGeometry *geometry )
{
if ( geometry != NULL )
{
if ( const_cast< BoundingBox * >( geometry->GetBoundingBoxInWorld())
->GetDiagonalLength2() < eps )
{
itkWarningMacro( "setting an empty bounding-box" );
geometry = NULL;
}
}
if ( m_InputWorldTimeGeometry != geometry )
{
m_InputWorldTimeGeometry = geometry;
m_InputWorldGeometry3D = NULL;
this->Modified();
}
}
RenderingManager *
SliceNavigationController::GetRenderingManager() const
{
mitk::RenderingManager* renderingManager = m_RenderingManager.GetPointer();
if (renderingManager != NULL)
return renderingManager;
if ( m_Renderer != NULL )
{
renderingManager = m_Renderer->GetRenderingManager();
if (renderingManager != NULL)
return renderingManager;
}
return mitk::RenderingManager::GetInstance();
}
void SliceNavigationController::SetViewDirectionToDefault()
{
m_ViewDirection = m_DefaultViewDirection;
}
void SliceNavigationController::Update()
{
if ( !m_BlockUpdate )
{
if ( m_ViewDirection == Axial )
{
this->Update( Axial, false, false, true );
}
else
{
this->Update( m_ViewDirection );
}
}
}
void
SliceNavigationController::Update(
SliceNavigationController::ViewDirection viewDirection,
bool top, bool frontside, bool rotated )
{
const TimeGeometry* worldTimeGeometry = m_InputWorldTimeGeometry.GetPointer();
if( m_BlockUpdate ||
( m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull() ) ||
( (worldTimeGeometry != NULL) && (worldTimeGeometry->GetNumberOfTimeSteps() == 0) )
)
{
return;
}
m_BlockUpdate = true;
- if ( m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime() )
+ if ( m_InputWorldTimeGeometry.IsNotNull() &&
+ m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime() )
+ {
+ Modified();
+ }
+ if ( m_InputWorldGeometry3D.IsNotNull() &&
+ m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime() )
{
Modified();
}
-
this->SetViewDirection( viewDirection );
this->SetTop( top );
this->SetFrontSide( frontside );
this->SetRotated( rotated );
if ( m_LastUpdateTime < GetMTime() )
{
m_LastUpdateTime = GetMTime();
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry = NULL;
m_CreatedWorldGeometry = NULL;
switch ( viewDirection )
{
case Original:
if ( worldTimeGeometry != NULL )
{
m_CreatedWorldGeometry = worldTimeGeometry->Clone().GetPointer();
worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ) );
if ( slicedWorldGeometry.IsNotNull() )
{
break;
}
}
else
{
const SlicedGeometry3D *worldSlicedGeometry =
dynamic_cast< const SlicedGeometry3D * >(
m_InputWorldGeometry3D.GetPointer());
if ( worldSlicedGeometry != NULL )
{
slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
m_InputWorldGeometry3D->Clone().GetPointer());
break;
}
}
//else: use Axial: no "break" here!!
case Axial:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(
m_InputWorldGeometry3D, PlaneGeometry::Axial,
top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry3D,
PlaneGeometry::Frontal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry3D,
PlaneGeometry::Sagittal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
default:
itkExceptionMacro("unknown ViewDirection");
}
m_Slice->SetPos( 0 );
m_Slice->SetSteps( (int)slicedWorldGeometry->GetSlices() );
if ( m_CreatedWorldGeometry.IsNull() )
{
// initialize TimeGeometry
m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
}
if ( worldTimeGeometry == NULL )
{
m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, 1);
m_Time->SetSteps( 0 );
m_Time->SetPos( 0 );
m_Time->InvalidateRange();
}
else
{
m_BlockUpdate = true;
m_Time->SetSteps( worldTimeGeometry->GetNumberOfTimeSteps() );
m_Time->SetPos( 0 );
const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
m_Time->SetRange( timeBounds[0], timeBounds[1] );
m_BlockUpdate = false;
assert( worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ) != NULL );
slicedWorldGeometry->SetTimeBounds(
worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() )->GetTimeBounds() );
//@todo implement for non-evenly-timed geometry!
m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, worldTimeGeometry->GetNumberOfTimeSteps());
}
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}
void
SliceNavigationController::SendCreatedWorldGeometry()
{
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry.
if ( !m_BlockUpdate )
{
this->InvokeEvent( GeometrySendEvent(m_CreatedWorldGeometry, 0) );
}
}
void
SliceNavigationController::SendCreatedWorldGeometryUpdate()
{
if ( !m_BlockUpdate )
{
this->InvokeEvent(
GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
}
}
void
SliceNavigationController::SendSlice()
{
if ( !m_BlockUpdate )
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
this->InvokeEvent(
GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
// send crosshair event
crosshairPositionEvent.Send();
// Request rendering update for all views
this->GetRenderingManager()->RequestUpdateAll();
}
}
}
void
SliceNavigationController::SendTime()
{
if ( !m_BlockUpdate )
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
this->InvokeEvent(
GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()) );
// Request rendering update for all views
this->GetRenderingManager()->RequestUpdateAll();
}
}
}
void
SliceNavigationController::SetGeometry( const itk::EventObject & )
{
}
void
SliceNavigationController
::SetGeometryTime( const itk::EventObject &geometryTimeEvent )
{
const SliceNavigationController::GeometryTimeEvent *timeEvent =
dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(
&geometryTimeEvent);
assert( timeEvent != NULL );
TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
assert( timeGeometry != NULL );
if ( m_CreatedWorldGeometry.IsNotNull() )
{
int timeStep = (int) timeEvent->GetPos();
ScalarType timeInMS;
timeInMS = timeGeometry->TimeStepToTimePoint( timeStep );
timeStep = m_CreatedWorldGeometry->TimePointToTimeStep( timeInMS );
this->GetTime()->SetPos( timeStep );
}
}
void
SliceNavigationController
::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
{
const SliceNavigationController::GeometrySliceEvent* sliceEvent =
dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(
&geometrySliceEvent);
assert(sliceEvent!=NULL);
this->GetSlice()->SetPos(sliceEvent->GetPos());
}
void
SliceNavigationController::SelectSliceByPoint( const Point3D &point )
{
//@todo add time to PositionEvent and use here!!
SlicedGeometry3D* slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ) );
if ( slicedWorldGeometry )
{
int bestSlice = -1;
double bestDistance = itk::NumericTraits<double>::max();
int s, slices;
slices = slicedWorldGeometry->GetSlices();
if ( slicedWorldGeometry->GetEvenlySpaced() )
{
mitk::Geometry2D *plane = slicedWorldGeometry->GetGeometry2D( 0 );
const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
Point3D projectedPoint;
plane->Project( point, projectedPoint );
// Check whether the point is somewhere within the slice stack volume;
// otherwise, the defualt slice (0) will be selected
if ( direction[0] * (point[0] - projectedPoint[0])
+ direction[1] * (point[1] - projectedPoint[1])
+ direction[2] * (point[2] - projectedPoint[2]) >= 0 )
{
bestSlice = (int)(plane->Distance( point )
/ slicedWorldGeometry->GetSpacing()[2] + 0.5);
}
}
else
{
Point3D projectedPoint;
for ( s = 0; s < slices; ++s )
{
slicedWorldGeometry->GetGeometry2D( s )->Project( point, projectedPoint );
Vector3D distance = projectedPoint - point;
ScalarType currentDistance = distance.GetSquaredNorm();
if ( currentDistance < bestDistance )
{
bestDistance = currentDistance;
bestSlice = s;
}
}
}
if ( bestSlice >= 0 )
{
this->GetSlice()->SetPos( bestSlice );
}
else
{
this->GetSlice()->SetPos( 0 );
}
this->SendCreatedWorldGeometryUpdate();
}
}
void
SliceNavigationController::ReorientSlices( const Point3D &point,
const Vector3D &normal )
{
PlaneOperation op( OpORIENT, point, normal );
m_CreatedWorldGeometry->ExecuteOperation( &op );
this->SendCreatedWorldGeometryUpdate();
}
void SliceNavigationController::ReorientSlices(const mitk::Point3D &point,
const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1 )
{
PlaneOperation op( OpORIENT, point, axisVec0, axisVec1 );
m_CreatedWorldGeometry->ExecuteOperation( &op );
this->SendCreatedWorldGeometryUpdate();
}
mitk::TimeGeometry *
SliceNavigationController::GetCreatedWorldGeometry()
{
return m_CreatedWorldGeometry;
}
const mitk::Geometry3D *
SliceNavigationController::GetCurrentGeometry3D()
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
return m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() );
}
else
{
return NULL;
}
}
const mitk::PlaneGeometry *
SliceNavigationController::GetCurrentPlaneGeometry()
{
const mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast< const mitk::SlicedGeometry3D * >
( this->GetCurrentGeometry3D() );
if ( slicedGeometry )
{
const mitk::PlaneGeometry *planeGeometry =
dynamic_cast< mitk::PlaneGeometry * >
( slicedGeometry->GetGeometry2D(this->GetSlice()->GetPos()) );
return planeGeometry;
}
else
{
return NULL;
}
}
void
SliceNavigationController::SetRenderer( BaseRenderer *renderer )
{
m_Renderer = renderer;
}
BaseRenderer *
SliceNavigationController::GetRenderer() const
{
return m_Renderer;
}
void
SliceNavigationController::AdjustSliceStepperRange()
{
const mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast< const mitk::SlicedGeometry3D * >
( this->GetCurrentGeometry3D() );
const Vector3D &direction = slicedGeometry->GetDirectionVector();
int c = 0;
int i, k = 0;
for ( i = 0; i < 3; ++i )
{
if ( fabs( (float) direction[i] ) < 0.000000001 ) { ++c; }
else { k = i; }
}
if ( c == 2 )
{
ScalarType min = slicedGeometry->GetOrigin()[k];
ScalarType max = min + slicedGeometry->GetExtentInMM( k );
m_Slice->SetRange( min, max );
}
else
{
m_Slice->InvalidateRange();
}
}
void
SliceNavigationController::ExecuteOperation( Operation *operation )
{
// switch on type
// - select best slice for a given point
// - rotate created world geometry according to Operation->SomeInfo()
if ( !operation )
{
return;
}
switch ( operation->GetOperationType() )
{
case OpMOVE: // should be a point operation
{
if ( !m_SliceLocked ) //do not move the cross position
{
// select a slice
PointOperation *po = dynamic_cast< PointOperation * >( operation );
if ( po && po->GetIndex() == -1 )
{
this->SelectSliceByPoint( po->GetPoint() );
}
else if ( po && po->GetIndex() != -1 ) // undo case because index != -1, index holds the old position of this slice
{
this->GetSlice()->SetPos( po->GetIndex() );
}
}
break;
}
case OpRESTOREPLANEPOSITION:
{
m_CreatedWorldGeometry->ExecuteOperation( operation );
this->SendCreatedWorldGeometryUpdate();
break;
}
default:
{
// do nothing
break;
}
}
}
// Relict from the old times, when automous decisions were accepted
// behavior. Remains in here, because some RenderWindows do exist outside
// of StdMultiWidgets.
bool
SliceNavigationController
::ExecuteAction( Action* action, StateEvent const* stateEvent )
{
bool ok = false;
const PositionEvent* posEvent = dynamic_cast< const PositionEvent * >(
stateEvent->GetEvent() );
if ( posEvent != NULL )
{
if ( m_CreatedWorldGeometry.IsNull() )
{
return true;
}
switch (action->GetActionId())
{
case AcMOVE:
{
BaseRenderer *baseRenderer = posEvent->GetSender();
if ( !baseRenderer )
{
baseRenderer = const_cast<BaseRenderer *>(
GlobalInteraction::GetInstance()->GetFocus() );
}
if ( baseRenderer )
if ( baseRenderer->GetMapperID() == 1 )
{
PointOperation doOp(OpMOVE, posEvent->GetWorldPosition());
this->ExecuteOperation( &doOp );
// If click was performed in this render window than we have to update the status bar information about position and pixel value.
if(baseRenderer == m_Renderer)
{
{
std::string statusText;
TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = baseRenderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
mitk::Point3D worldposition = posEvent->GetWorldPosition();
int maxlayer = -32768;
mitk::Image::Pointer image3D;
// find image with largest layer, that is the image shown on top in the render window
for (unsigned int x = 0; x < nodes->size(); x++)
{
//Just consider image data that is no helper object. E.g. do not consider nodes created for the slice interpolation
bool isHelper (false);
nodes->at(x)->GetBoolProperty("helper object", isHelper);
if(nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
{
int layer = 0;
if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
if(layer > maxlayer)
{
if(static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(m_Renderer))
{
image3D = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
maxlayer = layer;
}
}
}
}
std::stringstream stream;
stream.imbue(std::locale::classic());
// get the position and gray value from the image and build up status bar text
if(image3D.IsNotNull())
{
Index3D p;
image3D->GetGeometry()->WorldToIndex(worldposition, p);
stream.precision(2);
stream<<"Position: <" << std::fixed <<worldposition[0] << ", " << std::fixed << worldposition[1] << ", " << std::fixed << worldposition[2] << "> mm";
stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific<< pixelValue <<" ";
}
else
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<" ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
}
ok = true;
break;
}
}
default:
ok = true;
break;
}
return ok;
}
const DisplayPositionEvent *displPosEvent =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( displPosEvent != NULL )
{
return true;
}
return false;
}
} // namespace
diff --git a/Core/Code/DataManagement/mitkBaseData.cpp b/Core/Code/DataManagement/mitkBaseData.cpp
index df043b8903..91bd3f0574 100644
--- a/Core/Code/DataManagement/mitkBaseData.cpp
+++ b/Core/Code/DataManagement/mitkBaseData.cpp
@@ -1,371 +1,374 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseData.h"
#include <mitkProportionalTimeGeometry.h>
#include <itkObjectFactoryBase.h>
#include <mitkException.h>
#define MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
mitk::BaseData::BaseData() :
m_RequestedRegionInitialized(false), m_SmartSourcePointer(NULL),
m_SourceOutputIndexDuplicate(0), m_Initialized(true),
m_Unregistering(false), m_CalculatingExternalReferenceCount(false),
m_ExternalReferenceCount(-1)
{
m_TimeGeometry = mitk::ProportionalTimeGeometry::New();
m_PropertyList = PropertyList::New();
}
mitk::BaseData::BaseData( const BaseData &other ):
itk::DataObject(), mitk::OperationActor(),
m_RequestedRegionInitialized(other.m_RequestedRegionInitialized),
m_SmartSourcePointer(other.m_SmartSourcePointer),
m_SourceOutputIndexDuplicate(other.m_SourceOutputIndexDuplicate),
m_Initialized(other.m_Initialized), m_Unregistering(other.m_Unregistering),
m_CalculatingExternalReferenceCount(other.m_CalculatingExternalReferenceCount),
m_ExternalReferenceCount(other.m_ExternalReferenceCount)
{
m_TimeGeometry = other.m_TimeGeometry->Clone().GetPointer();
m_PropertyList = other.m_PropertyList->Clone();
}
mitk::BaseData::~BaseData()
{
m_SmartSourcePointer = NULL;
}
void mitk::BaseData::InitializeTimeGeometry(unsigned int timeSteps)
{
mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
g3d->Initialize();
if ( timeSteps > 1 )
{
mitk::ScalarType timeBounds[] = {0.0, 1.0};
g3d->SetTimeBounds( timeBounds );
}
// The geometry is propagated automatically to the other items,
// if EvenlyTimed is true...
//Old timeGeometry->InitializeEvenlyTimed( g3d.GetPointer(), timeSteps );
TimeGeometry::Pointer timeGeometry = this->GetTimeGeometry();
timeGeometry->Expand(timeSteps);
for (TimeStepType step = 0; step < timeSteps; ++step)
{
timeGeometry->SetTimeStepGeometry(g3d.GetPointer(),step);
}
}
void mitk::BaseData::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if (m_TimeGeometry.IsNotNull())
{
m_TimeGeometry->UpdateBoundingBox();
}
}
const mitk::TimeGeometry* mitk::BaseData::GetUpdatedTimeGeometry()
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetTimeGeometry();
}
void mitk::BaseData::Expand( unsigned int timeSteps )
{
if (m_TimeGeometry.IsNotNull() )
{
ProportionalTimeGeometry * propTimeGeometry = dynamic_cast<ProportionalTimeGeometry*> (m_TimeGeometry.GetPointer());
if (propTimeGeometry)
{
propTimeGeometry->Expand(timeSteps);
return;
}
mitkThrow() << "TimeGeometry is of an unkown Type. Could not expand it. ";
}
else
{
this->InitializeTimeGeometry(timeSteps);
}
}
const mitk::Geometry3D* mitk::BaseData::GetUpdatedGeometry(int t)
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetGeometry(t);
}
void mitk::BaseData::SetGeometry(Geometry3D* geometry)
{
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
if(geometry!=NULL)
{
timeGeometry->Initialize(geometry, 1);
}
SetTimeGeometry(timeGeometry);
return;
}
void mitk::BaseData::SetTimeGeometry(TimeGeometry* geometry)
{
m_TimeGeometry = geometry;
this->Modified();
}
void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D)
{
SetGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()));
}
void mitk::BaseData::SetClonedTimeGeometry(const TimeGeometry* geometry)
{
SetTimeGeometry((geometry->Clone().GetPointer()));
}
void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time)
{
if (m_TimeGeometry)
{
m_TimeGeometry->SetTimeStepGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()),time);
}
}
bool mitk::BaseData::IsEmptyTimeStep(unsigned int) const
{
return IsInitialized() == false;
}
bool mitk::BaseData::IsEmpty() const
{
if(IsInitialized() == false)
return true;
const TimeGeometry* timeGeometry = const_cast<BaseData*>(this)->GetUpdatedTimeGeometry();
if(timeGeometry == NULL)
return true;
unsigned int timeSteps = timeGeometry->GetNumberOfTimeSteps();
for ( unsigned int t = 0 ; t < timeSteps ; ++t )
{
if(IsEmptyTimeStep(t) == false)
return false;
}
return true;
}
itk::SmartPointer<mitk::BaseProcess> mitk::BaseData::GetSource() const
{
return static_cast<mitk::BaseProcess*>(Superclass::GetSource().GetPointer());
}
int mitk::BaseData::GetExternalReferenceCount() const
{
if(m_CalculatingExternalReferenceCount==false) //this is only needed because a smart-pointer to m_Outputs (private!!) must be created by calling GetOutputs.
{
m_CalculatingExternalReferenceCount = true;
m_ExternalReferenceCount = -1;
int realReferenceCount = GetReferenceCount();
if(GetSource().IsNull())
{
m_ExternalReferenceCount = realReferenceCount;
m_CalculatingExternalReferenceCount = false;
return m_ExternalReferenceCount;
}
mitk::BaseProcess::DataObjectPointerArray outputs = m_SmartSourcePointer->GetOutputs();
unsigned int idx;
for (idx = 0; idx < outputs.size(); ++idx)
{
//references of outputs that are not referenced from someone else (reference additional to the reference from this BaseProcess object) are interpreted as non-existent
if(outputs[idx]==this)
--realReferenceCount;
}
m_ExternalReferenceCount = realReferenceCount;
if(m_ExternalReferenceCount<0)
m_ExternalReferenceCount=0;
m_CalculatingExternalReferenceCount = false;
}
else
return -1;
return m_ExternalReferenceCount;
}
void mitk::BaseData::UnRegister() const
{
#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
if(GetReferenceCount()>1)
{
Superclass::UnRegister();
if((m_Unregistering==false) && (m_SmartSourcePointer.IsNotNull()))
{
m_Unregistering=true;
// the order of the following boolean statement is important:
// this->GetSource() returns a SmartPointer,
// which increases and afterwards decreases the reference count,
// which may result in an ExternalReferenceCount of 0, causing
// BaseProcess::UnRegister() to destroy us (also we already
// about to do that).
if((this->m_SmartSourcePointer->GetExternalReferenceCount()==0) || (this->GetSource().IsNull()))
m_SmartSourcePointer=NULL; // now the reference count is zero and this object has been destroyed; thus nothing may be done after this line!!
else
m_Unregistering=false;
}
}
else
#endif
Superclass::UnRegister(); // now the reference count is zero and this object has been destroyed; thus nothing may be done after this line!!
}
void mitk::BaseData::ConnectSource(itk::ProcessObject *arg, unsigned int idx) const
{
#ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
itkDebugMacro( "connecting source " << arg
<< ", source output index " << idx);
if ( GetSource().GetPointer() != arg || m_SourceOutputIndexDuplicate != idx)
{
m_SmartSourcePointer = dynamic_cast<mitk::BaseProcess*>(arg);
m_SourceOutputIndexDuplicate = idx;
Modified();
}
#endif
}
mitk::PropertyList::Pointer mitk::BaseData::GetPropertyList() const
{
return m_PropertyList;
}
mitk::BaseProperty::Pointer mitk::BaseData::GetProperty(const char *propertyKey) const
{
return m_PropertyList->GetProperty(propertyKey);
}
void mitk::BaseData::SetProperty(const char *propertyKey,
BaseProperty* propertyValue)
{
m_PropertyList->SetProperty(propertyKey, propertyValue);
}
void mitk::BaseData::SetPropertyList(PropertyList *pList)
{
m_PropertyList = pList;
}
void mitk::BaseData::SetOrigin(const mitk::Point3D& origin)
{
TimeGeometry* timeGeom = GetTimeGeometry();
assert (timeGeom != NULL);
Geometry3D* geometry;
TimeStepType steps = timeGeom->GetNumberOfTimeSteps();
for (TimeStepType timestep = 0; timestep < steps; ++timestep)
{
geometry = GetGeometry(timestep);
if (geometry != NULL)
{
geometry->SetOrigin(origin);
}
}
}
unsigned long mitk::BaseData::GetMTime() const
{
unsigned long time = Superclass::GetMTime();
if(m_TimeGeometry.IsNotNull())
{
if((time < m_TimeGeometry->GetMTime()))
{
Modified();
return Superclass::GetMTime();
}
}
return time;
}
void mitk::BaseData::CopyInformation( const itk::DataObject* data )
{
const Self* bd = dynamic_cast<const Self*>(data);
if (bd != NULL)
{
m_PropertyList = bd->GetPropertyList()->Clone();
+ if (bd->GetTimeGeometry()!=NULL)
+ m_TimeGeometry = bd->GetTimeGeometry()->Clone();
+
}
else
{
// pointer could not be cast back down; this can be the case if your filters input
// and output objects differ in type; then you have to write your own GenerateOutputInformation method
itkExceptionMacro(<< "mitk::BaseData::CopyInformation() cannot cast "
<< typeid(data).name() << " to "
<< typeid(Self*).name() );
}
}
bool mitk::BaseData::IsInitialized() const
{
return m_Initialized;
}
void mitk::BaseData::Clear()
{
this->ClearData();
this->InitializeEmpty();
}
void mitk::BaseData::ClearData()
{
if(m_Initialized)
{
ReleaseData();
m_Initialized = false;
}
}
void mitk::BaseData::ExecuteOperation(mitk::Operation* /*operation*/)
{
//empty by default. override if needed!
}
void mitk::BaseData::PrintSelf(std::ostream& os, itk::Indent indent) const
{
os << std::endl;
os << indent << " TimeGeometry: ";
if(GetTimeGeometry() == NULL)
os << "NULL" << std::endl;
else
GetTimeGeometry()->Print(os, indent);
}
diff --git a/Core/Code/DataManagement/mitkImage.cpp b/Core/Code/DataManagement/mitkImage.cpp
index 9edd603c0c..4c507782e6 100644
--- a/Core/Code/DataManagement/mitkImage.cpp
+++ b/Core/Code/DataManagement/mitkImage.cpp
@@ -1,1286 +1,1288 @@
/*===================================================================
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 "mitkImage.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkPixelTypeMultiplex.h"
#include <mitkProportionalTimeGeometry.h>
#include <vtkImageData.h>
#include <cmath>
#define FILL_C_ARRAY( _arr, _size, _value) for(unsigned int i=0u; i<_size; i++) \
{ _arr[i] = _value; }
mitk::Image::Image() :
m_Dimension(0), m_Dimensions(NULL), m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL),
m_ImageStatistics(NULL)
{
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
m_Initialized = false;
}
mitk::Image::Image(const Image &other) : SlicedData(other), m_Dimension(0), m_Dimensions(NULL),
m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL), m_ImageStatistics(NULL)
{
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
this->Initialize( other.GetPixelType(), other.GetDimension(), other.GetDimensions());
//Since the above called "Initialize" method doesn't take the geometry into account we need to set it
//here manually
this->SetTimeGeometry(other.GetTimeGeometry()->Clone().GetPointer());
if (this->GetDimension() > 3)
{
const unsigned int time_steps = this->GetDimension(3);
for (unsigned int i = 0u; i < time_steps; ++i)
{
ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(i);
this->SetVolume(volume->GetData(), i);
}
}
else
{
ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(0);
this->SetVolume(volume->GetData(), 0);
}
}
mitk::Image::~Image()
{
Clear();
m_ReferenceCountLock.Lock();
m_ReferenceCount = 3;
m_ReferenceCountLock.Unlock();
m_ReferenceCountLock.Lock();
m_ReferenceCount = 0;
m_ReferenceCountLock.Unlock();
if(m_OffsetTable != NULL)
delete [] m_OffsetTable;
if(m_ImageStatistics != NULL)
delete m_ImageStatistics;
}
const mitk::PixelType mitk::Image::GetPixelType(int n) const
{
return this->m_ImageDescriptor->GetChannelTypeById(n);
}
unsigned int mitk::Image::GetDimension() const
{
return m_Dimension;
}
unsigned int mitk::Image::GetDimension(int i) const
{
if((i>=0) && (i<(int)m_Dimension))
return m_Dimensions[i];
return 1;
}
void* mitk::Image::GetData()
{
if(m_Initialized==false)
{
if(GetSource().IsNull())
return NULL;
if(GetSource()->Updating()==false)
GetSource()->UpdateOutputInformation();
}
m_CompleteData=GetChannelData();
// update channel's data
// if data was not available at creation point, the m_Data of channel descriptor is NULL
// if data present, it won't be overwritten
m_ImageDescriptor->GetChannelDescriptor(0).SetData(m_CompleteData->GetData());
return m_CompleteData->GetData();
}
template <class T>
void AccessPixel( const mitk::PixelType ptype, void* data, const unsigned int offset, double& value )
{
value = 0.0;
if( data == NULL ) return;
if(ptype.GetBpe() != 24)
{
value = (double) (((T*) data)[ offset ]);
}
else
{
const unsigned int rgboffset = 3 * offset;
double returnvalue = (((T*) data)[rgboffset ]);
returnvalue += (((T*) data)[rgboffset + 1]);
returnvalue += (((T*) data)[rgboffset + 2]);
value = returnvalue;
}
}
double mitk::Image::GetPixelValueByIndex(const mitk::Index3D &position, unsigned int timestep)
{
double value = 0;
if (this->GetTimeSteps() < timestep)
{
timestep = this->GetTimeSteps();
}
value = 0.0;
const unsigned int* imageDims = this->m_ImageDescriptor->GetDimensions();
const mitk::PixelType ptype = this->m_ImageDescriptor->GetChannelTypeById(0);
// Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
// (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
// bug-11978 : we still need to catch index with negative values
if ( position[0] < 0 ||
position[1] < 0 ||
position[2] < 0 )
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
// check if the given position is inside the index range of the image, the 3rd dimension needs to be compared only if the dimension is not 0
else if ( (unsigned int)position[0] >= imageDims[0] ||
(unsigned int)position[1] >= imageDims[1] ||
( imageDims[2] && (unsigned int)position[2] >= imageDims[2] ))
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
else
{
const unsigned int offset = position[0] + position[1]*imageDims[0] + position[2]*imageDims[0]*imageDims[1] + timestep*imageDims[0]*imageDims[1]*imageDims[2];
mitkPixelTypeMultiplex3( AccessPixel, ptype, this->GetData(), offset, value );
}
return value;
}
double mitk::Image::GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep)
{
double value = 0.0;
if (this->GetTimeSteps() < timestep)
{
timestep = this->GetTimeSteps();
}
Index3D itkIndex;
this->GetGeometry()->WorldToIndex(position, itkIndex);
value = this->GetPixelValueByIndex( itkIndex, timestep);
return value;
}
mitk::ImageVtkAccessor* mitk::Image::GetVtkImageData(int t, int n)
{
if(m_Initialized==false)
{
if(GetSource().IsNull())
return NULL;
if(GetSource()->Updating()==false)
GetSource()->UpdateOutputInformation();
}
ImageDataItemPointer volume=GetVolumeData(t, n);
if(volume.GetPointer()==NULL || volume->GetVtkImageData(this) == NULL)
return NULL;
float *fspacing = const_cast<float *>(GetSlicedGeometry(t)->GetFloatSpacing());
double dspacing[3] = {fspacing[0],fspacing[1],fspacing[2]};
volume->GetVtkImageData(this)->SetSpacing( dspacing );
return volume->GetVtkImageData(this);
}
mitk::Image::ImageDataItemPointer mitk::Image::GetSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidSlice(s,t,n)==false) return NULL;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// slice directly available?
int pos=GetSliceIndex(s,t,n);
if(m_Slices[pos].GetPointer()!=NULL)
return m_Slices[pos];
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// slice is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir mussen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, s);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, 1);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsSliceSet(s,t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetSliceData(s,t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateSliceData(s,t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
mitk::Image::ImageDataItemPointer mitk::Image::GetVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidVolume(t,n)==false) return NULL;
ImageDataItemPointer ch, vol;
// volume directly available?
int pos=GetVolumeIndex(t,n);
vol=m_Volumes[pos];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return vol;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
vol->SetComplete(true);
return m_Volumes[pos]=vol;
}
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
bool complete=true;
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
{
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
{
complete=false;
break;
}
}
if(complete)
{
// if there is only single slice we do not need to combine anything
if(m_Dimensions[2]<=1)
{
ImageDataItemPointer sl;
sl=GetSliceData(0,t,n,data,importMemoryManagement);
vol=new ImageDataItem(*sl, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory);
vol->SetComplete(true);
}
else
{
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
vol=m_Volumes[pos];
// ok, let's combine the slices!
if(vol.GetPointer()==NULL)
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
vol->SetComplete(true);
size_t size=m_OffsetTable[2]*(ptypeSize);
for(s=0;s<m_Dimensions[2];++s)
{
int posSl;
ImageDataItemPointer sl;
posSl=GetSliceIndex(s,t,n);
sl=m_Slices[posSl];
if(sl->GetParent()!=vol)
{
// copy data of slices in volume
size_t offset = ((size_t) s)*size;
std::memcpy(static_cast<char*>(vol->GetData())+offset, sl->GetData(), size);
// FIXME mitkIpPicDescriptor * pic = sl->GetPicDescriptor();
// replace old slice with reference to volume
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*size);
sl->SetComplete(true);
//mitkIpFuncCopyTags(sl->GetPicDescriptor(), pic);
m_Slices[posSl]=sl;
}
}
//if(vol->GetPicDescriptor()->info->tags_head==NULL)
// mitkIpFuncCopyTags(vol->GetPicDescriptor(), m_Slices[GetSliceIndex(0,t,n)]->GetPicDescriptor());
}
return m_Volumes[pos]=vol;
}
// volume is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir muessen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, 0);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, m_Dimensions[2]);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsVolumeSet(t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetVolumeData(t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateVolumeData(t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
mitk::Image::ImageDataItemPointer mitk::Image::GetChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidChannel(n)==false) return NULL;
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return ch;
// let's see if all volumes are set, so that we can (could) combine them to a channel
if(IsChannelSet(n))
{
// if there is only one time frame we do not need to combine anything
if(m_Dimensions[3]<=1)
{
vol=GetVolumeData(0,n,data,importMemoryManagement);
ch=new ImageDataItem(*vol, m_ImageDescriptor, m_ImageDescriptor->GetNumberOfDimensions(), data, importMemoryManagement == ManageMemory);
ch->SetComplete(true);
}
else
{
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ch=m_Channels[n];
// ok, let's combine the volumes!
if(ch.GetPointer()==NULL)
ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
ch->SetComplete(true);
size_t size=m_OffsetTable[m_Dimension-1]*(ptypeSize);
unsigned int t;
ImageDataItemPointerArray::iterator slicesIt = m_Slices.begin()+n*m_Dimensions[2]*m_Dimensions[3];
for(t=0;t<m_Dimensions[3];++t)
{
int posVol;
ImageDataItemPointer vol;
posVol=GetVolumeIndex(t,n);
vol=GetVolumeData(t,n,data,importMemoryManagement);
if(vol->GetParent()!=ch)
{
// copy data of volume in channel
size_t offset = ((size_t) t)*m_OffsetTable[3]*(ptypeSize);
std::memcpy(static_cast<char*>(ch->GetData())+offset, vol->GetData(), size);
// REVEIW FIX mitkIpPicDescriptor * pic = vol->GetPicDescriptor();
// replace old volume with reference to channel
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, offset);
vol->SetComplete(true);
//mitkIpFuncCopyTags(vol->GetPicDescriptor(), pic);
m_Volumes[posVol]=vol;
// get rid of slices - they may point to old volume
ImageDataItemPointer dnull=NULL;
for(unsigned int i = 0; i < m_Dimensions[2]; ++i, ++slicesIt)
{
assert(slicesIt != m_Slices.end());
*slicesIt = dnull;
}
}
}
// REVIEW FIX
// if(ch->GetPicDescriptor()->info->tags_head==NULL)
// mitkIpFuncCopyTags(ch->GetPicDescriptor(), m_Volumes[GetVolumeIndex(0,n)]->GetPicDescriptor());
}
return m_Channels[n]=ch;
}
// channel is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir muessen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, 0);
m_RequestedRegion.SetIndex(3, 0);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, m_Dimensions[2]);
m_RequestedRegion.SetSize(3, m_Dimensions[3]);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
// did it work?
if(IsChannelSet(n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetChannelData(n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateChannelData(n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
bool mitk::Image::IsSliceSet(int s, int t, int n) const
{
if(IsValidSlice(s,t,n)==false) return false;
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()!=NULL)
return true;
ImageDataItemPointer ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return true;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
return false;
}
bool mitk::Image::IsVolumeSet(int t, int n) const
{
if(IsValidVolume(t,n)==false) return false;
ImageDataItemPointer ch, vol;
// volume directly available?
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return true;
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
return false;
return true;
}
bool mitk::Image::IsChannelSet(int n) const
{
if(IsValidChannel(n)==false) return false;
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
// let's see if all volumes are set, so that we can (could) combine them to a channel
unsigned int t;
for(t=0;t<m_Dimensions[3];++t)
if(IsVolumeSet(t,n)==false)
return false;
return true;
}
bool mitk::Image::SetSlice(const void *data, int s, int t, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportSlice(const_cast<void*>(data), s, t, n, CopyMemory);
}
bool mitk::Image::SetVolume(const void *data, int t, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportVolume(const_cast<void*>(data), t, n, CopyMemory);
}
bool mitk::Image::SetChannel(const void *data, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportChannel(const_cast<void*>(data), n, CopyMemory);
}
bool mitk::Image::SetImportSlice(void *data, int s, int t, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidSlice(s,t,n)==false) return false;
ImageDataItemPointer sl;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
if(IsSliceSet(s,t,n))
{
sl=GetSliceData(s,t,n,data,importMemoryManagement);
if(sl->GetManageMemory()==false)
{
sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
if(sl.GetPointer()==NULL) return false;
}
if ( sl->GetData() != data )
std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
sl->Modified();
//we have changed the data: call Modified()!
Modified();
}
else
{
sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
if(sl.GetPointer()==NULL) return false;
if ( sl->GetData() != data )
std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
//we just added a missing slice, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
bool mitk::Image::SetImportVolume(void *data, int t, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidVolume(t,n)==false) return false;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ImageDataItemPointer vol;
if(IsVolumeSet(t,n))
{
vol=GetVolumeData(t,n,data,importMemoryManagement);
if(vol->GetManageMemory()==false)
{
vol=AllocateVolumeData(t,n,data,importMemoryManagement);
if(vol.GetPointer()==NULL) return false;
}
if ( vol->GetData() != data )
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
vol->Modified();
vol->SetComplete(true);
//we have changed the data: call Modified()!
Modified();
}
else
{
vol=AllocateVolumeData(t,n,data,importMemoryManagement);
if(vol.GetPointer()==NULL) return false;
if ( vol->GetData() != data )
{
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
}
vol->SetComplete(true);
this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( vol->GetData() );
//we just added a missing Volume, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
bool mitk::Image::SetImportChannel(void *data, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidChannel(n)==false) return false;
// channel descriptor
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ImageDataItemPointer ch;
if(IsChannelSet(n))
{
ch=GetChannelData(n,data,importMemoryManagement);
if(ch->GetManageMemory()==false)
{
ch=AllocateChannelData(n,data,importMemoryManagement);
if(ch.GetPointer()==NULL) return false;
}
if ( ch->GetData() != data )
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
ch->Modified();
ch->SetComplete(true);
//we have changed the data: call Modified()!
Modified();
}
else
{
ch=AllocateChannelData(n,data,importMemoryManagement);
if(ch.GetPointer()==NULL) return false;
if ( ch->GetData() != data )
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
ch->SetComplete(true);
this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( ch->GetData() );
//we just added a missing Channel, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
void mitk::Image::Initialize()
{
ImageDataItemPointerArray::iterator it, end;
for( it=m_Slices.begin(), end=m_Slices.end(); it!=end; ++it )
{
(*it)=NULL;
}
for( it=m_Volumes.begin(), end=m_Volumes.end(); it!=end; ++it )
{
(*it)=NULL;
}
for( it=m_Channels.begin(), end=m_Channels.end(); it!=end; ++it )
{
(*it)=NULL;
}
m_CompleteData = NULL;
if( m_ImageStatistics == NULL)
{
m_ImageStatistics = new mitk::ImageStatisticsHolder( this );
}
SetRequestedRegionToLargestPossibleRegion();
}
void mitk::Image::Initialize(const mitk::ImageDescriptor::Pointer inDesc)
{
// store the descriptor
this->m_ImageDescriptor = inDesc;
// initialize image
this->Initialize( inDesc->GetChannelDescriptor(0).GetPixelType(), inDesc->GetNumberOfDimensions(), inDesc->GetDimensions(), 1 );
}
void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels)
{
Clear();
m_Dimension=dimension;
if(!dimensions)
itkExceptionMacro(<< "invalid zero dimension image");
unsigned int i;
for(i=0;i<dimension;++i)
{
if(dimensions[i]<1)
itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
}
// create new array since the old was deleted
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
// initialize the first four dimensions to 1, the remaining 4 to 0
FILL_C_ARRAY(m_Dimensions, 4, 1u);
FILL_C_ARRAY((m_Dimensions+4), 4, 0u);
// copy in the passed dimension information
std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
this->m_ImageDescriptor = mitk::ImageDescriptor::New();
this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
for(i=0;i<4;++i)
{
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
}
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize(i, channels);
if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
{
delete [] m_Dimensions;
m_Dimensions = NULL;
return;
}
for( unsigned int i=0u; i<channels; i++)
{
this->m_ImageDescriptor->AddNewChannel( type );
}
PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
planegeometry->InitializeStandardPlane(m_Dimensions[0], m_Dimensions[1]);
SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(planegeometry, m_Dimensions[2]);
if(dimension>=4)
{
TimeBounds timebounds;
timebounds[0] = 0.0;
timebounds[1] = 1.0;
slicedGeometry->SetTimeBounds(timebounds);
}
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
for (TimeStepType step = 0; step < timeGeometry->GetNumberOfTimeSteps(); ++step)
{
timeGeometry->GetGeometryForTimeStep(step)->ImageGeometryOn();
}
SetTimeGeometry(timeGeometry);
ImageDataItemPointer dnull=NULL;
m_Channels.assign(GetNumberOfChannels(), dnull);
m_Volumes.assign(GetNumberOfChannels()*m_Dimensions[3], dnull);
m_Slices.assign(GetNumberOfChannels()*m_Dimensions[3]*m_Dimensions[2], dnull);
ComputeOffsetTable();
Initialize();
m_Initialized = true;
}
void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels, int tDim )
{
mitk::ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
- timeGeometry->Initialize(dynamic_cast<Geometry3D*>(geometry.Clone().GetPointer()), tDim);
+ AffineGeometryFrame3D::Pointer geometry3D = geometry.Clone();
+ timeGeometry->Initialize(dynamic_cast<Geometry3D*>(geometry3D.GetPointer()), tDim);
this->Initialize(type, *timeGeometry, channels, tDim);
}
void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::TimeGeometry& geometry, unsigned int channels, int tDim )
{
+ const ProportionalTimeGeometry& ptG = dynamic_cast<const ProportionalTimeGeometry&>(geometry);
unsigned int dimensions[5];
- dimensions[0] = (unsigned int)(geometry.GetExtendInWorld(0)+0.5);
- dimensions[1] = (unsigned int)(geometry.GetExtendInWorld(1)+0.5);
- dimensions[2] = (unsigned int)(geometry.GetExtendInWorld(2)+0.5);
+ dimensions[0] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(0)+0.5);
+ dimensions[1] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(1)+0.5);
+ dimensions[2] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(2)+0.5);
dimensions[3] = (tDim > 0) ? tDim : geometry.GetNumberOfTimeSteps();
dimensions[4] = 0;
unsigned int dimension = 2;
if ( dimensions[2] > 1 )
dimension = 3;
if ( dimensions[3] > 1 )
dimension = 4;
Initialize( type, dimension, dimensions, channels );
SetTimeGeometry(geometry.Clone().GetPointer());
/* //Old //TODO_GOETZ Really necessary?
mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBoxInWorld()->GetBounds();
if( (bounds[0] != 0.0) || (bounds[2] != 0.0) || (bounds[4] != 0.0) )
{
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
mitk::Point3D origin; origin.Fill(0.0);
slicedGeometry->IndexToWorld(origin, origin);
bounds[1]-=bounds[0]; bounds[3]-=bounds[2]; bounds[5]-=bounds[4];
bounds[0] = 0.0; bounds[2] = 0.0; bounds[4] = 0.0;
this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
slicedGeometry->SetBounds(bounds);
slicedGeometry->GetIndexToWorldTransform()->SetOffset(origin.Get_vnl_vector().data_block());
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
SetTimeGeometry(timeGeometry);
}*/
}
void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
{
SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(static_cast<Geometry2D*>(geometry2d.Clone().GetPointer()), sDim, flipped);
Initialize(type, *slicedGeometry, channels, tDim);
}
void mitk::Image::Initialize(const mitk::Image* image)
{
Initialize(image->GetPixelType(), *image->GetTimeGeometry());
}
void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
{
if(vtkimagedata==NULL) return;
m_Dimension=vtkimagedata->GetDataDimension();
unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
if(m_Dimension<4)
{
unsigned int *p;
for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
*p=1;
}
if(pDim>=0)
{
tmpDimensions[1]=pDim;
if(m_Dimension < 2)
m_Dimension = 2;
}
if(sDim>=0)
{
tmpDimensions[2]=sDim;
if(m_Dimension < 3)
m_Dimension = 3;
}
if(tDim>=0)
{
tmpDimensions[3]=tDim;
if(m_Dimension < 4)
m_Dimension = 4;
}
switch ( vtkimagedata->GetScalarType() )
{
case VTK_BIT:
case VTK_CHAR:
//pixelType.Initialize(typeid(char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_CHAR:
//pixelType.Initialize(typeid(unsigned char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_SHORT:
//pixelType.Initialize(typeid(short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_SHORT:
//pixelType.Initialize(typeid(unsigned short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_INT:
//pixelType.Initialize(typeid(int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_INT:
//pixelType.Initialize(typeid(unsigned int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_LONG:
//pixelType.Initialize(typeid(long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_LONG:
//pixelType.Initialize(typeid(unsigned long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_FLOAT:
//pixelType.Initialize(typeid(float), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<float>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_DOUBLE:
//pixelType.Initialize(typeid(double), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<double>(), m_Dimension, tmpDimensions, channels);
break;
default:
break;
}
/*
Initialize(pixelType,
m_Dimension,
tmpDimensions,
channels);
*/
const double *spacinglist = vtkimagedata->GetSpacing();
Vector3D spacing;
FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
if(m_Dimension>=2)
spacing[1]=spacinglist[1];
if(m_Dimension>=3)
spacing[2]=spacinglist[2];
// access origin of vtkImage
Point3D origin;
vtkFloatingPointType vtkorigin[3];
vtkimagedata->GetOrigin(vtkorigin);
FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
if(m_Dimension>=2)
origin[1]=vtkorigin[1];
if(m_Dimension>=3)
origin[2]=vtkorigin[2];
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetGeometry2D(0));
planeGeometry->SetOrigin(origin);
// re-initialize SlicedGeometry3D
slicedGeometry->SetOrigin(origin);
slicedGeometry->SetSpacing(spacing);
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
SetTimeGeometry(timeGeometry);
delete [] tmpDimensions;
}
bool mitk::Image::IsValidSlice(int s, int t, int n) const
{
if(m_Initialized)
return ((s>=0) && (s<(int)m_Dimensions[2]) && (t>=0) && (t< (int) m_Dimensions[3]) && (n>=0) && (n< (int)GetNumberOfChannels()));
else
return false;
}
bool mitk::Image::IsValidVolume(int t, int n) const
{
if(m_Initialized)
return IsValidSlice(0, t, n);
else
return false;
}
bool mitk::Image::IsValidChannel(int n) const
{
if(m_Initialized)
return IsValidSlice(0, 0, n);
else
return false;
}
void mitk::Image::ComputeOffsetTable()
{
if(m_OffsetTable!=NULL)
delete [] m_OffsetTable;
m_OffsetTable=new size_t[m_Dimension>4 ? m_Dimension+1 : 4+1];
unsigned int i;
size_t num=1;
m_OffsetTable[0] = 1;
for (i=0; i < m_Dimension; ++i)
{
num *= m_Dimensions[i];
m_OffsetTable[i+1] = num;
}
for (;i < 4; ++i)
m_OffsetTable[i+1] = num;
}
bool mitk::Image::IsValidTimeStep(int t) const
{
return ( ( m_Dimension >= 4 && t <= (int)m_Dimensions[3] && t > 0 ) || (t == 0) );
}
void mitk::Image::Expand(unsigned int timeSteps)
{
if(timeSteps < 1) itkExceptionMacro(<< "Invalid timestep in Image!");
Superclass::Expand(timeSteps);
}
int mitk::Image::GetSliceIndex(int s, int t, int n) const
{
if(IsValidSlice(s,t,n)==false) return false;
return ((size_t)s)+((size_t) t)*m_Dimensions[2]+((size_t) n)*m_Dimensions[3]*m_Dimensions[2]; //??
}
int mitk::Image::GetVolumeIndex(int t, int n) const
{
if(IsValidVolume(t,n)==false) return false;
return ((size_t)t)+((size_t) n)*m_Dimensions[3]; //??
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
int pos;
pos=GetSliceIndex(s,t,n);
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if(vol.GetPointer()!=NULL)
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if(ch.GetPointer()!=NULL)
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// allocate new volume (instead of a single slice to keep data together!)
m_Volumes[GetVolumeIndex(t,n)]=vol=AllocateVolumeData(t,n,NULL,importMemoryManagement);
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
////ALTERNATIVE:
//// allocate new slice
//sl=new ImageDataItem(*m_PixelType, 2, m_Dimensions);
//m_Slices[pos]=sl;
//return vol;
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
int pos;
pos=GetVolumeIndex(t,n);
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is volume available as part of a channel that is available?
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if(ch.GetPointer()!=NULL)
{
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data,importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
return m_Volumes[pos]=vol;
}
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
// allocate new volume
if(importMemoryManagement == CopyMemory)
{
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
if(data != NULL)
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
}
else
{
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, data, importMemoryManagement == ManageMemory);
}
m_Volumes[pos]=vol;
return vol;
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
ImageDataItemPointer ch;
// allocate new channel
if(importMemoryManagement == CopyMemory)
{
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
if(data != NULL)
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
}
else
{
ch=new ImageDataItem(this->m_ImageDescriptor, data, importMemoryManagement == ManageMemory);
}
m_Channels[n]=ch;
return ch;
}
unsigned int* mitk::Image::GetDimensions() const
{
return m_Dimensions;
}
void mitk::Image::Clear()
{
Superclass::Clear();
delete [] m_Dimensions;
m_Dimensions = NULL;
}
void mitk::Image::SetGeometry(Geometry3D* aGeometry3D)
{
// Please be aware of the 0.5 offset/pixel-center issue! See Geometry documentation for further information
if(aGeometry3D->GetImageGeometry()==false)
{
MITK_INFO << "WARNING: Applied a non-image geometry onto an image. Please be SURE that this geometry is pixel-center-based! If it is not, you need to call Geometry3D->ChangeImageGeometryConsideringOriginOffset(true) before calling image->setGeometry(..)\n";
}
Superclass::SetGeometry(aGeometry3D);
for (TimeStepType step = 0; step < GetTimeGeometry()->GetNumberOfTimeSteps(); ++step)
GetTimeGeometry()->GetGeometryForTimeStep(step)->ImageGeometryOn();
}
void mitk::Image::PrintSelf(std::ostream& os, itk::Indent indent) const
{
unsigned char i;
if(m_Initialized)
{
os << indent << " Dimension: " << m_Dimension << std::endl;
os << indent << " Dimensions: ";
for(i=0; i < m_Dimension; ++i)
os << GetDimension(i) << " ";
os << std::endl;
for(unsigned int ch=0; ch < this->m_ImageDescriptor->GetNumberOfChannels(); ch++)
{
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(ch);
os << indent << " Channel: " << this->m_ImageDescriptor->GetChannelName(ch) << std::endl;
os << indent << " PixelType: " << chPixelType.GetTypeId().name() << std::endl;
os << indent << " BitsPerElement: " << chPixelType.GetSize() << std::endl;
os << indent << " NumberOfComponents: " << chPixelType.GetNumberOfComponents() << std::endl;
os << indent << " BitsPerComponent: " << chPixelType.GetBitsPerComponent() << std::endl;
}
}
else
{
os << indent << " Image not initialized: m_Initialized: false" << std::endl;
}
Superclass::PrintSelf(os,indent);
}
bool mitk::Image::IsRotated() const
{
const mitk::Geometry3D* geo = this->GetGeometry();
bool ret = false;
if(geo)
{
const vnl_matrix_fixed<float, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
float ref = 0;
for(short k = 0; k < 3; ++k)
ref += mx[k][k];
ref/=1000; // Arbitrary value; if a non-diagonal (nd) element is bigger then this, matrix is considered nd.
for(short i = 0; i < 3; ++i)
{
for(short j = 0; j < 3; ++j)
{
if(i != j)
{
if(std::abs(mx[i][j]) > ref) // matrix is nd
ret = true;
}
}
}
}
return ret;
}
#include "mitkImageStatisticsHolder.h"
//##Documentation
mitk::ScalarType mitk::Image::GetScalarValueMin(int t) const
{
return m_ImageStatistics->GetScalarValueMin(t);
}
//##Documentation
//## \brief Get the maximum for scalar images
mitk::ScalarType mitk::Image::GetScalarValueMax(int t) const
{
return m_ImageStatistics->GetScalarValueMax(t);
}
//##Documentation
//## \brief Get the second smallest value for scalar images
mitk::ScalarType mitk::Image::GetScalarValue2ndMin(int t) const
{
return m_ImageStatistics->GetScalarValue2ndMin(t);
}
mitk::ScalarType mitk::Image::GetScalarValueMinNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValueMinNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMinNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValue2ndMinNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMax(int t) const
{
return m_ImageStatistics->GetScalarValue2ndMax(t);
}
mitk::ScalarType mitk::Image::GetScalarValueMaxNoRecompute( unsigned int t) const
{
return m_ImageStatistics->GetScalarValueMaxNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMaxNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValue2ndMaxNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetCountOfMinValuedVoxels(int t ) const
{
return m_ImageStatistics->GetCountOfMinValuedVoxels(t);
}
mitk::ScalarType mitk::Image::GetCountOfMaxValuedVoxels(int t) const
{
return m_ImageStatistics->GetCountOfMaxValuedVoxels(t);
}
unsigned int mitk::Image::GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetCountOfMaxValuedVoxelsNoRecompute(t);
}
unsigned int mitk::Image::GetCountOfMinValuedVoxelsNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetCountOfMinValuedVoxelsNoRecompute(t);
}
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
index 498601f361..8180d87548 100644
--- a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
@@ -1,173 +1,178 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkProportionalTimeGeometry.h>
mitk::ProportionalTimeGeometry::ProportionalTimeGeometry()
{
}
mitk::ProportionalTimeGeometry::~ProportionalTimeGeometry()
{
}
void mitk::ProportionalTimeGeometry::Initialize()
{
}
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
{
- return dynamic_cast<Geometry3D*>(m_GeometryVector[timeStep].GetPointer());
+ 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::ExecuteOperation(mitk::Operation* operation)
-{
-}
-
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;
this->ReserveSpaceForGeometries(timeSteps);
for (TimeStepType currentStep = 0; currentStep < timeSteps; ++currentStep)
{
this->SetTimeStepGeometry(dynamic_cast<Geometry3D *>(geometry->Clone().GetPointer()), currentStep);
}
m_FirstTimePoint = geometry->GetTimeBounds()[0];
m_StepDuration = geometry->GetTimeBounds()[1] - geometry->GetTimeBounds()[0];
+ 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/mitkProportionalTimeGeometry.h b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
index 9a16019442..9da337b551 100644
--- a/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
@@ -1,111 +1,109 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ProportialTimeGeometry_h
#define ProportialTimeGeometry_h
//ITK
#include <itkBoundingBox.h>
#include <itkFixedArray.h>
#include <itkObject.h>
//MITK
#include <mitkTimeGeometry.h>
#include <mitkCommon.h>
#include <MitkExports.h>
#include "mitkOperationActor.h"
#include "mitkVector.h"
// To be replaced
#include <mitkSlicedGeometry3D.h>
// STL
#include <vector>
namespace mitk {
// typedef itk::BoundingBox<unsigned long, 3, double> BoundingBox;
// typedef itk::FixedArray<ScalarType,2> TimeBounds;
class MITK_CORE_EXPORT ProportionalTimeGeometry : public TimeGeometry
{
public:
mitkClassMacro(ProportionalTimeGeometry, TimeGeometry);
ProportionalTimeGeometry();
typedef ProportionalTimeGeometry self;
itkNewMacro(self);
virtual TimeStepType GetNumberOfTimeSteps() const;
virtual TimePointType GetMinimumTimePoint () const;
virtual TimePointType GetMaximumTimePoint () const;
//##Documentation
//## @brief Get the time bounds (in ms)
virtual TimeBounds GetTimeBounds( ) const;
virtual bool IsValidTimePoint (TimePointType timePoint) const;
virtual bool IsValidTimeStep (TimeStepType timeStep) const;
virtual TimePointType TimeStepToTimePoint (TimeStepType timeStep) const;
virtual TimeStepType TimePointToTimeStep (TimePointType timePoint) const;
virtual Geometry3D::Pointer GetGeometryCloneForTimeStep( TimeStepType timeStep) const;
virtual Geometry3D* GetGeometryForTimePoint ( TimePointType timePoint) const;
virtual Geometry3D* GetGeometryForTimeStep ( TimeStepType timeStep) const;
virtual bool IsValid ();
virtual void Initialize();
- virtual void ExecuteOperation(Operation *);
-
virtual void Expand(TimeStepType size);
virtual void SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep);
/**
* \brief Makes a deep copy of the current object
*/
virtual TimeGeometry::Pointer Clone () const;
itkGetMacro(FirstTimePoint, TimePointType);
itkSetMacro(FirstTimePoint, TimePointType);
itkGetMacro(StepDuration, TimePointType);
itkSetMacro(StepDuration, TimePointType);
// void SetGeometryForTimeStep(TimeStepType timeStep, BaseGeometry& geometry);
void ClearAllGeometries ();
// void AddGeometry(BaseGeometry geometry);
void ReserveSpaceForGeometries (TimeStepType numberOfGeometries);
/**
* \brief Initializes the TimeGeometry with equally time Step geometries
*/
void Initialize (Geometry3D * geometry, TimeStepType timeSteps);
/**
* \brief Initialize the TimeGeometry with empty Geometry3D
*/
void Initialize (TimeStepType timeSteps);
protected:
virtual ~ProportionalTimeGeometry();
std::vector<Geometry3D::Pointer> m_GeometryVector;
TimePointType m_FirstTimePoint;
TimePointType m_StepDuration;
}; // end class ProportialTimeGeometry
} // end namespace MITK
#endif // ProportialTimeGeometry_h
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkSlicedData.cpp b/Core/Code/DataManagement/mitkSlicedData.cpp
index 7f007f91f3..b82b0a465a 100644
--- a/Core/Code/DataManagement/mitkSlicedData.cpp
+++ b/Core/Code/DataManagement/mitkSlicedData.cpp
@@ -1,351 +1,345 @@
/*===================================================================
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 "mitkSlicedData.h"
#include "mitkBaseProcess.h"
#include <mitkProportionalTimeGeometry.h>
mitk::SlicedData::SlicedData() : m_UseLargestPossibleRegion(false)
{
unsigned int i;
for(i=0;i<4;++i)
{
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize (i, 1);
}
}
mitk::SlicedData::SlicedData( const SlicedData &other ): BaseData(other),
m_LargestPossibleRegion(other.m_LargestPossibleRegion),
m_RequestedRegion(other.m_RequestedRegion),
m_BufferedRegion(other.m_BufferedRegion),
m_UseLargestPossibleRegion(other.m_UseLargestPossibleRegion)
{
}
mitk::SlicedData::~SlicedData()
{
}
void mitk::SlicedData::UpdateOutputInformation()
{
Superclass::UpdateOutputInformation();
if (this->GetSource().IsNull())
// If we don't have a source, then let's make our Image
// span our buffer
{
m_UseLargestPossibleRegion = true;
}
// Now we should know what our largest possible region is. If our
// requested region was not set yet, (or has been set to something
// invalid - with no data in it ) then set it to the largest possible
// region.
if ( ! m_RequestedRegionInitialized)
{
this->SetRequestedRegionToLargestPossibleRegion();
m_RequestedRegionInitialized = true;
}
m_LastRequestedRegionWasOutsideOfTheBufferedRegion = 0;
}
void mitk::SlicedData::PrepareForNewData()
{
if ( GetUpdateMTime() < GetPipelineMTime() || GetDataReleased() )
{
ReleaseData();
}
}
void mitk::SlicedData::SetRequestedRegionToLargestPossibleRegion()
{
m_UseLargestPossibleRegion = true;
if(GetGeometry()==NULL)
return;
unsigned int i;
const RegionType::IndexType & index = GetLargestPossibleRegion().GetIndex();
const RegionType::SizeType & size = GetLargestPossibleRegion().GetSize();
for(i=0;i<RegionDimension;++i)
{
m_RequestedRegion.SetIndex(i, index[i]);
m_RequestedRegion.SetSize(i, size[i]);
}
}
bool mitk::SlicedData::RequestedRegionIsOutsideOfTheBufferedRegion()
{
// Is the requested region within the currently buffered data?
// SlicedData and subclasses store entire volumes or slices. The
// methods IsVolumeSet() and IsSliceSet are provided to check,
// a volume or slice, respectively, is available. Thus, these
// methods used here.
const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
const SizeType& largestPossibleRegionSize
= GetLargestPossibleRegion().GetSize();
// are whole channels requested?
int c, cEnd;
c=requestedRegionIndex[4];
cEnd=c+static_cast<long>(requestedRegionSize[4]);
if(requestedRegionSize[3] == largestPossibleRegionSize[3])
{
for (; c< cEnd; ++c)
if(IsChannelSet(c)==false) return true;
return false;
}
// are whole volumes requested?
int t, tEnd;
t=requestedRegionIndex[3];
tEnd=t+static_cast<long>(requestedRegionSize[3]);
if(requestedRegionSize[2] == largestPossibleRegionSize[2])
{
for (; c< cEnd; ++c)
for (; t< tEnd; ++t)
if(IsVolumeSet(t, c)==false) return true;
return false;
}
// ok, only slices are requested. Check if they are available.
int s, sEnd;
s=requestedRegionIndex[2];
sEnd=s+static_cast<long>(requestedRegionSize[2]);
for (; c< cEnd; ++c)
for (; t< tEnd; ++t)
for (; s< sEnd; ++s)
if(IsSliceSet(s, t, c)==false) return true;
return false;
}
bool mitk::SlicedData::VerifyRequestedRegion()
{
if(GetTimeGeometry() == NULL) return false;
unsigned int i;
// Is the requested region within the LargestPossibleRegion?
// Note that the test is indeed against the largest possible region
// rather than the buffered region; see DataObject::VerifyRequestedRegion.
const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
const IndexType &largestPossibleRegionIndex
= GetLargestPossibleRegion().GetIndex();
const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
const SizeType& largestPossibleRegionSize
= GetLargestPossibleRegion().GetSize();
for (i=0; i< RegionDimension; ++i)
{
if ( (requestedRegionIndex[i] < largestPossibleRegionIndex[i]) ||
((requestedRegionIndex[i] + static_cast<long>(requestedRegionSize[i]))
> (largestPossibleRegionIndex[i]+static_cast<long>(largestPossibleRegionSize[i]))))
{
return false;
}
}
return true;
}
void mitk::SlicedData::SetRequestedRegion(itk::DataObject *data)
{
m_UseLargestPossibleRegion=false;
mitk::SlicedData *slicedData;
slicedData = dynamic_cast<mitk::SlicedData*>(data);
if (slicedData)
{
m_RequestedRegion = slicedData->GetRequestedRegion();
m_RequestedRegionInitialized = true;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
}
}
void mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType *region)
{
m_UseLargestPossibleRegion=false;
if(region!=NULL)
{
m_RequestedRegion = *region;
m_RequestedRegionInitialized = true;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(SlicedData*).name() );
}
}
void mitk::SlicedData::CopyInformation(const itk::DataObject *data)
{
// Standard call to the superclass' method
Superclass::CopyInformation(data);
const mitk::SlicedData *slicedData;
slicedData = dynamic_cast<const mitk::SlicedData*>(data);
if (slicedData)
{
m_LargestPossibleRegion = slicedData->GetLargestPossibleRegion();
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::CopyInformation(const DataObject *data) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
}
}
//const mitk::Geometry2D* mitk::SlicedData::GetGeometry2D(int s, int t) const
//{
// const_cast<SlicedData*>(this)->SetRequestedRegionToLargestPossibleRegion();
//
// const_cast<SlicedData*>(this)->UpdateOutputInformation();
//
// return GetSlicedGeometry(t)->GetGeometry2D(s);
//}
//
mitk::SlicedGeometry3D* mitk::SlicedData::GetSlicedGeometry(unsigned int t) const
{
if (GetTimeGeometry() == NULL)
return NULL;
return dynamic_cast<SlicedGeometry3D*>(GetTimeGeometry()->GetGeometryForTimeStep(t));
}
const mitk::SlicedGeometry3D* mitk::SlicedData::GetUpdatedSlicedGeometry(unsigned int t)
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetSlicedGeometry(t);
}
void mitk::SlicedData::SetGeometry(Geometry3D* aGeometry3D)
{
if(aGeometry3D!=NULL)
{
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
SlicedGeometry3D::Pointer slicedGeometry = dynamic_cast<SlicedGeometry3D*>(aGeometry3D);
if(slicedGeometry.IsNull())
{
Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(aGeometry3D);
if(geometry2d!=NULL)
{
if((GetSlicedGeometry()->GetGeometry2D(0)==geometry2d) && (GetSlicedGeometry()->GetSlices()==1))
return;
slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(geometry2d, 1);
}
else
{
slicedGeometry = SlicedGeometry3D::New();
PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
planeGeometry->InitializeStandardPlane(aGeometry3D);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, (unsigned int)(aGeometry3D->GetExtent(2)));
}
}
assert(slicedGeometry.IsNotNull());
timeGeometry->Initialize(slicedGeometry, 1);
Superclass::SetTimeGeometry(timeGeometry);
}
else
{
if(GetGeometry()==NULL)
return;
Superclass::SetGeometry(NULL);
}
}
void mitk::SlicedData::SetSpacing(const float aSpacing[3])
{
this->SetSpacing((mitk::Vector3D)aSpacing);
}
void mitk::SlicedData::SetOrigin(const mitk::Point3D& origin)
{
TimeGeometry* timeGeometry = GetTimeGeometry();
assert(timeGeometry!=NULL);
mitk::SlicedGeometry3D* slicedGeometry;
unsigned int steps = timeGeometry->GetNumberOfTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
slicedGeometry = GetSlicedGeometry(timestep);
if(slicedGeometry != NULL)
{
slicedGeometry->SetOrigin(origin);
if(slicedGeometry->GetEvenlySpaced())
{
mitk::Geometry2D* geometry2D = slicedGeometry->GetGeometry2D(0);
geometry2D->SetOrigin(origin);
slicedGeometry->InitializeEvenlySpaced(geometry2D, slicedGeometry->GetSlices());
}
}
- ProportionalTimeGeometry* timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(GetTimeGeometry());
- if(timeGeometry != NULL)
- {
- timeGeometry->Initialize(slicedGeometry, steps);
- break;
- }
+ //ProportionalTimeGeometry* timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(GetTimeGeometry());
+ //if(timeGeometry != NULL)
+ //{
+ // timeGeometry->Initialize(slicedGeometry, steps);
+ // break;
+ //}
}
}
void mitk::SlicedData::SetSpacing(mitk::Vector3D aSpacing)
{
TimeGeometry* timeGeometry = GetTimeGeometry();
assert(timeGeometry!=NULL);
mitk::SlicedGeometry3D* slicedGeometry;
unsigned int steps = timeGeometry->GetNumberOfTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
slicedGeometry = GetSlicedGeometry(timestep);
if(slicedGeometry != NULL)
{
slicedGeometry->SetSpacing(aSpacing);
}
- ProportionalTimeGeometry* timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(GetTimeGeometry());
- if(timeGeometry != NULL)
- {
- timeGeometry->Initialize(slicedGeometry, steps);
- break;
- }
}
}
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.cpp b/Core/Code/DataManagement/mitkTimeGeometry.cpp
index 0e69bac04c..40ee0b93ae 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkTimeGeometry.cpp
@@ -1,153 +1,161 @@
/*===================================================================
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);
Point3D minimumWorld;
GetGeometryForTimeStep(step)->IndexToWorld(minimum, minimumWorld);
Point3D maximumWorld;
GetGeometryForTimeStep(step)->IndexToWorld(maximum, maximumWorld);
points->push_back(minimumWorld);
points->push_back(maximumWorld);
}
if (lastModifiedTime >= this->GetMTime())
{
m_BoundingBox->SetPoints(points);
m_BoundingBox->ComputeBoundingBox();
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/DataManagement/mitkTimeGeometry.h b/Core/Code/DataManagement/mitkTimeGeometry.h
index 5399ca0779..7bf375e97a 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.h
+++ b/Core/Code/DataManagement/mitkTimeGeometry.h
@@ -1,227 +1,231 @@
/*===================================================================
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 TimeGeometry_h
#define TimeGeometry_h
//ITK
#include <itkBoundingBox.h>
#include <itkFixedArray.h>
#include <itkObject.h>
//MITK
#include <mitkCommon.h>
#include <MitkExports.h>
#include "mitkOperationActor.h"
#include "mitkVector.h"
// To be replaced
#include <mitkGeometry3D.h>
// STL
#include <vector>
namespace mitk {
// typedef itk::BoundingBox<unsigned long, 3, double> BoundingBox;
// typedef itk::FixedArray<ScalarType,2> TimeBounds;
// typedef unsigned long TimePointType;
typedef float TimePointType;
typedef std::size_t TimeStepType;
/**
* \brief Manages the geometries of a data object for each time step
*
* For each time step a geometry object is kept, which defines
* the position and transformation of the BasicObject.
*/
class MITK_CORE_EXPORT TimeGeometry : public itk::Object, public OperationActor
{
protected:
TimeGeometry();
virtual ~TimeGeometry();
/**
* \brief Contains a bounding box which includes all time steps
*/
BoundingBox::Pointer m_BoundingBox;
public:
mitkClassMacro(TimeGeometry, itk::Object);
/**
* \brief Returns the number of time steps.
*/
virtual TimeStepType GetNumberOfTimeSteps() const = 0;
/**
* \brief Returns the first time point for which the object is valid.
*/
virtual TimePointType GetMinimumTimePoint () const = 0;
/**
* \brief Returns the last time point for which the object is valid
*/
virtual TimePointType GetMaximumTimePoint () const = 0;
/**
* \brief Get the time bounds (in ms)
*/
virtual TimeBounds GetTimeBounds( ) const = 0;
/**
* \brief Tests if a given time point is covered by this object
*/
virtual bool IsValidTimePoint (TimePointType timePoint) const = 0;
/**
* \brief Test for the given time step if a geometry is availible
*/
virtual bool IsValidTimeStep (TimeStepType timeStep) const = 0;
/**
* \brief Converts a time step to a time point
*/
virtual TimePointType TimeStepToTimePoint (TimeStepType timeStep) const = 0;
/**
* \brief Converts a time point to the corresponding time step
*/
virtual TimeStepType TimePointToTimeStep (TimePointType timePoint) const = 0;
/**
* \brief Returns the geometry of a specific time point
*/
virtual Geometry3D* GetGeometryForTimePoint ( TimePointType timePoint) const = 0;
/**
* \brief Returns the geometry which corresponds to the given time step
*/
virtual Geometry3D* GetGeometryForTimeStep ( TimeStepType timeStep) const = 0;
/**
* \brief Returns a clone of the geometry of a specific time point
*/
virtual Geometry3D::Pointer GetGeometryCloneForTimeStep( TimeStepType timeStep) const = 0;
/**
* \brief Sets the geometry for a given time step
*/
virtual void SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep) = 0;
/**
* \brief Expands to the given number of time steps
*
* Expands to the given number of time steps. Each new created time
* step is filled with an empty geometry.
* Shrinking is not supported!
*/
virtual void Expand(TimeStepType size) = 0;
/**
* \brief Tests if all necessary informations are set and the object is valid
*/
virtual bool IsValid () = 0;
/**
* \brief Get the position of the corner number \a id (in world coordinates)
*
* See SetImageGeometry for how a corner is defined on images.
*/
Point3D GetCornerPointInWorld(int id) const;
/**
* \brief Get the position of a corner (in world coordinates)
*
* See SetImageGeometry for how a corner is defined on images.
*/
Point3D GetCornerPointInWorld(bool xFront=true, bool yFront=true, bool zFront=true) const;
/**
* \brief Get the center of the bounding-box in mm
*/
Point3D GetCenterInWorld() const;
/**
* \brief Get the squared length of the diagonal of the bounding-box in mm
*/
double GetDiagonalLength2InWorld() const;
/**
* \brief Get the length of the diagonal of the bounding-box in mm
*/
double GetDiagonalLengthinWorld() const;
/**
* \brief Test whether the point \a p (world coordinates in mm) is inside the bounding box
*/
bool IsWorldPointInside(const mitk::Point3D& p) const;
/**
* \brief Updates the bounding box to cover the area used in all time steps
*
* The bounding box is updated by this method. The new bounding box
* covers an area which includes all bounding boxes during
* all times steps.
*/
void UpdateBoundingBox();
/**
* \brief Returns a bounding box that covers all time steps
*/
BoundingBox* GetBoundingBoxInWorld() const
{
return m_BoundingBox;
}
/**
* \brief Returns the world bounds of the object that cover all time steps
*/
BoundingBox::BoundsArrayType GetBoundsInWorld() const
{
return m_BoundingBox->GetBounds();
}
/**
* \brief Returns the Extend of the bounding in the given direction
*/
ScalarType GetExtendInWorld (unsigned int direction) const;
/**
* \brief Makes a deep copy of the current object
*/
virtual TimeGeometry::Pointer Clone () const = 0 ;
/**
* \brief Initializes the TimeGeometry
*/
virtual void Initialize();
/**
* \brief Updates the geometry
*/
void Update();
/**
* \brief Updates everything except the Bounding box
*
* This class should be overwritten by child classes.
* The method is called when Update() is required.
*/
virtual void UpdateWithoutBoundingBox()
{};
+ /**
+ * \brief Executes the given operation on all time steps
+ */
+ virtual void ExecuteOperation(Operation *op);
}; // end class TimeGeometry
} // end namespace MITK
#endif // TimeGeometry_h
\ No newline at end of file
diff --git a/Core/Code/Testing/mitkImageTest.cpp b/Core/Code/Testing/mitkImageTest.cpp
index d2fc5d1e01..808757b76f 100644
--- a/Core/Code/Testing/mitkImageTest.cpp
+++ b/Core/Code/Testing/mitkImageTest.cpp
@@ -1,376 +1,375 @@
/*===================================================================
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);
+ 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;
ItkFloatImage3D::Pointer itkimage;
mitk::CastToItkImage(image, itkimage);
MITK_TEST_CONDITION_REQUIRED(itkimage.IsNotNull(), "Test conversion to itk::Image!");
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();
}
diff --git a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
index 9218e7c579..d246488adc 100644
--- a/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
+++ b/Core/Code/Testing/mitkSliceNavigationControllerTest.cpp
@@ -1,578 +1,579 @@
/*===================================================================
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 "mitkSliceNavigationController.h"
#include "mitkPlaneGeometry.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkRotationOperation.h"
#include "mitkInteractionConst.h"
#include "mitkPlanePositionManager.h"
#include "mitkTestingMacros.h"
#include "mitkGetModuleContext.h"
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_quaternion.txx>
#include <fstream>
bool operator==(const mitk::Geometry3D & left, const mitk::Geometry3D & right)
{
mitk::BoundingBox::BoundsArrayType leftbounds, rightbounds;
leftbounds =left.GetBounds();
rightbounds=right.GetBounds();
unsigned int i;
for(i=0;i<6;++i)
if(mitk::Equal(leftbounds[i],rightbounds[i])==false) return false;
const mitk::Geometry3D::TransformType::MatrixType & leftmatrix = left.GetIndexToWorldTransform()->GetMatrix();
const mitk::Geometry3D::TransformType::MatrixType & rightmatrix = right.GetIndexToWorldTransform()->GetMatrix();
unsigned int j;
for(i=0;i<3;++i)
{
const mitk::Geometry3D::TransformType::MatrixType::ValueType* leftvector = leftmatrix[i];
const mitk::Geometry3D::TransformType::MatrixType::ValueType* rightvector = rightmatrix[i];
for(j=0;j<3;++j)
if(mitk::Equal(leftvector[i],rightvector[i])==false) return false;
}
const mitk::Geometry3D::TransformType::OffsetType & leftoffset = left.GetIndexToWorldTransform()->GetOffset();
const mitk::Geometry3D::TransformType::OffsetType & rightoffset = right.GetIndexToWorldTransform()->GetOffset();
for(i=0;i<3;++i)
if(mitk::Equal(leftoffset[i],rightoffset[i])==false) return false;
return true;
}
-int compareGeometry(const mitk::TimeGeometry & geometry,
+int compareGeometry(const mitk::TimeGeometry & timeGeometry,
const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& numSlices,
const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::ScalarType& thicknessInMM,
const mitk::Point3D& cornerpoint0, const mitk::Vector3D& right, const mitk::Vector3D& bottom, const mitk::Vector3D& normal)
{
//Probleme durch umstellung von Time-SlicedGeometry auf TimeGeometry?
//Eventuell gibt es keine Entsprechung mehr.
+ const mitk::Geometry3D::Pointer geometry= timeGeometry.GetGeometryForTimeStep(0);
std::cout << "Testing width, height and thickness (in units): ";
- if((mitk::Equal(geometry.GetExtendInWorld(0),width)==false) ||
- (mitk::Equal(geometry.GetExtendInWorld(1),height)==false) ||
- (mitk::Equal(geometry.GetExtendInWorld(2),numSlices)==false)
+ if((mitk::Equal(geometry->GetExtent(0),width)==false) ||
+ (mitk::Equal(geometry->GetExtent(1),height)==false) ||
+ (mitk::Equal(geometry->GetExtent(2),numSlices)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing width, height and thickness (in mm): ";
- if((mitk::Equal(geometry.GetExtendInWorld(0),widthInMM)==false) ||
- (mitk::Equal(geometry.GetExtendInWorld(1),heightInMM)==false) ||
- (mitk::Equal(geometry.GetExtendInWorld(2),thicknessInMM)==false)
+ if((mitk::Equal(geometry->GetExtentInMM(0),widthInMM)==false) ||
+ (mitk::Equal(geometry->GetExtentInMM(1),heightInMM)==false) ||
+ (mitk::Equal(geometry->GetExtentInMM(2),thicknessInMM)==false)
)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetAxisVector(): ";
std::cout << "dir=0 ";
mitk::Vector3D dv;
dv=right; dv.Normalize(); dv*=widthInMM;
- if((mitk::Equal(geometry.GetGeometryForTimeStep(0)->GetAxisVector(0), dv)==false))
+ if((mitk::Equal(geometry->GetAxisVector(0), dv)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]";
std::cout << ", dir=1 ";
dv=bottom; dv.Normalize(); dv*=heightInMM;
- if((mitk::Equal(geometry.GetGeometryForTimeStep(0)->GetAxisVector(1), dv)==false))
+ if((mitk::Equal(geometry->GetAxisVector(1), dv)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]";
std::cout << ", dir=2 ";
dv=normal; dv.Normalize(); dv*=thicknessInMM;
- if((mitk::Equal(geometry.GetGeometryForTimeStep(0)->GetAxisVector(2), dv)==false))
+ if((mitk::Equal(geometry->GetAxisVector(2), dv)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing offset: ";
- if((mitk::Equal(geometry.GetGeometryForTimeStep(0)->GetCornerPoint(0),cornerpoint0)==false))
+ if((mitk::Equal(geometry->GetCornerPoint(0),cornerpoint0)==false))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
return EXIT_SUCCESS;
}
int testGeometry(const mitk::Geometry3D * geometry,
const mitk::ScalarType& width, const mitk::ScalarType& height, const mitk::ScalarType& numSlices,
const mitk::ScalarType& widthInMM, const mitk::ScalarType& heightInMM, const mitk::ScalarType& thicknessInMM,
const mitk::Point3D& cornerpoint0, const mitk::Vector3D& right, const mitk::Vector3D& bottom, const mitk::Vector3D& normal)
{
int result=EXIT_FAILURE;
std::cout << "Comparing GetCornerPoint(0) of Geometry3D with provided cornerpoint0: ";
if(mitk::Equal(geometry->GetCornerPoint(0), cornerpoint0)==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Creating and initializing a SliceNavigationController with the Geometry3D: ";
mitk::SliceNavigationController::Pointer sliceCtrl = mitk::SliceNavigationController::New();
sliceCtrl->SetInputWorldGeometry3D(geometry);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Axial): ";
sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Update(): ";
sliceCtrl->Update();
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing result of CreatedWorldGeometry(): ";
mitk::Point3D axialcornerpoint0;
axialcornerpoint0 = cornerpoint0+bottom+normal*(numSlices-1+0.5); //really -1?
result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, height, numSlices, widthInMM, heightInMM, thicknessInMM*numSlices, axialcornerpoint0, right, bottom*(-1.0), normal*(-1.0));
if(result!=EXIT_SUCCESS)
{
std::cout<<"[FAILED]"<<std::endl;
return result;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Frontal): ";
sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Frontal);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Update(): ";
sliceCtrl->Update();
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing result of CreatedWorldGeometry(): ";
mitk::Point3D frontalcornerpoint0;
frontalcornerpoint0 = cornerpoint0+geometry->GetAxisVector(1)*(+0.5/geometry->GetExtent(1));
result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), width, numSlices, height, widthInMM, thicknessInMM*numSlices, heightInMM, frontalcornerpoint0, right, normal, bottom);
if(result!=EXIT_SUCCESS)
{
std::cout<<"[FAILED]"<<std::endl;
return result;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing SetViewDirection(mitk::SliceNavigationController::Sagittal): ";
sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Sagittal);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Update(): "<<std::endl;
sliceCtrl->Update();
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing result of CreatedWorldGeometry(): ";
mitk::Point3D sagittalcornerpoint0;
sagittalcornerpoint0 = cornerpoint0+geometry->GetAxisVector(0)*(+0.5/geometry->GetExtent(0));
result = compareGeometry(*sliceCtrl->GetCreatedWorldGeometry(), height, numSlices, width, heightInMM, thicknessInMM*numSlices, widthInMM, sagittalcornerpoint0, bottom, normal, right);
if(result!=EXIT_SUCCESS)
{
std::cout<<"[FAILED]"<<std::endl;
return result;
}
std::cout<<"[PASSED]"<<std::endl;
return EXIT_SUCCESS;
}
int testReorientPlanes ()
{
//Create PlaneGeometry
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 1.5;
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
mitk::Vector3D spacing;
normal.Normalize(); normal *= thicknessInMM;
mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector(), &spacing);
planegeometry->SetOrigin(origin);
//Create SlicedGeometry3D out of planeGeometry
mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New();
unsigned int numSlices = 20;
slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create another slicedgeo which will be rotated
mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create geo3D as reference
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetBounds(slicedgeometry1->GetBounds());
geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform());
//Initialize planes
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry1->SetGeometry2D(geo2d,i);
}
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry2->SetGeometry2D(geo2d,i);
}
slicedgeometry1->SetReferenceGeometry(geometry);
slicedgeometry2->SetReferenceGeometry(geometry);
//Create SNC
mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
sliceCtrl1->Update();
mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
sliceCtrl2->SetInputWorldGeometry3D(slicedgeometry2);
sliceCtrl2->Update();
slicedgeometry1->SetSliceNavigationController(sliceCtrl1);
slicedgeometry2->SetSliceNavigationController(sliceCtrl2);
// Whats current geometry?
MITK_INFO << "center: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
MITK_INFO << "normal: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal();
MITK_INFO << "origin: " << sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
MITK_INFO << "axis0 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
MITK_INFO << "aixs1 : " << sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
//
// Now reorient slices (ONE POINT, ONE NORMAL)
mitk::Point3D oldCenter, oldOrigin;
mitk::Vector3D oldAxis0, oldAxis1;
oldCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
oldOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
oldAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
oldAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
mitk::Point3D orientCenter;
mitk::Vector3D orientNormal;
orientCenter = oldCenter;
mitk::FillVector3D(orientNormal, 0.3, 0.1, 0.8);
orientNormal.Normalize();
sliceCtrl1->ReorientSlices(orientCenter,orientNormal);
mitk::Point3D newCenter, newOrigin;
mitk::Vector3D newNormal;
newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
newOrigin = sliceCtrl1->GetCurrentPlaneGeometry()->GetOrigin();
newNormal = sliceCtrl1->GetCurrentPlaneGeometry()->GetNormal();
newNormal.Normalize();
itk::Index<3> orientCenterIdx;
itk::Index<3> newCenterIdx;
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx);
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx);
if (
(newCenterIdx != orientCenterIdx) ||
( !mitk::Equal(orientNormal, newNormal) )
)
{
MITK_INFO << "Reorient Planes (1 point, 1 vector) not working as it should";
MITK_INFO << "orientCenterIdx: " << orientCenterIdx;
MITK_INFO << "newCenterIdx: " << newCenterIdx;
MITK_INFO << "orientNormal: " << orientNormal;
MITK_INFO << "newNormal: " << newNormal;
return EXIT_FAILURE;
}
//
// Now reorient slices (center, vec0, vec1 )
mitk::Vector3D orientAxis0, orientAxis1, newAxis0, newAxis1;
mitk::FillVector3D(orientAxis0, 1.0, 0.0, 0.0);
mitk::FillVector3D(orientAxis1, 0.0, 1.0, 0.0);
orientAxis0.Normalize();
orientAxis1.Normalize();
sliceCtrl1->ReorientSlices(orientCenter,orientAxis0, orientAxis1);
newAxis0 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(0);
newAxis1 = sliceCtrl1->GetCurrentPlaneGeometry()->GetAxisVector(1);
newCenter = sliceCtrl1->GetCurrentPlaneGeometry()->GetCenter();
newAxis0.Normalize();
newAxis1.Normalize();
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(orientCenter, orientCenterIdx);
sliceCtrl1->GetCurrentGeometry3D()->WorldToIndex(newCenter, newCenterIdx);
if (
(newCenterIdx != orientCenterIdx) ||
( !mitk::Equal(orientAxis0, newAxis0) ) ||
( !mitk::Equal(orientAxis1, newAxis1) )
)
{
MITK_INFO << "Reorient Planes (point, vec, vec) not working as it should";
MITK_INFO << "orientCenterIdx: " << orientCenterIdx;
MITK_INFO << "newCenterIdx: " << newCenterIdx;
MITK_INFO << "orientAxis0: " << orientAxis0;
MITK_INFO << "newAxis0: " << newAxis0;
MITK_INFO << "orientAxis1: " << orientAxis1;
MITK_INFO << "newAxis1: " << newAxis1;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int testRestorePlanePostionOperation ()
{
//Create PlaneGeometry
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 1.5;
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
mitk::Vector3D spacing;
normal.Normalize(); normal *= thicknessInMM;
mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector(), &spacing);
planegeometry->SetOrigin(origin);
//Create SlicedGeometry3D out of planeGeometry
mitk::SlicedGeometry3D::Pointer slicedgeometry1 = mitk::SlicedGeometry3D::New();
unsigned int numSlices = 300;
slicedgeometry1->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create another slicedgeo which will be rotated
mitk::SlicedGeometry3D::Pointer slicedgeometry2 = mitk::SlicedGeometry3D::New();
slicedgeometry2->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
//Create geo3D as reference
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetBounds(slicedgeometry1->GetBounds());
geometry->SetIndexToWorldTransform(slicedgeometry1->GetIndexToWorldTransform());
//Initialize planes
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry1->SetGeometry2D(geo2d,i);
}
for (int i=0; i < (int)numSlices; i++)
{
mitk::PlaneGeometry::Pointer geo2d = mitk::PlaneGeometry::New();
geo2d->Initialize();
geo2d->SetReferenceGeometry(geometry);
slicedgeometry2->SetGeometry2D(geo2d,i);
}
slicedgeometry1->SetReferenceGeometry(geometry);
slicedgeometry2->SetReferenceGeometry(geometry);
//Create SNC
mitk::SliceNavigationController::Pointer sliceCtrl1 = mitk::SliceNavigationController::New();
sliceCtrl1->SetInputWorldGeometry3D(slicedgeometry1);
sliceCtrl1->Update();
mitk::SliceNavigationController::Pointer sliceCtrl2 = mitk::SliceNavigationController::New();
sliceCtrl2->SetInputWorldGeometry3D(slicedgeometry2);
sliceCtrl2->Update();
slicedgeometry1->SetSliceNavigationController(sliceCtrl1);
slicedgeometry2->SetSliceNavigationController(sliceCtrl2);
//Rotate slicedgeo2
double angle = 63.84;
mitk::Vector3D rotationVector; mitk::FillVector3D( rotationVector, 0.5, 0.95, 0.23 );
mitk::Point3D center = slicedgeometry2->GetCenter();
mitk::RotationOperation* op = new mitk::RotationOperation( mitk::OpROTATE, center, rotationVector, angle );
slicedgeometry2->ExecuteOperation(op);
sliceCtrl2->Update();
mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
service->AddNewPlanePosition(slicedgeometry2->GetGeometry2D(0), 178);
sliceCtrl1->ExecuteOperation(service->GetPlanePosition(0));
sliceCtrl1->Update();
mitk::Geometry2D* planeRotated = slicedgeometry2->GetGeometry2D(178);
mitk::Geometry2D* planeRestored = dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetGeometry2D(178);
try{
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(planeRotated->GetIndexToWorldTransform()->GetMatrix(), planeRestored->GetIndexToWorldTransform()->GetMatrix()),"Testing for IndexToWorld");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetOrigin(), planeRestored->GetOrigin(),2*mitk::eps),"Testing for origin");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(planeRotated->GetSpacing(), planeRestored->GetSpacing()),"Testing for spacing");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(slicedgeometry2->GetDirectionVector(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetDirectionVector()),"Testing for directionvector");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(slicedgeometry2->GetSlices(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetSlices()),"Testing for numslices");
MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(slicedgeometry2->GetIndexToWorldTransform()->GetMatrix(), dynamic_cast< const mitk::SlicedGeometry3D*>(sliceCtrl1->GetCurrentGeometry3D())->GetIndexToWorldTransform()->GetMatrix()),"Testing for IndexToWorld");
}
catch(...)
{
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int mitkSliceNavigationControllerTest(int /*argc*/, char* /*argv*/[])
{
int result=EXIT_FAILURE;
std::cout << "Creating and initializing a PlaneGeometry: ";
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
mitk::Point3D origin;
mitk::Vector3D right, bottom, normal;
mitk::ScalarType width, height;
mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
width = 100; widthInMM = width;
height = 200; heightInMM = height;
thicknessInMM = 1.5;
// mitk::FillVector3D(origin, 0, 0, thicknessInMM*0.5);
mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
mitk::FillVector3D(right, widthInMM, 0, 0);
mitk::FillVector3D(bottom, 0, heightInMM, 0);
mitk::FillVector3D(normal, 0, 0, thicknessInMM);
mitk::Vector3D spacing;
normal.Normalize(); normal *= thicknessInMM;
mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector(), &spacing);
planegeometry->SetOrigin(origin);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Creating and initializing a SlicedGeometry3D with the PlaneGeometry: ";
mitk::SlicedGeometry3D::Pointer slicedgeometry = mitk::SlicedGeometry3D::New();
unsigned int numSlices = 5;
slicedgeometry->InitializeEvenlySpaced(planegeometry, thicknessInMM, numSlices, false);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Creating a Geometry3D with the same extent as the SlicedGeometry3D: ";
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->SetBounds(slicedgeometry->GetBounds());
geometry->SetIndexToWorldTransform(slicedgeometry->GetIndexToWorldTransform());
std::cout<<"[PASSED]"<<std::endl;
mitk::Point3D cornerpoint0;
cornerpoint0 = geometry->GetCornerPoint(0);
result=testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
if(result!=EXIT_SUCCESS)
return result;
mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
transform->SetMatrix(geometry->GetIndexToWorldTransform()->GetMatrix());
mitk::BoundingBox::Pointer boundingbox = geometry->CalculateBoundingBoxRelativeToTransform(transform);
geometry->SetBounds(boundingbox->GetBounds());
cornerpoint0 = geometry->GetCornerPoint(0);
result=testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
if(result!=EXIT_SUCCESS)
return result;
std::cout << "Changing the IndexToWorldTransform of the geometry to a rotated version by SetIndexToWorldTransform() (keep cornerpoint0): ";
transform = mitk::AffineTransform3D::New();
mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
mitk::VnlVector axis(3);
mitk::FillVector3D(axis, 1.0, 1.0, 1.0); axis.normalize();
vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
vnlmatrix = rotation.rotation_matrix_transpose()*vnlmatrix;
mitk::Matrix3D matrix;
matrix = vnlmatrix;
transform->SetMatrix(matrix);
transform->SetOffset(cornerpoint0.GetVectorFromOrigin());
right.Set_vnl_vector( rotation.rotation_matrix_transpose()*right.Get_vnl_vector() );
bottom.Set_vnl_vector(rotation.rotation_matrix_transpose()*bottom.Get_vnl_vector());
normal.Set_vnl_vector(rotation.rotation_matrix_transpose()*normal.Get_vnl_vector());
geometry->SetIndexToWorldTransform(transform);
std::cout<<"[PASSED]"<<std::endl;
cornerpoint0 = geometry->GetCornerPoint(0);
result = testGeometry(geometry, width, height, numSlices, widthInMM, heightInMM, thicknessInMM, cornerpoint0, right, bottom, normal);
if(result!=EXIT_SUCCESS)
return result;
//Testing Execute RestorePlanePositionOperation
result = testRestorePlanePostionOperation();
if(result!=EXIT_SUCCESS)
return result;
//Testing ReorientPlanes
result = testReorientPlanes();
if(result!=EXIT_SUCCESS)
return result;
std::cout<<"[TEST DONE]"<<std::endl;
return EXIT_SUCCESS;
}