diff --git a/Core/Code/DataManagement/mitkBaseData.cpp b/Core/Code/DataManagement/mitkBaseData.cpp
index 1a9cc3fd75..df043b8903 100644
--- a/Core/Code/DataManagement/mitkBaseData.cpp
+++ b/Core/Code/DataManagement/mitkBaseData.cpp
@@ -1,419 +1,371 @@
/*===================================================================
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_TimeSlicedGeometry = TimeSlicedGeometry::New();
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_TimeSlicedGeometry = dynamic_cast<mitk::TimeSlicedGeometry*>(other.m_TimeSlicedGeometry->Clone().GetPointer());
- m_TimeGeometry = dynamic_cast<mitk::TimeGeometry*>(other.m_TimeGeometry->Clone().GetPointer());
+ m_TimeGeometry = other.m_TimeGeometry->Clone().GetPointer();
m_PropertyList = other.m_PropertyList->Clone();
}
mitk::BaseData::~BaseData()
{
m_SmartSourcePointer = NULL;
}
-void mitk::BaseData::InitializeTimeSlicedGeometry(unsigned int timeSteps)
+void mitk::BaseData::InitializeTimeGeometry(unsigned int timeSteps)
{
- //Oldmitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
-
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_TimeSlicedGeometry.IsNotNull())
- m_TimeSlicedGeometry->UpdateInformation();
if (m_TimeGeometry.IsNotNull())
{
m_TimeGeometry->UpdateBoundingBox();
}
}
-const mitk::TimeSlicedGeometry* mitk::BaseData::OldGetUpdatedTimeSlicedGeometry()
-{
- SetRequestedRegionToLargestPossibleRegion();
-
- UpdateOutputInformation();
-
- return NULL;
-//Old return GetTimeSlicedGeometry();
-}
-
const mitk::TimeGeometry* mitk::BaseData::GetUpdatedTimeGeometry()
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetTimeGeometry();
}
void mitk::BaseData::Expand( unsigned int timeSteps )
{
- if( m_TimeSlicedGeometry.IsNotNull() )
- m_TimeSlicedGeometry->ExpandToNumberOfTimeSteps( 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* aGeometry3D)
+void mitk::BaseData::SetGeometry(Geometry3D* geometry)
{
-if(aGeometry3D!=NULL)
+ ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
+ if(geometry!=NULL)
{
- TimeSlicedGeometry::Pointer timeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(aGeometry3D);
- if ( timeSlicedGeometry.IsNotNull() )
- m_TimeSlicedGeometry = timeSlicedGeometry;
- else
- {
- timeSlicedGeometry = TimeSlicedGeometry::New();
- m_TimeSlicedGeometry = timeSlicedGeometry;
- timeSlicedGeometry->InitializeEvenlyTimed(aGeometry3D, 1);
- }
- Modified();
- }
- else if( m_TimeSlicedGeometry.IsNotNull() )
- {
- m_TimeSlicedGeometry = NULL;
- Modified();
+ 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_TimeSlicedGeometry)
- {
- m_TimeSlicedGeometry->SetGeometry3D(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()), 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)
{
- //Old
- //mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
-
- //assert(timeSlicedGeometry!=NULL);
-
- //mitk::Geometry3D* geometry;
-
- //unsigned int steps = timeSlicedGeometry->GetTimeSteps();
-
- //for(unsigned int timestep = 0; timestep < steps; ++timestep)
- //{
- // geometry = GetGeometry(timestep);
- // if(geometry != NULL)
- // {
- // geometry->SetOrigin(origin);
- // }
- // if(GetTimeSlicedGeometry()->GetEvenlyTimed())
- // {
- // GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry, steps);
- // break;
- // }
- //}
-
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_TimeSlicedGeometry.IsNotNull())
+ if(m_TimeGeometry.IsNotNull())
{
- if((time < m_TimeSlicedGeometry->GetMTime()))
+ if((time < m_TimeGeometry->GetMTime()))
{
Modified();
return Superclass::GetMTime();
}
- //unsigned long geometryTime = m_TimeSlicedGeometry->GetMTime();
- //if(time < geometryTime)
- //{
- // return geometryTime;
- //}
}
return time;
}
void mitk::BaseData::CopyInformation( const itk::DataObject* data )
{
const Self* bd = dynamic_cast<const Self*>(data);
if (bd != NULL)
{
-//Old m_TimeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(bd->GetTimeSlicedGeometry()->Clone().GetPointer());
m_PropertyList = bd->GetPropertyList()->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;
-//Old os << indent << " TimeSlicedGeometry: ";
-//Old if(GetTimeSlicedGeometry() == NULL)
-//Old os << "NULL" << std::endl;
-//Old else
-//Old GetTimeSlicedGeometry()->Print(os, indent);
+ os << indent << " TimeGeometry: ";
+ if(GetTimeGeometry() == NULL)
+ os << "NULL" << std::endl;
+ else
+ GetTimeGeometry()->Print(os, indent);
}
-
diff --git a/Core/Code/DataManagement/mitkBaseData.h b/Core/Code/DataManagement/mitkBaseData.h
index ba4e0f6c87..ec6193603e 100644
--- a/Core/Code/DataManagement/mitkBaseData.h
+++ b/Core/Code/DataManagement/mitkBaseData.h
@@ -1,407 +1,394 @@
/*===================================================================
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 BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
#define BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
#include <itkDataObject.h>
#include "mitkBaseProcess.h"
#include "mitkTimeGeometry.h"
#include <MitkExports.h>
#include "mitkOperationActor.h"
#include "mitkPropertyList.h"
-//To be replaced
-#include "mitkTimeSlicedGeometry.h"
-
-
namespace mitk {
//class BaseProcess;
//##Documentation
//## @brief Base of all data objects
//##
//## Base of all data objects, e.g., images, contours, surfaces etc. Inherits
//## from itk::DataObject and thus can be included in a pipeline.
//## Inherits also from OperationActor and can be used as a destination for Undo
//## @ingroup Data
class MITK_CORE_EXPORT BaseData : public itk::DataObject, public OperationActor
{
public:
mitkClassMacro(BaseData,itk::DataObject)
- //##Documentation
- //## @brief Return the TimeSlicedGeometry of the data as const pointer.
- //##
- //## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
- //## be sure that the geometry is up-to-date.
- //##
- //## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
- const mitk::TimeSlicedGeometry* OldGetTimeSlicedGeometry() const
- {
- return m_TimeSlicedGeometry.GetPointer();
- }
-
+ /**
+ * \brief Return the TimeGeo of the data as const pointer.
+ *
+ * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
+ * be sure that the geometry is up-to-date.
+ *
+ * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
+ */
const mitk::TimeGeometry* GetTimeGeometry() const
{
return m_TimeGeometry.GetPointer();
}
- //##Documentation
- //## @brief Return the TimeSlicedGeometry of the data as pointer.
- //##
- //## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
- //## be sure that the geometry is up-to-date.
- //##
- //## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
- mitk::TimeSlicedGeometry* OldGetTimeSlicedGeometry()
- {
- return m_TimeSlicedGeometry.GetPointer();
- }
-
+ /**
+ * @brief Return the TimeGeometry of the data as pointer.
+ *
+ * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
+ * be sure that the geometry is up-to-date.
+ *
+ * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
+ */
mitk::TimeGeometry* GetTimeGeometry()
{
return m_TimeGeometry.GetPointer();
}
- //##Documentation
- //## @brief Return the Geometry3D of the data.
- //##
- //## The method does not simply return the value of the m_TimeSlicedGeometry
- //## member. Before doing this, it makes sure that the TimeSlicedGeometry
- //## is up-to-date (by setting the update extent to largest possible and
- //## calling UpdateOutputInformation).
- const mitk::TimeSlicedGeometry* OldGetUpdatedTimeSlicedGeometry();
+ /**
+ * @brief Return the Geometry3D of the data.
+ *
+ * The method does not simply return the value of the m_TimeGeometry
+ * member. Before doing this, it makes sure that the TimeGeometry
+ * is up-to-date (by setting the update extent to largest possible and
+ * calling UpdateOutputInformation).
+ */
const mitk::TimeGeometry* GetUpdatedTimeGeometry();
- //##Documentation
- //## @brief Expands the TimeSlicedGeometry to a number of TimeSteps.
- //##
- //## The method expands the TimeSlicedGeometry to the given number of TimeSteps,
- //## filling newly created elements with empty geometries. Sub-classes should override
- //## this method to handle the elongation of their data vectors, too.
- //## Note that a shrinking is neither possible nor intended.
+ /**
+ * \brief Expands the TimeGeometry to a number of TimeSteps.
+ *
+ * The method expands the TimeGeometry to the given number of TimeSteps,
+ * filling newly created elements with empty geometries. Sub-classes should override
+ * this method to handle the elongation of their data vectors, too.
+ * Note that a shrinking is neither possible nor intended.
+ */
virtual void Expand( unsigned int timeSteps );
- //##Documentation
- //## @brief Return the Geometry3D of the data at time \a t.
- //##
- //## The method does not simply return
- //## m_TimeSlicedGeometry->GetGeometry(t).
- //## Before doing this, it makes sure that the Geometry3D is up-to-date
- //## (by setting the update extent appropriately and calling
- //## UpdateOutputInformation).
- //##
- //## @todo Appropriate setting of the update extent is missing.
+ /**
+ * \brief Return the Geometry3D of the data at time \a t.
+ *
+ * The method does not simply return
+ * m_TimeGeometry->GetGeometry(t).
+ * Before doing this, it makes sure that the Geometry3D is up-to-date
+ * (by setting the update extent appropriately and calling
+ * UpdateOutputInformation).
+ *
+ * @todo Appropriate setting of the update extent is missing.
+ */
const mitk::Geometry3D* GetUpdatedGeometry(int t=0);
//##Documentation
- //## @brief Return the geometry, which is a TimeSlicedGeometry, of the data
+ //## @brief Return the geometry, which is a TimeGeometry, of the data
//## as non-const pointer.
//##
//## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
//## be sure that the geometry is up-to-date.
//##
//## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
mitk::Geometry3D* GetGeometry(int t=0) const
{
- if(m_TimeSlicedGeometry.IsNull())
+ if(m_TimeGeometry.IsNull())
return NULL;
- return m_TimeSlicedGeometry->GetGeometry3D(t);
+ return m_TimeGeometry->GetGeometryForTimeStep(t);
}
//##Documentation
//## @brief Helps to deal with the weak-pointer-problem.
virtual void UnRegister() const;
//##Documentation
//## @brief for internal use only. Helps to deal with the
//## weak-pointer-problem.
virtual int GetExternalReferenceCount() const;
//##Documentation
//## @brief Update the information for this BaseData (the geometry in particular)
//## so that it can be used as an output of a BaseProcess.
//##
//## This method is used in the pipeline mechanism to propagate information and
//## initialize the meta data associated with a BaseData. Any implementation
//## of this method in a derived class is assumed to call its source's
//## BaseProcess::UpdateOutputInformation() which determines modified
//## times, LargestPossibleRegions, and any extra meta data like spacing,
//## origin, etc. Default implementation simply call's it's source's
//## UpdateOutputInformation().
//## \note Implementations of this methods in derived classes must take care
//## that the geometry is updated by calling
- //## GetTimeSlicedGeometry()->UpdateInformation()
+ //## GetTimeGeometry()->UpdateInformation()
//## \em after calling its source's BaseProcess::UpdateOutputInformation().
void UpdateOutputInformation();
//##Documentation
//## @brief Set the RequestedRegion to the LargestPossibleRegion.
//##
//## This forces a filter to produce all of the output in one execution
//## (i.e. not streaming) on the next call to Update().
void SetRequestedRegionToLargestPossibleRegion()=0;
//##Documentation
//## @brief Determine whether the RequestedRegion is outside of the BufferedRegion.
//##
//## This method returns true if the RequestedRegion
//## is outside the BufferedRegion (true if at least one pixel is
//## outside). This is used by the pipeline mechanism to determine
//## whether a filter needs to re-execute in order to satisfy the
//## current request. If the current RequestedRegion is already
//## inside the BufferedRegion from the previous execution (and the
//## current filter is up to date), then a given filter does not need
//## to re-execute
bool RequestedRegionIsOutsideOfTheBufferedRegion()=0;
//##Documentation
//## @brief Verify that the RequestedRegion is within the LargestPossibleRegion.
//##
//## If the RequestedRegion is not within the LargestPossibleRegion,
//## then the filter cannot possibly satisfy the request. This method
//## returns true if the request can be satisfied (even if it will be
//## necessary to process the entire LargestPossibleRegion) and
//## returns false otherwise. This method is used by
//## PropagateRequestedRegion(). PropagateRequestedRegion() throws a
//## InvalidRequestedRegionError exception if the requested region is
//## not within the LargestPossibleRegion.
virtual bool VerifyRequestedRegion() = 0;
//##Documentation
//## @brief Copy information from the specified data set.
//##
//## This method is part of the pipeline execution model. By default, a
//## BaseProcess will copy meta-data from the first input to all of its
//## outputs. See ProcessObject::GenerateOutputInformation(). Each
//## subclass of DataObject is responsible for being able to copy
//## whatever meta-data it needs from another DataObject.
//## The default implementation of this method copies the time sliced geometry
//## and the property list of an object. If a subclass overrides this
//## method, it should always call its superclass' version.
void CopyInformation(const itk::DataObject* data);
//##Documentation
//## @brief Check whether the data has been initialized, i.e.,
//## at least the Geometry and other header data has been set
//##
//## \warning Set to \a true by default for compatibility reasons.
//## Set m_Initialized=false in constructors of sub-classes that
//## support distinction between initialized and uninitialized state.
virtual bool IsInitialized() const;
//##Documentation
//## @brief Calls ClearData() and InitializeEmpty();
//## \warning Only use in subclasses that reimplemented these methods.
//## Just calling Clear from BaseData will reset an object to a not initialized,
//## invalid state.
virtual void Clear();
//##Documentation
//## @brief Check whether object contains data (at
//## a specified time), e.g., a set of points may be empty
//##
//## \warning Returns IsInitialized()==false by default for
//## compatibility reasons. Override in sub-classes that
//## support distinction between empty/non-empty state.
virtual bool IsEmptyTimeStep(unsigned int t) const;
//##Documentation
//## @brief Check whether object contains data (at
//## least at one point in time), e.g., a set of points
//## may be empty
//##
//## \warning Returns IsInitialized()==false by default for
//## compatibility reasons. Override in sub-classes that
//## support distinction between empty/non-empty state.
virtual bool IsEmpty() const;
//##Documentation
//## @brief Set the requested region from this data object to match the requested
//## region of the data object passed in as a parameter.
//##
//## This method is implemented in the concrete subclasses of BaseData.
void SetRequestedRegion(itk::DataObject *data)=0;
//##Documentation
//##@brief overwrite if the Data can be called by an Interactor (StateMachine).
//##
//## Empty by default. Overwrite and implement all the necessary operations here
//## and get the necessary information from the parameter operation.
void ExecuteOperation(Operation* operation);
//##Documentation
//## @brief Set the Geometry3D of the data, which will be referenced (not copied!).
//## Assumes the data object has only 1 time step ( is a 3D object ).
//##
//## For convenience (and historic) reasons, it is also possible to set a complete
- //## mitk::TimeSlicedGeometry*, which will be referenced (not copied!).
+ //## mitk::TimeGeometry*, which will be referenced (not copied!).
//##
//## @warning This method will normally be called internally by the sub-class of BaseData
//## during initialization.
//## \sa SetClonedGeometry
virtual void SetGeometry(Geometry3D* aGeometry3D);
virtual void SetTimeGeometry (TimeGeometry* geometry);
//##Documentation
//## @brief Set a clone of the provided geometry as Geometry3D of the data.
//## Assumes the data object has only 1 time step ( is a 3D object )
//##
//## \sa SetGeometry
virtual void SetClonedGeometry(const Geometry3D* aGeometry3D);
virtual void SetClonedTimeGeometry (const TimeGeometry* geometry);
//##Documentation
//## @brief Set a clone of the provided geometry as Geometry3D of a given time step.
//##
//## \sa SetGeometry
virtual void SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time);
//##Documentation
//## @brief Get the data's property list
//## @sa GetProperty
//## @sa m_PropertyList
mitk::PropertyList::Pointer GetPropertyList() const;
//##Documentation
//## @brief Set the data's property list
//## @sa SetProperty
//## @sa m_PropertyList
void SetPropertyList(PropertyList* propertyList);
//##Documentation
//## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList,
//## and set it to this, respectively;
//## @sa GetPropertyList
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
mitk::BaseProperty::Pointer GetProperty(const char *propertyKey) const;
void SetProperty(const char *propertyKey, BaseProperty* property);
//##Documentation
//## @brief Convenience method for setting the origin of
//## the Geometry3D instances of all time steps
//##
//## \warning Geometries contained in the Geometry3D will
//## \em not be changed, e.g. in case the Geometry3D is a
//## SlicedGeometry3D the origin will \em not be propagated
//## to the contained slices. The sub-class SlicedData
//## does this for the case that the SlicedGeometry3D is
//## evenly spaced.
virtual void SetOrigin(const Point3D& origin);
/** \brief Get the process object that generated this data object.
*
* If there is no process object, then the data object has
* been disconnected from the pipeline, or the data object
* was created manually. (Note: we cannot use the GetObjectMacro()
* defined in itkMacro because the mutual dependency of
* DataObject and ProcessObject causes compile problems. Also,
* a forward reference smart pointer is returned, not a smart pointer,
* because of the circular dependency between the process and data object.)
*
* GetSource() returns a SmartPointer and not a WeakPointer
* because it is assumed the code calling GetSource() wants to hold a
* long term reference to the source. */
itk::SmartPointer<mitk::BaseProcess> GetSource() const;
//##Documentation
- //## @brief Get the number of time steps from the Timeslicedgeometry
+ //## @brief Get the number of time steps from the TimeGeometry
//## As the base data has not a data vector given by itself, the number
//## of time steps is defined over the time sliced geometry. In sub classes,
//## a better implementation could be over the length of the data vector.
unsigned int GetTimeSteps() const
{
-
return m_TimeGeometry->GetNumberOfTimeSteps();
- return m_TimeSlicedGeometry->GetTimeSteps();
}
//##Documentation
//## @brief Get the modified time of the last change of the contents
//## this data object or its geometry.
virtual unsigned long GetMTime() const;
protected:
BaseData();
BaseData(const BaseData &other);
~BaseData();
//##Documentation
- //## @brief Initialize the TimeSlicedGeometry for a number of time steps.
- //## The TimeSlicedGeometry is initialized empty and evenly timed.
+ //## \brief Initialize the TimeGeometry for a number of time steps.
+ //## The TimeGeometry is initialized empty and evenly timed.
//## In many cases it will be necessary to overwrite this in sub-classes.
- virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 );
+ virtual void InitializeTimeGeometry( unsigned int timeSteps = 1 );
//##Documentation
//## @brief reset to non-initialized state, release memory
virtual void ClearData();
//##Documentation
//## @brief Pure virtual; Must be used in subclasses to get a data object to a
//## valid state. Should at least create one empty object and call
- //## Superclass::InitializeTimeSlicedGeometry() to ensure an existing valid geometry
+ //## Superclass::InitializeTimeGeometry() to ensure an existing valid geometry
virtual void InitializeEmpty(){}
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
bool m_RequestedRegionInitialized;
bool m_LastRequestedRegionWasOutsideOfTheBufferedRegion;
mutable itk::SmartPointer<mitk::BaseProcess> m_SmartSourcePointer;
mutable unsigned int m_SourceOutputIndexDuplicate;
//##Documentation
//## @brief for internal use only. Helps to deal with the
//## weak-pointer-problem.
virtual void ConnectSource(itk::ProcessObject *arg, unsigned int idx) const;
bool m_Initialized;
private:
//##Documentation
//## @brief Helps to deal with the weak-pointer-problem.
mutable bool m_Unregistering;
//##Documentation
//## @brief Helps to deal with the weak-pointer-problem.
mutable bool m_CalculatingExternalReferenceCount;
//##Documentation
//## @brief Helps to deal with the weak-pointer-problem.
mutable int m_ExternalReferenceCount;
//##Documentation
//## @brief PropertyList, f.e. to hold pic-tags, tracking-data,..
//##
PropertyList::Pointer m_PropertyList;
- TimeSlicedGeometry::Pointer m_TimeSlicedGeometry;
TimeGeometry::Pointer m_TimeGeometry;
//##Documentation
//## @brief Helps to deal with the weak-pointer-problem.
friend class mitk::BaseProcess;
};
} // namespace mitk
#endif /* BASEDATA_H_HEADER_INCLUDED_C1EBB6FA */
diff --git a/Core/Code/DataManagement/mitkBaseDataTestImplementation.h b/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
index 647e81f273..757d598fe6 100644
--- a/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
+++ b/Core/Code/DataManagement/mitkBaseDataTestImplementation.h
@@ -1,59 +1,59 @@
/*===================================================================
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 BASEDATAIMPLEMENTATION_H_HEADER_INCLUDED
#define BASEDATAIMPLEMENTATION_H_HEADER_INCLUDED
#include "mitkBaseData.h"
namespace mitk {
//##Documentation
//## @brief Implementation of BaseData (for testing)
//##
//## As BaseData is an abstract class, we need an implementation for testing its methods
//## @ingroup Data
class BaseDataTestImplementation : public BaseData
{
public:
mitkClassMacro(BaseDataTestImplementation, BaseData);
itkNewMacro(Self);
mitkCloneMacro(BaseDataTestImplementation);
- virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps /* = 1 */ )
+ virtual void InitializeTimeGeometry( unsigned int timeSteps /* = 1 */ )
{
- Superclass::InitializeTimeSlicedGeometry(timeSteps);
+ Superclass::InitializeTimeGeometry(timeSteps);
}
protected:
virtual bool VerifyRequestedRegion(){return false;};
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion(){return false;};
virtual void SetRequestedRegionToLargestPossibleRegion(){};
virtual void SetRequestedRegion(itk::DataObject * /*data*/){};
BaseDataTestImplementation(){};
virtual ~BaseDataTestImplementation(){};
};
} // namespace
#endif // BASEDATA_H_HEADER_INCLUDED
diff --git a/Core/Code/DataManagement/mitkPointSet.cpp b/Core/Code/DataManagement/mitkPointSet.cpp
index 3ab0ec9162..fb163d8f47 100755
--- a/Core/Code/DataManagement/mitkPointSet.cpp
+++ b/Core/Code/DataManagement/mitkPointSet.cpp
@@ -1,796 +1,796 @@
/*===================================================================
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 "mitkPointSet.h"
#include "mitkPointOperation.h"
#include "mitkInteractionConst.h"
mitk::PointSet::PointSet()
{
this->InitializeEmpty();
}
mitk::PointSet::PointSet(const PointSet &other): BaseData(other)
{
// Copy overall geometry information
this->SetGeometry(other.GetGeometry());
// Copy geometry information of every single timestep
for (unsigned int t=0; t < other.GetTimeSteps(); t++)
{
this->SetClonedGeometry( other.GetGeometry(t) );
}
// Expand to desired amount of timesteps
this->Expand(other.GetTimeSteps());
// Copy points
for (unsigned int t=0; t < other.GetTimeSteps(); t++)
{
for (int i=0; i< other.GetSize(t); i++)
{
this->InsertPoint(i, other.GetPoint(i,t), t);
}
}
}
mitk::PointSet::~PointSet()
{
this->ClearData();
}
void mitk::PointSet::ClearData()
{
m_PointSetSeries.clear();
Superclass::ClearData();
}
void mitk::PointSet::InitializeEmpty()
{
m_PointSetSeries.resize( 1 );
m_PointSetSeries[0] = DataType::New();
PointDataContainer::Pointer pointData = PointDataContainer::New();
m_PointSetSeries[0]->SetPointData( pointData );
m_CalculateBoundingBox = false;
- Superclass::InitializeTimeSlicedGeometry(1);
+ Superclass::InitializeTimeGeometry(1);
m_Initialized = true;
}
bool mitk::PointSet::IsEmptyTimeStep(unsigned int t) const
{
return IsInitialized() && (GetSize(t) == 0);
}
void mitk::PointSet::Expand( unsigned int timeSteps )
{
// Check if the vector is long enough to contain the new element
// at the given position. If not, expand it with sufficient pre-initialized
// elements.
//
// NOTE: This method will never REDUCE the vector size; it should only
// be used to make sure that the vector has enough elements to include the
// specified time step.
unsigned int oldSize = m_PointSetSeries.size();
if ( timeSteps > oldSize )
{
Superclass::Expand( timeSteps );
m_PointSetSeries.resize( timeSteps );
for ( unsigned int i = oldSize; i < timeSteps; ++i )
{
m_PointSetSeries[i] = DataType::New();
PointDataContainer::Pointer pointData = PointDataContainer::New();
m_PointSetSeries[i]->SetPointData( pointData );
}
//if the size changes, then compute the bounding box
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetExtendTimeRangeEvent() );
}
}
unsigned int mitk::PointSet::GetPointSetSeriesSize() const
{
return m_PointSetSeries.size();
}
int mitk::PointSet::GetSize( unsigned int t ) const
{
if ( t < m_PointSetSeries.size() )
{
return m_PointSetSeries[t]->GetNumberOfPoints();
}
else
{
return 0;
}
}
mitk::PointSet::DataType::Pointer mitk::PointSet::GetPointSet( int t ) const
{
if ( t < (int)m_PointSetSeries.size() )
{
return m_PointSetSeries[t];
}
else
{
return NULL;
}
}
int mitk::PointSet::SearchPoint( Point3D point, float distance, int t ) const
{
if ( t >= (int)m_PointSetSeries.size() )
{
return -1;
}
// Out is the point which is checked to be the searched point
PointType out;
out.Fill( 0 );
PointType indexPoint;
this->GetGeometry( t )->WorldToIndex(point, indexPoint);
// Searching the first point in the Set, that is +- distance far away fro
// the given point
unsigned int i;
PointsContainer::Iterator it, end;
end = m_PointSetSeries[t]->GetPoints()->End();
int bestIndex = -1;
distance = distance * distance;
// To correct errors from converting index to world and world to index
if (distance == 0.0)
{
distance = 0.000001;
}
ScalarType bestDist = distance;
ScalarType dist, tmp;
for ( it = m_PointSetSeries[t]->GetPoints()->Begin(), i = 0;
it != end;
++it, ++i )
{
bool ok = m_PointSetSeries[t]->GetPoints()
->GetElementIfIndexExists( it->Index(), &out );
if ( !ok )
{
return -1;
}
else if ( indexPoint == out ) //if totally equal
{
return it->Index();
}
//distance calculation
tmp = out[0] - indexPoint[0]; dist = tmp * tmp;
tmp = out[1] - indexPoint[1]; dist += tmp * tmp;
tmp = out[2] - indexPoint[2]; dist += tmp * tmp;
if ( dist < bestDist )
{
bestIndex = it->Index();
bestDist = dist;
}
}
return bestIndex;
}
mitk::PointSet::PointType
mitk::PointSet::GetPoint( PointIdentifier id, int t ) const
{
PointType out;
out.Fill(0);
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return out;
}
if ( m_PointSetSeries[t]->GetPoints()->IndexExists(id) )
{
m_PointSetSeries[t]->GetPoint( id, &out );
this->GetGeometry(t)->IndexToWorld( out, out );
return out;
}
else
{
return out;
}
}
bool
mitk::PointSet
::GetPointIfExists( PointIdentifier id, PointType* point, int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return false;
}
if ( m_PointSetSeries[t]->GetPoints()->GetElementIfIndexExists(id, point) )
{
this->GetGeometry( t )->IndexToWorld( *point, *point );
return true;
}
else
{
return false;
}
}
void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, int t )
{
// Adapt the size of the data vector if necessary
this->Expand( t+1 );
mitk::Point3D indexPoint;
this->GetGeometry( t )->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->SetPoint( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = mitk::PTUNDEFINED;
m_PointSetSeries[t]->SetPointData( id, defaultPointData );
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
{
// Adapt the size of the data vector if necessary
this->Expand( t+1 );
mitk::Point3D indexPoint;
this->GetGeometry( t )->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->SetPoint( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = spec;
m_PointSetSeries[t]->SetPointData( id, defaultPointData );
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, int t )
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
mitk::Point3D indexPoint;
mitk::Geometry3D* tempGeometry = this->GetGeometry( t );
if (tempGeometry == NULL)
{
MITK_INFO<< __FILE__ << ", l." << __LINE__ << ": GetGeometry of "<< t <<" returned NULL!" << std::endl;
return;
}
tempGeometry->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->GetPoints()->InsertElement( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = mitk::PTUNDEFINED;
m_PointSetSeries[t]->GetPointData()->InsertElement(id, defaultPointData);
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
}
void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
mitk::Point3D indexPoint;
mitk::Geometry3D* tempGeometry = this->GetGeometry( t );
if (tempGeometry == NULL)
{
MITK_INFO<< __FILE__ << ", l." << __LINE__ << ": GetGeometry of "<< t <<" returned NULL!" << std::endl;
return;
}
tempGeometry->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->GetPoints()->InsertElement( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = spec;
m_PointSetSeries[t]->GetPointData()->InsertElement(id, defaultPointData);
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
}
bool mitk::PointSet::SwapPointPosition( PointIdentifier id, bool moveUpwards, int t )
{
if(IndexExists(id, t) )
{
PointType point = GetPoint(id,t);
if(moveUpwards)
{//up
if(IndexExists(id-1,t))
{
InsertPoint(id, GetPoint(id - 1, t), t);
InsertPoint(id-1,point,t);
this->Modified();
return true;
}
}
else
{//down
if(IndexExists(id+1,t))
{
InsertPoint(id, GetPoint(id + 1, t), t);
InsertPoint(id+1,point,t);
this->Modified();
return true;
}
}
}
return false;
}
bool mitk::PointSet::IndexExists( int position, int t ) const
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
return m_PointSetSeries[t]->GetPoints()->IndexExists( position );
}
else
{
return false;
}
}
bool mitk::PointSet::GetSelectInfo( int position, int t ) const
{
if ( this->IndexExists( position, t ) )
{
PointDataType pointData = { 0, false, PTUNDEFINED };
m_PointSetSeries[t]->GetPointData( position, &pointData );
return pointData.selected;
}
else
{
return false;
}
}
void mitk::PointSet::SetSelectInfo( int position, bool selected, int t )
{
if ( this->IndexExists( position, t ) )
{
// timeStep to ms
TimePointType timeInMS = this->GetTimeGeometry()->TimeStepToTimePoint( t );
// point
Point3D point = this->GetPoint( position, t );
std::auto_ptr<PointOperation> op;
if (selected)
{
op.reset(new mitk::PointOperation(OpSELECTPOINT, timeInMS, point, position ));
}
else
{
op.reset(new mitk::PointOperation(OpDESELECTPOINT, timeInMS, point, position ));
}
this->ExecuteOperation( op.get() );
}
}
mitk::PointSpecificationType mitk::PointSet::GetSpecificationTypeInfo( int position, int t ) const
{
if ( this->IndexExists( position, t ) )
{
PointDataType pointData = { 0, false, PTUNDEFINED };
m_PointSetSeries[t]->GetPointData( position, &pointData );
return pointData.pointSpec;
}
else
{
return PTUNDEFINED;
}
}
int mitk::PointSet::GetNumberOfSelected( int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return 0;
}
int numberOfSelected = 0;
PointDataIterator it;
for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
it != m_PointSetSeries[t]->GetPointData()->End();
it++ )
{
if (it->Value().selected == true)
{
++numberOfSelected;
}
}
return numberOfSelected;
}
int mitk::PointSet::SearchSelectedPoint( int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return -1;
}
PointDataIterator it;
for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
it != m_PointSetSeries[t]->GetPointData()->End();
it++ )
{
if ( it->Value().selected == true )
{
return it->Index();
}
}
return -1;
}
void mitk::PointSet::ExecuteOperation( Operation* operation )
{
int timeStep = -1;
mitkCheckOperationTypeMacro(PointOperation, operation, pointOp);
if ( pointOp )
{
timeStep = this->GetTimeGeometry()->TimePointToTimeStep( pointOp->GetTimeInMS() );
}
if ( timeStep < 0 )
{
MITK_ERROR << "Time step (" << timeStep << ") outside of PointSet time bounds" << std::endl;
return;
}
switch (operation->GetOperationType())
{
case OpNOTHING:
break;
case OpINSERT://inserts the point at the given position and selects it.
{
int position = pointOp->GetIndex();
PointType pt;
pt.CastFrom(pointOp->GetPoint());
//transfer from world to index coordinates
mitk::Geometry3D* geometry = this->GetGeometry( timeStep );
if (geometry == NULL)
{
MITK_INFO<<"GetGeometry returned NULL!\n";
return;
}
geometry->WorldToIndex(pt, pt);
m_PointSetSeries[timeStep]->GetPoints()->InsertElement(position, pt);
PointDataType pointData =
{
static_cast<unsigned int>(pointOp->GetIndex()),
pointOp->GetSelected(),
pointOp->GetPointType()
};
m_PointSetSeries[timeStep]->GetPointData()
->InsertElement(position, pointData);
this->Modified();
//boundingbox has to be computed
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetAddEvent() );
this->OnPointSetChange();
}
break;
case OpMOVE://moves the point given by index
{
PointType pt;
pt.CastFrom(pointOp->GetPoint());
//transfer from world to index coordinates
this->GetGeometry( timeStep )->WorldToIndex(pt, pt);
// Copy new point into container
m_PointSetSeries[timeStep]->SetPoint(pointOp->GetIndex(), pt);
// Insert a default point data object to keep the containers in sync
// (if no point data object exists yet)
PointDataType pointData;
if ( !m_PointSetSeries[timeStep]->GetPointData( pointOp->GetIndex(), &pointData ) )
{
m_PointSetSeries[timeStep]->SetPointData( pointOp->GetIndex(), pointData );
}
this->OnPointSetChange();
this->Modified();
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetMoveEvent() );
}
break;
case OpREMOVE://removes the point at given by position
{
m_PointSetSeries[timeStep]->GetPoints()->DeleteIndex((unsigned)pointOp->GetIndex());
m_PointSetSeries[timeStep]->GetPointData()->DeleteIndex((unsigned)pointOp->GetIndex());
this->OnPointSetChange();
this->Modified();
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetRemoveEvent() );
}
break;
case OpSELECTPOINT://select the given point
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.selected = true;
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpDESELECTPOINT://unselect the given point
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.selected = false;
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpSETPOINTTYPE:
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.pointSpec = pointOp->GetPointType();
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpMOVEPOINTUP: // swap content of point with ID pointOp->GetIndex() with the point preceding it in the container // move point position within the pointset
{
PointIdentifier currentID = pointOp->GetIndex();
/* search for point with this id and point that precedes this one in the data container */
PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
PointsContainer::STLContainerType::iterator it = points.find(currentID);
if (it == points.end()) // ID not found
break;
if (it == points.begin()) // we are at the first element, there is no previous element
break;
/* get and cache current point & pointdata and previous point & pointdata */
--it;
PointIdentifier prevID = it->first;
if (this->SwapPointContents(prevID, currentID, timeStep) == true)
this->Modified();
}
break;
case OpMOVEPOINTDOWN: // move point position within the pointset
{
PointIdentifier currentID = pointOp->GetIndex();
/* search for point with this id and point that succeeds this one in the data container */
PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
PointsContainer::STLContainerType::iterator it = points.find(currentID);
if (it == points.end()) // ID not found
break;
++it;
if (it == points.end()) // ID is already the last element, there is no succeeding element
break;
/* get and cache current point & pointdata and previous point & pointdata */
PointIdentifier nextID = it->first;
if (this->SwapPointContents(nextID, currentID, timeStep) == true)
this->Modified();
}
break;
default:
itkWarningMacro("mitkPointSet could not understrand the operation. Please check!");
break;
}
//to tell the mappers, that the data is modified and has to be updated
//only call modified if anything is done, so call in cases
//this->Modified();
mitk::OperationEndEvent endevent(operation);
((const itk::Object*)this)->InvokeEvent(endevent);
//*todo has to be done here, cause of update-pipeline not working yet
// As discussed lately, don't mess with the rendering from inside data structures
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PointSet::UpdateOutputInformation()
{
if ( this->GetSource( ) )
{
this->GetSource( )->UpdateOutputInformation( );
}
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as PointSets are present
//
TimeGeometry* timeGeometry = GetTimeGeometry();
if ( timeGeometry->GetNumberOfTimeSteps() != m_PointSetSeries.size() )
{
itkExceptionMacro(<<"timeGeometry->GetNumberOfTimeSteps() != m_PointSetSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
// This is needed to detect zero objects
mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsNull(nullpoint);
//
// Iterate over the PointSets and update the Geometry
// information of each of the items.
//
if (m_CalculateBoundingBox)
{
for ( unsigned int i = 0 ; i < m_PointSetSeries.size() ; ++i )
{
const DataType::BoundingBoxType *bb = m_PointSetSeries[i]->GetBoundingBox();
BoundingBox::BoundsArrayType itkBounds = bb->GetBounds();
if ( m_PointSetSeries[i].IsNull() || (m_PointSetSeries[i]->GetNumberOfPoints() == 0)
|| (itkBounds == itkBoundsNull) )
{
itkBounds = itkBoundsNull;
continue;
}
// Ensure minimal bounds of 1.0 in each dimension
for ( unsigned int j = 0; j < 3; ++j )
{
if ( itkBounds[j*2+1] - itkBounds[j*2] < 1.0 )
{
BoundingBox::CoordRepType center =
(itkBounds[j*2] + itkBounds[j*2+1]) / 2.0;
itkBounds[j*2] = center - 0.5;
itkBounds[j*2+1] = center + 0.5;
}
}
this->GetGeometry(i)->SetBounds(itkBounds);
}
m_CalculateBoundingBox = false;
}
this->GetTimeGeometry()->Update();
}
void mitk::PointSet::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::PointSet::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::PointSet::VerifyRequestedRegion()
{
return true;
}
void mitk::PointSet::SetRequestedRegion( itk::DataObject * )
{
}
void mitk::PointSet::PrintSelf( std::ostream& os, itk::Indent indent ) const
{
Superclass::PrintSelf(os, indent);
os << indent << "Number timesteps: " << m_PointSetSeries.size() << "\n";
unsigned int i = 0;
for (PointSetSeries::const_iterator it = m_PointSetSeries.begin(); it != m_PointSetSeries.end(); ++it)
{
os << indent << "Timestep " << i++ << ": \n";
MeshType::Pointer ps = *it;
itk::Indent nextIndent = indent.GetNextIndent();
ps->Print(os, nextIndent);
MeshType::PointsContainer* points = ps->GetPoints();
MeshType::PointDataContainer* datas = ps->GetPointData();
MeshType::PointDataContainer::Iterator dataIterator = datas->Begin();
for (MeshType::PointsContainer::Iterator pointIterator = points->Begin();
pointIterator != points->End();
++pointIterator, ++dataIterator)
{
os << nextIndent << "Point " << pointIterator->Index() << ": [";
os << pointIterator->Value().GetElement(0);
for (unsigned int i = 1; i < PointType::GetPointDimension(); ++i)
{
os << ", " << pointIterator->Value().GetElement(i);
}
os << "]";
os << ", selected: " << dataIterator->Value().selected << ", point spec: " << dataIterator->Value().pointSpec << "\n";
}
}
}
bool mitk::PointSet::SwapPointContents(PointIdentifier id1, PointIdentifier id2, int timeStep)
{
/* search and cache contents */
PointType p1;
if (m_PointSetSeries[timeStep]->GetPoint(id1, &p1) == false)
return false;
PointDataType data1;
if (m_PointSetSeries[timeStep]->GetPointData(id1, &data1) == false)
return false;
PointType p2;
if (m_PointSetSeries[timeStep]->GetPoint(id2, &p2) == false)
return false;
PointDataType data2;
if (m_PointSetSeries[timeStep]->GetPointData(id2, &data2) == false)
return false;
/* now swap contents */
m_PointSetSeries[timeStep]->SetPoint(id1, p2);
m_PointSetSeries[timeStep]->SetPointData(id1, data2);
m_PointSetSeries[timeStep]->SetPoint(id2, p1);
m_PointSetSeries[timeStep]->SetPointData(id2, data1);
return true;
}
diff --git a/Core/Code/DataManagement/mitkSurface.cpp b/Core/Code/DataManagement/mitkSurface.cpp
index e46acac581..5993482106 100644
--- a/Core/Code/DataManagement/mitkSurface.cpp
+++ b/Core/Code/DataManagement/mitkSurface.cpp
@@ -1,386 +1,386 @@
/*===================================================================
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 "mitkSurface.h"
#include "mitkInteractionConst.h"
#include "mitkSurfaceOperation.h"
#include <algorithm>
#include <vtkPolyData.h>
static vtkPolyData* DeepCopy(vtkPolyData* other)
{
if (other == NULL)
return NULL;
vtkPolyData* copy = vtkPolyData::New();
copy->DeepCopy(other);
return copy;
}
static void Delete(vtkPolyData* polyData)
{
if (polyData != NULL)
polyData->Delete();
}
static void Update(vtkPolyData* polyData)
{
if (polyData != NULL)
polyData->Update();
}
mitk::Surface::Surface()
: m_CalculateBoundingBox(false)
{
this->InitializeEmpty();
}
mitk::Surface::Surface(const mitk::Surface& other)
: BaseData(other),
m_LargestPossibleRegion(other.m_LargestPossibleRegion),
m_RequestedRegion(other.m_RequestedRegion),
m_CalculateBoundingBox(other.m_CalculateBoundingBox)
{
if(!other.m_PolyDatas.empty())
{
m_PolyDatas.resize(other.m_PolyDatas.size());
std::transform(other.m_PolyDatas.begin(), other.m_PolyDatas.end(), m_PolyDatas.begin(), DeepCopy);
}
else
{
this->InitializeEmpty();
}
}
void mitk::Surface::Swap(mitk::Surface& other)
{
std::swap(m_PolyDatas, other.m_PolyDatas);
std::swap(m_LargestPossibleRegion, other.m_LargestPossibleRegion);
std::swap(m_RequestedRegion, other.m_RequestedRegion);
std::swap(m_CalculateBoundingBox, other.m_CalculateBoundingBox);
}
mitk::Surface& mitk::Surface::operator=(Surface other)
{
this->Swap(other);
return *this;
}
mitk::Surface::~Surface()
{
this->ClearData();
}
void mitk::Surface::ClearData()
{
using ::Delete;
std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Delete);
m_PolyDatas.clear();
Superclass::ClearData();
}
const mitk::Surface::RegionType& mitk::Surface::GetLargestPossibleRegion() const
{
m_LargestPossibleRegion.SetIndex(3, 0);
m_LargestPossibleRegion.SetSize(3, GetTimeGeometry()->GetNumberOfTimeSteps());
return m_LargestPossibleRegion;
}
const mitk::Surface::RegionType& mitk::Surface::GetRequestedRegion() const
{
return m_RequestedRegion;
}
void mitk::Surface::InitializeEmpty()
{
if (!m_PolyDatas.empty())
this->ClearData();
- Superclass::InitializeTimeSlicedGeometry();
+ Superclass::InitializeTimeGeometry();
m_PolyDatas.push_back(NULL);
m_Initialized = true;
}
void mitk::Surface::SetVtkPolyData(vtkPolyData* polyData, unsigned int t)
{
this->Expand(t + 1);
if (m_PolyDatas[t] != NULL)
{
if (m_PolyDatas[t] == polyData)
return;
m_PolyDatas[t]->Delete();
}
m_PolyDatas[t] = polyData;
if(polyData != NULL)
polyData->Register(NULL);
m_CalculateBoundingBox = true;
this->Modified();
this->UpdateOutputInformation();
}
bool mitk::Surface::IsEmptyTimeStep(unsigned int t) const
{
if(!IsInitialized())
return false;
vtkPolyData* polyData = const_cast<Surface*>(this)->GetVtkPolyData(t);
return polyData == NULL || (
polyData->GetNumberOfLines() == 0 &&
polyData->GetNumberOfPolys() == 0 &&
polyData->GetNumberOfStrips() == 0 &&
polyData->GetNumberOfVerts() == 0
);
}
vtkPolyData* mitk::Surface::GetVtkPolyData(unsigned int t)
{
if (t < m_PolyDatas.size())
{
if(m_PolyDatas[t] == NULL && this->GetSource().IsNotNull())
{
RegionType requestedRegion;
requestedRegion.SetIndex(3, t);
requestedRegion.SetSize(3, 1);
this->SetRequestedRegion(&requestedRegion);
this->GetSource()->Update();
}
return m_PolyDatas[t];
}
return NULL;
}
void mitk::Surface::UpdateOutputInformation()
{
if (this->GetSource().IsNotNull())
this->GetSource()->UpdateOutputInformation();
if (m_CalculateBoundingBox == true && !m_PolyDatas.empty())
this->CalculateBoundingBox();
else
this->GetTimeGeometry()->Update();
}
void mitk::Surface::CalculateBoundingBox()
{
TimeGeometry* timeSlicedGeometry = this->GetTimeGeometry();
if (timeSlicedGeometry->GetNumberOfTimeSteps() != m_PolyDatas.size())
mitkThrow() << "Number of geometry time steps is inconsistent with number of poly data pointers.";
for (unsigned int i = 0; i < m_PolyDatas.size(); ++i)
{
vtkPolyData* polyData = m_PolyDatas[i];
vtkFloatingPointType bounds[6] = {0};
if (polyData != NULL && polyData->GetNumberOfPoints() > 0)
{
polyData->Update();
polyData->ComputeBounds();
polyData->GetBounds(bounds);
}
Geometry3D::Pointer geometry = timeSlicedGeometry->GetGeometryForTimeStep(i);
if (geometry.IsNull())
mitkThrow() << "Time-sliced geometry is invalid (equals NULL).";
geometry->SetFloatBounds(bounds);
}
timeSlicedGeometry->Update();
m_CalculateBoundingBox = false;
}
void mitk::Surface::SetRequestedRegionToLargestPossibleRegion()
{
m_RequestedRegion = GetLargestPossibleRegion();
}
bool mitk::Surface::RequestedRegionIsOutsideOfTheBufferedRegion()
{
RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3);
if(static_cast<RegionType::IndexValueType>(m_PolyDatas.size()) < end)
return true;
for(RegionType::IndexValueType t = m_RequestedRegion.GetIndex(3); t < end; ++t)
{
if(m_PolyDatas[t] == NULL)
return true;
}
return false;
}
bool mitk::Surface::VerifyRequestedRegion()
{
if(m_RequestedRegion.GetIndex(3) >= 0 && m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3) <= m_PolyDatas.size())
return true;
return false;
}
void mitk::Surface::SetRequestedRegion(itk::DataObject* data)
{
mitk::Surface* surface = dynamic_cast<mitk::Surface*>(data);
if (surface != NULL)
m_RequestedRegion = surface->GetRequestedRegion();
else
mitkThrow() << "Data object used to get requested region is not a mitk::Surface.";
}
void mitk::Surface::SetRequestedRegion(Surface::RegionType* region)
{
if (region == NULL)
mitkThrow() << "Requested region is invalid (equals NULL)";
m_RequestedRegion = *region;
}
void mitk::Surface::CopyInformation(const itk::DataObject* data)
{
Superclass::CopyInformation(data);
const mitk::Surface* surface = dynamic_cast<const mitk::Surface*>(data);
if (surface == NULL)
mitkThrow() << "Data object used to get largest possible region is not a mitk::Surface.";
m_LargestPossibleRegion = surface->GetLargestPossibleRegion();
}
void mitk::Surface::Update()
{
using ::Update;
if (this->GetSource().IsNull())
std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Update);
Superclass::Update();
}
void mitk::Surface::Expand(unsigned int timeSteps)
{
if (timeSteps > m_PolyDatas.size())
{
Superclass::Expand(timeSteps);
m_PolyDatas.resize(timeSteps);
m_CalculateBoundingBox = true;
}
}
void mitk::Surface::ExecuteOperation(Operation* operation)
{
switch (operation->GetOperationType())
{
case OpSURFACECHANGED:
{
mitk::SurfaceOperation* surfaceOperation = dynamic_cast<mitk::SurfaceOperation*>(operation);
if(surfaceOperation == NULL)
break;
unsigned int timeStep = surfaceOperation->GetTimeStep();
if(m_PolyDatas[timeStep] != NULL)
{
vtkPolyData* updatedPolyData = surfaceOperation->GetVtkPolyData();
if(updatedPolyData != NULL)
{
this->SetVtkPolyData(updatedPolyData, timeStep);
this->CalculateBoundingBox();
this->Modified();
}
}
break;
}
default:
return;
}
}
unsigned int mitk::Surface::GetSizeOfPolyDataSeries() const
{
return m_PolyDatas.size();
}
void mitk::Surface::Graft(const DataObject* data)
{
const Surface* surface = dynamic_cast<const Surface*>(data);
if(surface == NULL)
mitkThrow() << "Data object used to graft surface is not a mitk::Surface.";
this->CopyInformation(data);
m_PolyDatas.clear();
for (unsigned int i = 0; i < surface->GetSizeOfPolyDataSeries(); ++i)
{
m_PolyDatas.push_back(vtkPolyData::New());
m_PolyDatas.back()->DeepCopy(const_cast<mitk::Surface*>(surface)->GetVtkPolyData(i));
}
}
void mitk::Surface::PrintSelf(std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "\nNumber PolyDatas: " << m_PolyDatas.size() << "\n";
unsigned int count = 0;
for (std::vector<vtkPolyData*>::const_iterator it = m_PolyDatas.begin(); it != m_PolyDatas.end(); ++it)
{
os << "\n";
if(*it != NULL)
{
os << indent << "PolyData at time step " << count << ":\n";
os << indent << "Number of cells: " << (*it)->GetNumberOfCells() << "\n";
os << indent << "Number of points: " << (*it)->GetNumberOfPoints() << "\n\n";
os << indent << "VTKPolyData:\n";
(*it)->Print(os);
}
else
{
os << indent << "Empty PolyData at time step " << count << "\n";
}
++count;
}
}
diff --git a/Core/Code/Testing/mitkBaseDataTest.cpp b/Core/Code/Testing/mitkBaseDataTest.cpp
index 8712e950fa..3426f2ff58 100644
--- a/Core/Code/Testing/mitkBaseDataTest.cpp
+++ b/Core/Code/Testing/mitkBaseDataTest.cpp
@@ -1,121 +1,121 @@
/*===================================================================
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 "mitkBaseDataTestImplementation.h"
#include "mitkStringProperty.h"
#include "mitkTestingMacros.h"
#include <mitkTimeGeometry.h>
#include <mitkProportionalTimeGeometry.h>
#include "itkImage.h"
int mitkBaseDataTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN("BaseData")
//Create a BaseData implementation
MITK_INFO << "Creating a base data instance...";
mitk::BaseDataTestImplementation::Pointer baseDataImpl = mitk::BaseDataTestImplementation::New();
MITK_TEST_CONDITION_REQUIRED(baseDataImpl.IsNotNull(),"Testing instantiation");
MITK_TEST_CONDITION(baseDataImpl->IsInitialized(), "BaseDataTestImplementation is initialized");
MITK_TEST_CONDITION(baseDataImpl->IsEmpty(), "BaseDataTestImplementation is initialized and empty");
MITK_TEST_CONDITION(baseDataImpl->GetExternalReferenceCount()== baseDataImpl->GetReferenceCount(), "Checks external reference count!");
mitk::BaseDataTestImplementation::Pointer cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION_REQUIRED(cloneBaseData.IsNotNull(),"Testing instantiation of base data clone");
MITK_TEST_CONDITION(cloneBaseData->IsInitialized(), "Clone of BaseDataTestImplementation is initialized");
MITK_TEST_CONDITION(cloneBaseData->IsEmpty(), "Clone of BaseDataTestImplementation is initialized and empty");
MITK_TEST_CONDITION(cloneBaseData->GetExternalReferenceCount()== cloneBaseData->GetReferenceCount(), "Checks external reference count of base data clone!");
MITK_INFO << "Testing setter and getter for geometries...";
//test method GetTimeSlicedGeometry()
MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry(), "Testing creation of TimeSlicedGeometry");
- mitk::TimeSlicedGeometry* geo = NULL;
- baseDataImpl->SetGeometry(geo);
+ mitk::TimeGeometry* geo = NULL;
+ baseDataImpl->SetTimeGeometry(geo);
MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry() == NULL, "Reset Geometry");
mitk::ProportionalTimeGeometry::Pointer geo2 = mitk::ProportionalTimeGeometry::New();
baseDataImpl->SetTimeGeometry(geo2);
geo2->Initialize(2);
MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry() == geo2.GetPointer(), "Correct Reinit of TimeslicedGeometry");
//test method GetGeometry(int timeStep)
MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1) != NULL, "... and single Geometries");
//test method Expand(unsigned int timeSteps)
baseDataImpl->Expand(5);
MITK_TEST_CONDITION(baseDataImpl->GetTimeSteps() == 5, "Expand the geometry to further time slices!");
//test method GetUpdatedGeometry(int timeStep);
mitk::Geometry3D::Pointer geo3 = mitk::Geometry3D::New();
mitk::ProportionalTimeGeometry::Pointer timeSlicedGeometry = dynamic_cast<mitk::ProportionalTimeGeometry *>(baseDataImpl->GetTimeGeometry());
if (timeSlicedGeometry.IsNotNull() )
{
timeSlicedGeometry->SetTimeStepGeometry(geo3,1);
}
MITK_TEST_CONDITION(baseDataImpl->GetUpdatedGeometry(1) == geo3, "Set Geometry for time step 1");
MITK_TEST_CONDITION(baseDataImpl->GetMTime()!= 0, "Check if modified time is set");
baseDataImpl->SetClonedGeometry(geo3, 1);
float x[3];
x[0] = 2;
x[1] = 4;
x[2] = 6;
mitk::Point3D p3d(x);
baseDataImpl->SetOrigin(p3d);
geo3->SetOrigin(p3d);
MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing Origin set");
cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION(cloneBaseData->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing origin set in clone!");
MITK_TEST_CONDITION(!baseDataImpl->IsEmptyTimeStep(1), "Is not empty before clear()!");
baseDataImpl->Clear();
MITK_TEST_CONDITION(baseDataImpl->IsEmptyTimeStep(1), "...but afterwards!");
//test method Set-/GetProperty()
baseDataImpl->SetProperty("property38", mitk::StringProperty::New("testproperty"));
//baseDataImpl->SetProperty("visibility", mitk::BoolProperty::New());
MITK_TEST_CONDITION(baseDataImpl->GetProperty("property38")->GetValueAsString() == "testproperty","Check if base property is set correctly!");
cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION(cloneBaseData->GetProperty("property38")->GetValueAsString() == "testproperty", "Testing origin set in clone!");
//test method Set-/GetPropertyList
mitk::PropertyList::Pointer propertyList = mitk::PropertyList::New();
propertyList->SetFloatProperty("floatProperty1", 123.45);
propertyList->SetBoolProperty("visibility",true);
propertyList->SetStringProperty("nameXY","propertyName");
baseDataImpl->SetPropertyList(propertyList);
bool value = false;
MITK_TEST_CONDITION(baseDataImpl->GetPropertyList() == propertyList, "Check if base property list is set correctly!");
MITK_TEST_CONDITION(baseDataImpl->GetPropertyList()->GetBoolProperty("visibility", value) == true, "Check if base property is set correctly in the property list!");
//test method UpdateOutputInformation()
baseDataImpl->UpdateOutputInformation();
MITK_TEST_CONDITION(baseDataImpl->GetUpdatedTimeGeometry() == geo2, "TimeSlicedGeometry update!");
//Test method CopyInformation()
mitk::BaseDataTestImplementation::Pointer newBaseData = mitk::BaseDataTestImplementation::New();
newBaseData->CopyInformation(baseDataImpl);
MITK_TEST_CONDITION_REQUIRED( newBaseData->GetTimeGeometry()->GetNumberOfTimeSteps() == 5, "Check copying of of Basedata Data Object!");
MITK_TEST_END()
}
diff --git a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
index 3e1ec39945..53b415c29c 100644
--- a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
+++ b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
@@ -1,250 +1,250 @@
/*===================================================================
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 "mitkUnstructuredGrid.h"
#include <vtkUnstructuredGrid.h>
#include <itkSmartPointerForwardReference.txx>
void mitk::UnstructuredGrid::SetVtkUnstructuredGrid( vtkUnstructuredGrid* grid, unsigned int t )
{
this->Expand(t);
if(m_GridSeries[ t ] != NULL)
{
m_GridSeries[ t ]->Delete();
}
m_GridSeries[ t ] = grid;
// call m_VtkPolyData->Register(NULL) to tell the reference counting that we
// want to keep a reference on the object
if (m_GridSeries[t] != 0)
m_GridSeries[t]->Register(grid);
this->Modified();
m_CalculateBoundingBox = true;
}
void mitk::UnstructuredGrid::Expand(unsigned int timeSteps)
{
// check if the vector is long enough to contain the new element
// at the given position. If not, expand it with sufficient zero-filled elements.
if(timeSteps > m_GridSeries.size())
{
Superclass::Expand(timeSteps);
vtkUnstructuredGrid* pdnull = 0;
m_GridSeries.resize( timeSteps, pdnull );
m_CalculateBoundingBox = true;
}
}
void mitk::UnstructuredGrid::ClearData()
{
for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin(); it != m_GridSeries.end(); ++it )
{
if ( ( *it ) != 0 )
( *it )->Delete();
}
m_GridSeries.clear();
Superclass::ClearData();
}
void mitk::UnstructuredGrid::InitializeEmpty()
{
vtkUnstructuredGrid* pdnull = 0;
m_GridSeries.resize( 1, pdnull );
- Superclass::InitializeTimeSlicedGeometry(1);
+ Superclass::InitializeTimeGeometry(1);
m_Initialized = true;
}
vtkUnstructuredGrid* mitk::UnstructuredGrid::GetVtkUnstructuredGrid(unsigned int t)
{
if ( t < m_GridSeries.size() )
{
vtkUnstructuredGrid* grid = m_GridSeries[ t ];
if((grid == 0) && (GetSource().GetPointer() != 0))
{
RegionType requestedregion;
requestedregion.SetIndex(3, t);
requestedregion.SetSize(3, 1);
SetRequestedRegion(&requestedregion);
GetSource()->Update();
}
grid = m_GridSeries[ t ];
return grid;
}
else
return 0;
}
mitk::UnstructuredGrid::UnstructuredGrid() : m_CalculateBoundingBox( false )
{
this->InitializeEmpty();
}
mitk::UnstructuredGrid::UnstructuredGrid(const mitk::UnstructuredGrid &other) :
BaseData(other),
m_CalculateBoundingBox( other.m_CalculateBoundingBox ),
m_LargestPossibleRegion(other.m_LargestPossibleRegion)
{
if(!other.m_Initialized)
{
this->InitializeEmpty();
}
else
{
m_GridSeries = other.m_GridSeries;
m_Initialized = other.m_Initialized;
}
this->SetRequestedRegion( const_cast<mitk::UnstructuredGrid*>(&other) );
}
mitk::UnstructuredGrid::~UnstructuredGrid()
{
this->ClearData();
}
void mitk::UnstructuredGrid::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if ( ( m_CalculateBoundingBox ) && ( m_GridSeries.size() > 0 ) )
CalculateBoundingBox();
else
GetTimeGeometry()->Update();
}
void mitk::UnstructuredGrid::CalculateBoundingBox()
{
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as vtkUnstructuredGrids are present
//
TimeGeometry* timeGeometry = GetTimeGeometry();
if ( timeGeometry->GetNumberOfTimeSteps() != m_GridSeries.size() )
{
itkExceptionMacro(<<"timeGeometry->GetNumberOfTimeSteps() != m_GridSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
//
// Iterate over the vtkUnstructuredGrids and update the Geometry
// information of each of the items.
//
for ( unsigned int i = 0 ; i < m_GridSeries.size() ; ++i )
{
vtkUnstructuredGrid* grid = m_GridSeries[ i ];
vtkFloatingPointType bounds[ ] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
if ( ( grid != 0 ) && ( grid->GetNumberOfCells() > 0 ) )
{
grid->Update();
grid->ComputeBounds();
grid->GetBounds( bounds );
}
mitk::Geometry3D::Pointer g3d = timeGeometry->GetGeometryForTimeStep( i );
assert( g3d.IsNotNull() );
g3d->SetFloatBounds( bounds );
}
timeGeometry->Update();
mitk::BoundingBox::Pointer bb = const_cast<mitk::BoundingBox*>( timeGeometry->GetBoundingBoxInWorld() );
itkDebugMacro( << "boundingbox min: "<< bb->GetMinimum());
itkDebugMacro( << "boundingbox max: "<< bb->GetMaximum());
m_CalculateBoundingBox = false;
}
void mitk::UnstructuredGrid::SetRequestedRegionToLargestPossibleRegion()
{
m_RequestedRegion = GetLargestPossibleRegion();
}
bool mitk::UnstructuredGrid::RequestedRegionIsOutsideOfTheBufferedRegion()
{
RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3);
if(((RegionType::IndexValueType)m_GridSeries.size()) < end)
return true;
for( RegionType::IndexValueType t=m_RequestedRegion.GetIndex(3); t < end; ++t )
if(m_GridSeries[t] == 0)
return true;
return false;
}
bool mitk::UnstructuredGrid::VerifyRequestedRegion()
{
if( (m_RequestedRegion.GetIndex(3)>=0) &&
(m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3)<=m_GridSeries.size()) )
return true;
return false;
}
void mitk::UnstructuredGrid::SetRequestedRegion( itk::DataObject *data )
{
mitk::UnstructuredGrid *gridData;
gridData = dynamic_cast<mitk::UnstructuredGrid*>(data);
if (gridData)
{
m_RequestedRegion = gridData->GetRequestedRegion();
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(UnstructuredGrid*).name() );
}
}
void mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType *region) //by arin
{
if(region != 0)
{
m_RequestedRegion = *region;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(UnstructuredGrid*).name() );
}
}
void mitk::UnstructuredGrid::CopyInformation( const itk::DataObject * data )
{
Superclass::CopyInformation(data);
}
void mitk::UnstructuredGrid::Update()
{
if ( GetSource().IsNull() )
{
for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin() ; it != m_GridSeries.end() ; ++it )
{
if ( ( *it ) != 0 )
( *it )->Update();
}
}
Superclass::Update();
}
diff --git a/Modules/Segmentation/DataManagement/mitkContour.cpp b/Modules/Segmentation/DataManagement/mitkContour.cpp
index a05f536e4b..b26104ee9b 100644
--- a/Modules/Segmentation/DataManagement/mitkContour.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContour.cpp
@@ -1,165 +1,165 @@
/*===================================================================
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 "mitkContour.h"
#include <mitkProportionalTimeGeometry.h>
mitk::Contour::Contour() :
m_ContourPath (PathType::New()),
m_CurrentWindow ( NULL ),
m_BoundingBox (BoundingBoxType::New()),
m_Vertices ( BoundingBoxType::PointsContainer::New() ),
m_Closed ( true ),
m_Selected ( false ),
m_Width (3.0)
{
- Superclass::InitializeTimeSlicedGeometry();
+ Superclass::InitializeTimeGeometry();
}
mitk::Contour::Contour( const Contour & other ): BaseData(other),
m_ContourPath(other.m_ContourPath),
m_CurrentWindow(other.m_CurrentWindow),
m_BoundingBox(other.m_BoundingBox),
m_Vertices(other.m_Vertices),
m_Closed(other.m_Closed),
m_Selected(other.m_Selected),
m_Width(other.m_Width)
{
}
mitk::Contour::~Contour()
{
}
void mitk::Contour::AddVertex(mitk::Point3D newPoint)
{
BoundingBoxType::PointType p;
p.CastFrom(newPoint);
m_Vertices->InsertElement(m_Vertices->Size(), p);
ContinuousIndexType idx;
idx.CastFrom(newPoint);
m_ContourPath->AddVertex(idx);
m_BoundingBox->SetPoints(m_Vertices);
Modified();
}
void mitk::Contour::UpdateOutputInformation()
{
// \todo probably we should do this additionally for each time-step
float mitkBounds[6];
if (m_Vertices->Size() == 0) {
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
}
else
{
m_BoundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = m_BoundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
}
Geometry3D* geometry3d = GetGeometry(0);
geometry3d->SetBounds(mitkBounds);
GetTimeGeometry()->Update();
}
void mitk::Contour::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::Contour::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::Contour::VerifyRequestedRegion()
{
return true;
}
void mitk::Contour::SetRequestedRegion(itk::DataObject*)
{
}
mitk::Contour::PathType::Pointer mitk::Contour::GetContourPath() const
{
return m_ContourPath;
}
void mitk::Contour::SetCurrentWindow(vtkRenderWindow* rw)
{
m_CurrentWindow = rw;
}
vtkRenderWindow* mitk::Contour::GetCurrentWindow() const
{
return m_CurrentWindow;
}
void mitk::Contour::Initialize()
{
m_ContourPath = PathType::New();
m_ContourPath->Initialize();
m_BoundingBox = BoundingBoxType::New();
m_Vertices = BoundingBoxType::PointsContainer::New();
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(1);
SetTimeGeometry(timeGeometry);
}
unsigned int mitk::Contour::GetNumberOfPoints() const
{
return m_Vertices->Size();
}
mitk::Contour::PointsContainerPointer
mitk::Contour::GetPoints() const
{
return m_Vertices;
}
void mitk::Contour::SetPoints(mitk::Contour::PointsContainerPointer points)
{
m_Vertices = points;
Modified();
}
void mitk::Contour::PrintSelf( std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf( os, indent );
os << indent << "Number of verticies: " << GetNumberOfPoints() << std::endl;
mitk::Contour::PointsContainerIterator pointsIt = m_Vertices->Begin(), end = m_Vertices->End();
os << indent << "Verticies: " << std::endl;
int i = 0;
while ( pointsIt != end )
{
os << indent << indent << i << ": " << pointsIt.Value() << std::endl;
++pointsIt; ++i;
}
}
diff --git a/Modules/Segmentation/DataManagement/mitkContourModel.cpp b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
index aea9c45b70..a36ce32ef7 100644
--- a/Modules/Segmentation/DataManagement/mitkContourModel.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
@@ -1,552 +1,552 @@
/*===================================================================
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 <mitkContourModel.h>
#include <mitkPlaneGeometry.h>
mitk::ContourModel::ContourModel()
{
//set to initial state
this->InitializeEmpty();
}
mitk::ContourModel::ContourModel(const mitk::ContourModel &other) :
m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
{
m_SelectedVertex = NULL;
}
mitk::ContourModel::~ContourModel()
{
m_SelectedVertex = NULL;
this->m_ContourSeries.clear();//TODO check destruction
}
void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) )
{
this->AddVertex(vertex, false, timestep);
}
}
void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertex(vertex, isControlPoint);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::AddVertex(VertexType &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertex(vertex);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) )
{
this->AddVertexAtFront(vertex, false, timestep);
}
}
void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertexAtFront(vertex, isControlPoint);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertexAtFront(vertex);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
void mitk::ContourModel::InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(index > 0 && this->m_ContourSeries[timestep]->GetSize() > index)
{
this->m_ContourSeries[timestep]->InsertVertexAtIndex(vertex, isControlPoint, index);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
}
int mitk::ContourModel::GetNumberOfVertices( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetSize();
}
return -1;
}
const mitk::ContourModel::VertexType* mitk::ContourModel::GetVertexAt(int index, int timestep) const
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetVertexAt(index);
}
return NULL;
}
void mitk::ContourModel::Close( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Close();
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();
}
}
void mitk::ContourModel::Open( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Open();
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();
}
}
void mitk::ContourModel::SetIsClosed(bool isClosed, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->SetIsClosed(isClosed);
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();
}
}
bool mitk::ContourModel::IsEmptyTimeStep( int t) const
{
return (t < 0) || (this->m_ContourSeries.size() <= t);
}
void mitk::ContourModel::Concatenate(mitk::ContourModel* other, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if( !this->m_ContourSeries[timestep]->IsClosed() )
{
this->m_ContourSeries[timestep]->Concatenate(other->m_ContourSeries[timestep]);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();
}
}
}
mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorBegin();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
}
}
mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorEnd();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
}
}
bool mitk::ContourModel::IsClosed( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsClosed();
}
return false;
}
bool mitk::ContourModel::SelectVertexAt(int index, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return (this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(index));
}
return false;
}
bool mitk::ContourModel::SelectVertexAt(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
}
return this->m_SelectedVertex != NULL;
}
bool mitk::ContourModel::RemoveVertex(VertexType* vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertex(vertex))
{
this->Modified();
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
bool mitk::ContourModel::RemoveVertexAt(int index, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertexAt(index))
{
this->Modified();
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
bool mitk::ContourModel::RemoveVertexAt(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertexAt(point, eps))
{
this->Modified();
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
void mitk::ContourModel::ShiftSelectedVertex(mitk::Vector3D &translate)
{
if(this->m_SelectedVertex)
{
this->ShiftVertex(this->m_SelectedVertex,translate);
this->Modified();
}
}
void mitk::ContourModel::ShiftContour(mitk::Vector3D &translate, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
VertexListType* vList = this->m_ContourSeries[timestep]->GetVertexList();
VertexIterator it = vList->begin();
VertexIterator end = vList->end();
//shift all vertices
while(it != end)
{
this->ShiftVertex((*it),translate);
it++;
}
this->Modified();
this->InvokeEvent( ContourModelShiftEvent() );
}
}
void mitk::ContourModel::ShiftVertex(VertexType* vertex, mitk::Vector3D &vector)
{
vertex->Coordinates[0] += vector[0];
vertex->Coordinates[1] += vector[1];
vertex->Coordinates[2] += vector[2];
}
void mitk::ContourModel::Clear(int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
//clear data at timestep
this->m_ContourSeries[timestep]->Clear();
this->InitializeEmpty();
this->Modified();
}
}
void mitk::ContourModel::Expand( int timeSteps )
{
int oldSize = this->m_ContourSeries.size();
if( timeSteps > 0 && timeSteps > oldSize )
{
Superclass::Expand(timeSteps);
//insert contours for each new timestep
for( int i = oldSize; i < timeSteps; i++)
{
m_ContourSeries.push_back(mitk::ContourElement::New());
}
this->InvokeEvent( ContourModelExpandTimeBoundsEvent() );
}
}
void mitk::ContourModel::SetRequestedRegionToLargestPossibleRegion ()
{
//no support for regions
}
bool mitk::ContourModel::RequestedRegionIsOutsideOfTheBufferedRegion ()
{
//no support for regions
return false;
}
bool mitk::ContourModel::VerifyRequestedRegion ()
{
//no support for regions
return true;
}
const mitk::Geometry3D * mitk::ContourModel::GetUpdatedGeometry (int t)
{
return Superclass::GetUpdatedGeometry(t);
}
mitk::Geometry3D* mitk::ContourModel::GetGeometry (int t)const
{
return Superclass::GetGeometry(t);
}
void mitk::ContourModel::SetRequestedRegion (itk::DataObject *data)
{
//no support for regions
}
void mitk::ContourModel::Clear()
{
//clear data and set to initial state again
this->ClearData();
this->InitializeEmpty();
this->Modified();
}
void mitk::ContourModel::ClearData()
{
//call the superclass, this releases the data of BaseData
Superclass::ClearData();
//clear out the time resolved contours
this->m_ContourSeries.clear();
}
void mitk::ContourModel::InitializeEmpty()
{
//clear data at timesteps
this->m_ContourSeries.resize(0);
this->m_ContourSeries.push_back(mitk::ContourElement::New());
//set number of timesteps to one
- this->InitializeTimeSlicedGeometry(1);
+ this->InitializeTimeGeometry(1);
m_SelectedVertex = NULL;
this->m_lineInterpolation = ContourModel::LINEAR;
}
void mitk::ContourModel::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
//update the bounds of the geometry according to the stored vertices
float mitkBounds[6];
//calculate the boundingbox at each timestep
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::PointsContainer PointsContainer;
int timesteps = this->GetTimeSteps();
//iterate over the timesteps
for(int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
{
if( dynamic_cast< mitk::PlaneGeometry* >(this->GetGeometry(currenTimeStep)) )
{
//do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
return;
}
else
{//we have a 3D geometry -> let's update bounds
//only update bounds if the contour was modified
if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
{
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
PointsContainer::Pointer points = PointsContainer::New();
VertexIterator it = this->IteratorBegin(currenTimeStep);
VertexIterator end = this->IteratorEnd(currenTimeStep);
//fill the boundingbox with the points
while(it != end)
{
Point3D currentP = (*it)->Coordinates;
BoundingBoxType::PointType p;
p.CastFrom(currentP);
points->InsertElement(points->Size(), p);
it++;
}
//construct the new boundingBox
boundingBox->SetPoints(points);
boundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
//set boundingBox at current timestep
Geometry3D* geometry3d = this->GetGeometry(currenTimeStep);
geometry3d->SetBounds(mitkBounds);
}
}
}
GetTimeGeometry()->Update();
}
void mitk::ContourModel::ExecuteOperation(mitk::Operation* operation)
{
//not supported yet
}