diff --git a/Modules/Core/include/mitkArbitraryTimeGeometry.h b/Modules/Core/include/mitkArbitraryTimeGeometry.h
index d86baa7636..6ea93073c7 100644
--- a/Modules/Core/include/mitkArbitraryTimeGeometry.h
+++ b/Modules/Core/include/mitkArbitraryTimeGeometry.h
@@ -1,244 +1,252 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef ArbitraryTimeGeometry_h
#define ArbitraryTimeGeometry_h
//MITK
#include <mitkTimeGeometry.h>
#include <mitkCommon.h>
#include <MitkCoreExports.h>
namespace mitk
{
/**
* \brief Organizes geometries over arbitrary defined time steps
*
* For this TimeGeometry implementation it is assumed that
* the durations of the time steps are arbitrary and may differ.
* The geometries of the time steps are independent,
* and not linked to each other. Since the timeBounds of the
* geometries are different for each time step it is not possible
* to set the same geometry to different time steps. Instead
* copies should be used.
* @remark The lower time bound of a succeeding time step may not be smaller
* than the upper time bound of its predecessor. Thus the list of time points is
* always sorted by its lower time bounds.
* @remark For the conversion between time step and time point the following assumption
* is used.:\n
* time step -> time point: time point is the lower time bound of the geometry indicated by step.\n
* time point -> time step: associated time step is last step which lower time bound is smaller or equal then the time
* point.
*
* \addtogroup geometry
*/
class MITKCORE_EXPORT ArbitraryTimeGeometry : public TimeGeometry
{
public:
mitkClassMacro(ArbitraryTimeGeometry, TimeGeometry);
ArbitraryTimeGeometry();
typedef ArbitraryTimeGeometry self;
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/**
* \brief Returns the number of time steps.
*
* Returns the number of time steps for which
* geometries are saved. The number of time steps
* is also the upper bound of the time steps. The
* minimum time steps is always 0.
*/
TimeStepType CountTimeSteps() const override;
/**
* \brief Returns the first time point for which the time geometry instance is valid.
*
* Returns the first valid time point for this geometry. It is the lower time bound of
* the first step. The time point is given in ms.
*/
TimePointType GetMinimumTimePoint() const override;
/**
* \brief Returns the last time point for which the time geometry instance is valid
*
* Gives the last time point for which a valid geometry is saved in
* this time geometry. It is the upper time bound of the last step.
* The time point is given in ms.
*/
TimePointType GetMaximumTimePoint() const override;
/**
* \brief Returns the first time point for which the time geometry instance is valid.
*
* Returns the first valid time point for the given TimeStep. The time point
* is given in ms.
*/
TimePointType GetMinimumTimePoint(TimeStepType step) const override;
/**
* \brief Returns the last time point for which the time geometry instance is valid
*
* Gives the last time point for the Geometry specified by the given TimeStep. The time point is given in ms.
*/
TimePointType GetMaximumTimePoint(TimeStepType step) const override;
/**
* \brief Get the time bounds (in ms)
* it returns GetMinimumTimePoint() and GetMaximumTimePoint() results as bounds.
*/
TimeBounds GetTimeBounds() const override;
/**
* \brief Get the time bounds for the given TimeStep (in ms)
*/
TimeBounds GetTimeBounds(TimeStepType step) const override;
/**
* \brief Tests if a given time point is covered by this time geometry instance
*
* Returns true if a geometry can be returned for the given time
* point (so it is within GetTimeBounds() and fails if not.
* The time point must be given in ms.
*/
bool IsValidTimePoint(TimePointType timePoint) const override;
/**
* \brief Test for the given time step if a geometry is availible
*
* Returns true if a geometry is defined for the given time step.
* Otherwise false is returned.
* The time step is defined as positiv number.
*/
bool IsValidTimeStep(TimeStepType timeStep) const override;
/**
* \brief Converts a time step to a time point
*
* Converts a time step to a time point by using the time steps lower
* time bound.
* If the original time steps does not point to a valid geometry,
* a time point is calculated that also does not point to a valid
* geometry, but no exception is raised.
*/
TimePointType TimeStepToTimePoint(TimeStepType timeStep) const override;
/**
- * \brief Converts a time point to the corresponding time step
- *
- * Converts a time point to a time step in a way that
- * the new time step indicates the same geometry as the time point.
- * The associated time step is the last step which lower time bound
- * is smaller or equal then the time point.
- * If a negative invalid time point is given always time step 0 is
- * returned. If a positive invalid time point is given the last time
- * step will be returned. This is also true for time points that are
- * exactly on the upper time bound.
- */
+ * \brief Converts a time point to the corresponding time step
+ *
+ * Converts a time point to a time step in a way that
+ * the new time step indicates the same geometry as the time point.
+ * The associated time step is the last step which lower time bound
+ * is smaller or equal then the time point.
+ * If a negative invalid time point is given always time step 0 is
+ * returned. If a positive invalid time point is given the last time
+ * step will be returned. This is also true for time points that are
+ * exactly on the upper time bound (the only exception is the final
+ * time step in case that HasCollapsedFinalTimeStep() is true).
+ */
TimeStepType TimePointToTimeStep(TimePointType timePoint) const override;
/**
* \brief Returns the geometry which corresponds to the given time step
*
* Returns a clone of the geometry which defines the given time step. If
* the given time step is invalid an null-pointer is returned.
*/
BaseGeometry::Pointer GetGeometryCloneForTimeStep(TimeStepType timeStep) const override;
/**
* \brief Returns the geometry which corresponds to the given time point
*
* Returns the geometry which defines the given time point. If
* the given time point is invalid an null-pointer is returned.
*
* If the returned geometry is changed this will affect the saved
* geometry.
*/
BaseGeometry::Pointer GetGeometryForTimePoint(TimePointType timePoint) const override;
/**
* \brief Returns the geometry which corresponds to the given time step
*
* Returns the geometry which defines the given time step. If
* the given time step is invalid an null-pointer is returned.
*
* If the returned geometry is changed this will affect the saved
* geometry.
*/
BaseGeometry::Pointer GetGeometryForTimeStep(TimeStepType timeStep) const override;
/**
* \brief Tests if all necessary informations are set and the object is valid
*/
bool IsValid() const override;
/**
* \brief Initializes a new object with one time steps which contains an empty geometry.
*/
void Initialize() override;
/**
* \brief Expands the time geometry to the given number of time steps.
*
* Initializes the new time steps with empty geometries. This default geometries will behave like
* ProportionalTimeGeometry.
* Shrinking is not supported. The new steps will have the same duration like the last step before extension.
*/
void Expand(TimeStepType size) override;
/**
* \brief Replaces the geometry instances with clones of the passed geometry.
*
* Replaces the geometries of all time steps with clones of the passed
* geometry. Replacement strategy depends on the implementation of TimeGeometry
* sub class.
* @remark The time points itself stays untouched. Use this method if you want
* to change the spatial properties of a TimeGeometry and preserve the time
* "grid".
*/
void ReplaceTimeStepGeometries(const BaseGeometry *geometry) override;
/**
* \brief Sets the geometry for the given time step
*
* If passed time step is not valid. Nothing will be changed.
* @pre geometry must point to a valid instance.
*/
void SetTimeStepGeometry(BaseGeometry *geometry, TimeStepType timeStep) override;
/**
* \brief Makes a deep copy of the current object
*/
itk::LightObject::Pointer InternalClone() const override;
void ClearAllGeometries();
/** Append the passed geometry to the time geometry.
* @pre The passed geometry pointer must be valid.
* @pre The minimumTimePoint must not be smaller than the maximum time point of the currently last time step.
* Therefore time steps must not be overlapping in time.
* @pre minimumTimePoint must not be larger then maximumTimePoint.*/
void AppendNewTimeStep(BaseGeometry *geometry, TimePointType minimumTimePoint, TimePointType maximumTimePoint);
/** Same than AppendNewTimeStep. But clones geometry before adding it.*/
void AppendNewTimeStepClone(const BaseGeometry* geometry,
TimePointType minimumTimePoint,
TimePointType maximumTimePoint );
void ReserveSpaceForGeometries( TimeStepType numberOfGeometries );
void PrintSelf(std::ostream &os, itk::Indent indent) const override;
+ /** This is a helper that indicates problematic corner cases that often occure e.g. when loading
+ dynamic DICOM data. There the final time step is collapsed as min time bound and max time bound
+ have the same value. For a more detailed explination why it happens please see:
+ https://phabricator.mitk.org/T24766#131411
+ */
+ const bool HasCollapsedFinalTimeStep() const;
+
protected:
~ArbitraryTimeGeometry() override;
std::vector<BaseGeometry::Pointer> m_GeometryVector;
std::vector<TimePointType> m_MinimumTimePoints;
std::vector<TimePointType> m_MaximumTimePoints;
}; // end class ArbitraryTimeGeometry
} // end namespace MITK
#endif // ArbitraryTimeGeometry_h
diff --git a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
index c7b740b6b6..e030ca310b 100644
--- a/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkArbitraryTimeGeometry.cpp
@@ -1,294 +1,307 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <limits>
#include <mitkArbitraryTimeGeometry.h>
#include <algorithm>
#include <mitkGeometry3D.h>
mitk::ArbitraryTimeGeometry::ArbitraryTimeGeometry() = default;
mitk::ArbitraryTimeGeometry::~ArbitraryTimeGeometry() = default;
void mitk::ArbitraryTimeGeometry::Initialize()
{
this->ClearAllGeometries();
Geometry3D::Pointer geo = Geometry3D::New();
geo->Initialize();
this->AppendNewTimeStep(geo, 0, 1);
Update();
}
mitk::TimeStepType mitk::ArbitraryTimeGeometry::CountTimeSteps() const
{
return static_cast<TimeStepType>(m_GeometryVector.size());
}
mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMinimumTimePoint() const
{
return m_MinimumTimePoints.empty() ? 0.0 : m_MinimumTimePoints.front();
}
mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMaximumTimePoint() const
{
TimePointType result = 0;
if ( !m_MaximumTimePoints.empty() )
{
result = m_MaximumTimePoints.back();
}
return result;
}
mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMinimumTimePoint( TimeStepType step ) const
{
TimePointType result = GetMinimumTimePoint();
if (step > 0 && step <= m_MaximumTimePoints.size())
{
result = m_MaximumTimePoints[step - 1];
}
return result;
};
mitk::TimePointType mitk::ArbitraryTimeGeometry::GetMaximumTimePoint( TimeStepType step ) const
{
TimePointType result = 0;
if (step < m_MaximumTimePoints.size())
{
result = m_MaximumTimePoints[step];
}
return result;
};
mitk::TimeBounds mitk::ArbitraryTimeGeometry::GetTimeBounds() const
{
TimeBounds bounds;
bounds[0] = this->GetMinimumTimePoint();
bounds[1] = this->GetMaximumTimePoint();
return bounds;
}
mitk::TimeBounds mitk::ArbitraryTimeGeometry::GetTimeBounds(TimeStepType step) const
{
TimeBounds bounds;
bounds[0] = this->GetMinimumTimePoint( step );
bounds[1] = this->GetMaximumTimePoint( step );
return bounds;
}
bool mitk::ArbitraryTimeGeometry::IsValidTimePoint(TimePointType timePoint) const
{
- return this->GetMinimumTimePoint() <= timePoint && timePoint < this->GetMaximumTimePoint();
+ return this->GetMinimumTimePoint() <= timePoint &&
+ (timePoint < this->GetMaximumTimePoint() || (this->HasCollapsedFinalTimeStep() && timePoint <= this->GetMaximumTimePoint()));
}
bool mitk::ArbitraryTimeGeometry::IsValidTimeStep(TimeStepType timeStep) const
{
return timeStep < this->CountTimeSteps();
}
mitk::TimePointType mitk::ArbitraryTimeGeometry::TimeStepToTimePoint( TimeStepType timeStep ) const
{
TimePointType result = 0.0;
if (timeStep < m_MinimumTimePoints.size() )
{
result = m_MinimumTimePoints[timeStep];
}
return result;
}
mitk::TimeStepType mitk::ArbitraryTimeGeometry::TimePointToTimeStep(TimePointType timePoint) const
{
mitk::TimeStepType result = 0;
if (timePoint >= GetMinimumTimePoint())
{
for (auto pos = m_MaximumTimePoints.cbegin(); pos != m_MaximumTimePoints.cend(); ++pos)
{
- if (timePoint < *pos)
+ if (timePoint < *pos || (pos==std::prev(m_MaximumTimePoints.cend()) && timePoint <= *pos && this->HasCollapsedFinalTimeStep()))
{
break;
}
++result;
}
}
return result;
}
mitk::BaseGeometry::Pointer mitk::ArbitraryTimeGeometry::GetGeometryForTimeStep(TimeStepType timeStep) const
{
if ( IsValidTimeStep( timeStep ) )
{
return m_GeometryVector[timeStep];
}
else
{
return nullptr;
}
}
mitk::BaseGeometry::Pointer
mitk::ArbitraryTimeGeometry::GetGeometryForTimePoint( TimePointType timePoint ) const
{
if ( this->IsValidTimePoint( timePoint ) )
{
const TimeStepType timeStep = this->TimePointToTimeStep( timePoint );
return this->GetGeometryForTimeStep( timeStep );
}
else
{
return nullptr;
}
}
mitk::BaseGeometry::Pointer
mitk::ArbitraryTimeGeometry::GetGeometryCloneForTimeStep( TimeStepType timeStep ) const
{
if ( timeStep >= m_GeometryVector.size() )
return nullptr;
return m_GeometryVector[timeStep]->Clone();
}
bool mitk::ArbitraryTimeGeometry::IsValid() const
{
bool isValid = true;
isValid &= m_GeometryVector.size() > 0;
return isValid;
}
void mitk::ArbitraryTimeGeometry::ClearAllGeometries()
{
m_GeometryVector.clear();
m_MinimumTimePoints.clear();
m_MaximumTimePoints.clear();
}
void mitk::ArbitraryTimeGeometry::ReserveSpaceForGeometries( TimeStepType numberOfGeometries )
{
m_GeometryVector.reserve( numberOfGeometries );
m_MinimumTimePoints.reserve( numberOfGeometries );
m_MaximumTimePoints.reserve( numberOfGeometries );
}
void mitk::ArbitraryTimeGeometry::Expand( mitk::TimeStepType size )
{
m_GeometryVector.reserve( size );
const mitk::TimeStepType lastIndex = this->CountTimeSteps() - 1;
const TimePointType minTP = this->GetMinimumTimePoint( lastIndex );
TimePointType maxTP = this->GetMaximumTimePoint( lastIndex );
const TimePointType duration = maxTP - minTP;
while (m_GeometryVector.size() < size)
{
m_GeometryVector.push_back( Geometry3D::New().GetPointer() );
m_MinimumTimePoints.push_back( maxTP );
maxTP += duration;
m_MaximumTimePoints.push_back( maxTP );
}
}
void mitk::ArbitraryTimeGeometry::ReplaceTimeStepGeometries(const BaseGeometry *geometry)
{
for ( auto pos = m_GeometryVector.begin(); pos != m_GeometryVector.end(); ++pos )
{
*pos = geometry->Clone();
}
}
void mitk::ArbitraryTimeGeometry::SetTimeStepGeometry(BaseGeometry *geometry, TimeStepType timeStep)
{
assert( timeStep <= m_GeometryVector.size() );
if ( timeStep == m_GeometryVector.size() )
{
m_GeometryVector.push_back( geometry );
}
m_GeometryVector[timeStep] = geometry;
}
itk::LightObject::Pointer mitk::ArbitraryTimeGeometry::InternalClone() const
{
itk::LightObject::Pointer parent = Superclass::InternalClone();
ArbitraryTimeGeometry::Pointer newTimeGeometry = dynamic_cast<ArbitraryTimeGeometry *>(parent.GetPointer());
newTimeGeometry->m_MinimumTimePoints = this->m_MinimumTimePoints;
newTimeGeometry->m_MaximumTimePoints = this->m_MaximumTimePoints;
newTimeGeometry->m_GeometryVector.clear();
for (TimeStepType i = 0; i < CountTimeSteps(); ++i)
{
newTimeGeometry->m_GeometryVector.push_back( this->m_GeometryVector[i]->Clone() );
}
return parent;
}
void mitk::ArbitraryTimeGeometry::AppendNewTimeStep(BaseGeometry *geometry,
TimePointType minimumTimePoint,
TimePointType maximumTimePoint)
{
if ( !geometry )
{
mitkThrow() << "Cannot append geometry to time geometry. Invalid geometry passed (nullptr pointer).";
}
if (maximumTimePoint < minimumTimePoint)
{
mitkThrow() << "Cannot append geometry to time geometry. Time bound conflict. Maxmimum time point ("<<maximumTimePoint<<") is smaller than minimum time point ("<<minimumTimePoint<<").";
}
if ( !m_GeometryVector.empty() )
{
if ( m_MaximumTimePoints.back() > minimumTimePoint )
{
mitkThrow() << "Cannot append geometry to time geometry. Time bound conflict new time point and currently last time point overlapp.";
}
}
m_GeometryVector.push_back( geometry );
m_MinimumTimePoints.push_back( minimumTimePoint );
m_MaximumTimePoints.push_back( maximumTimePoint );
}
void mitk::ArbitraryTimeGeometry::AppendNewTimeStepClone(const BaseGeometry *geometry,
TimePointType minimumTimePoint,
TimePointType maximumTimePoint)
{
BaseGeometry::Pointer clone = geometry->Clone();
this->AppendNewTimeStep(clone, minimumTimePoint, maximumTimePoint);
};
void mitk::ArbitraryTimeGeometry::PrintSelf(std::ostream &os, itk::Indent indent) const
{
Superclass::PrintSelf( os, indent );
os << indent << " MinimumTimePoint: " << this->GetMinimumTimePoint() << " ms" << std::endl;
os << indent << " MaximumTimePoint: " << this->GetMaximumTimePoint() << " ms" << std::endl;
os << std::endl;
os << indent << " min TimeBounds: " << std::endl;
for (TimeStepType i = 0; i < m_MinimumTimePoints.size(); ++i)
{
os << indent.GetNextIndent() << "Step " << i << ": " << m_MinimumTimePoints[i] << " ms" << std::endl;
}
os << std::endl;
os << indent << " max TimeBounds: " << std::endl;
for (TimeStepType i = 0; i < m_MaximumTimePoints.size(); ++i)
{
os << indent.GetNextIndent() << "Step " << i << ": " << m_MaximumTimePoints[i] << " ms" << std::endl;
}
}
+
+const bool mitk::ArbitraryTimeGeometry::HasCollapsedFinalTimeStep() const
+{
+ bool result = false;
+
+ if (!m_MaximumTimePoints.empty() && !m_MinimumTimePoints.empty())
+ {
+ result = m_MinimumTimePoints.back() == m_MaximumTimePoints.back();
+ }
+
+ return result;
+}
diff --git a/Modules/Core/test/mitkArbitraryTimeGeometryTest.cpp b/Modules/Core/test/mitkArbitraryTimeGeometryTest.cpp
index f25f0e4377..b05b96b04c 100644
--- a/Modules/Core/test/mitkArbitraryTimeGeometryTest.cpp
+++ b/Modules/Core/test/mitkArbitraryTimeGeometryTest.cpp
@@ -1,465 +1,504 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkArbitraryTimeGeometry.h"
#include "mitkGeometry3D.h"
#include "mitkTestFixture.h"
#include "mitkTestingMacros.h"
#include <limits>
class mitkArbitraryTimeGeometryTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkArbitraryTimeGeometryTestSuite);
// Test the append method
MITK_TEST(CountTimeSteps);
MITK_TEST(GetMinimumTimePoint);
MITK_TEST(GetMaximumTimePoint);
MITK_TEST(GetTimeBounds);
MITK_TEST(IsValidTimePoint);
MITK_TEST(TimeStepToTimePoint);
MITK_TEST(TimePointToTimeStep);
MITK_TEST(GetGeometryCloneForTimeStep);
MITK_TEST(GetGeometryForTimeStep);
MITK_TEST(GetGeometryForTimePoint);
MITK_TEST(IsValid);
MITK_TEST(Expand);
MITK_TEST(ReplaceTimeStepGeometries);
MITK_TEST(ClearAllGeometries);
MITK_TEST(AppendNewTimeStep);
+ MITK_TEST(HasCollapsedFinalTimeStep);
CPPUNIT_TEST_SUITE_END();
private:
mitk::Geometry3D::Pointer m_Geometry1;
mitk::Geometry3D::Pointer m_Geometry2;
mitk::Geometry3D::Pointer m_Geometry3;
mitk::Geometry3D::Pointer m_Geometry3_5;
mitk::Geometry3D::Pointer m_Geometry4;
mitk::Geometry3D::Pointer m_Geometry5;
mitk::Geometry3D::Pointer m_InvalidGeometry;
mitk::Geometry3D::Pointer m_NewGeometry;
mitk::TimePointType m_Geometry1MinTP;
mitk::TimePointType m_Geometry2MinTP;
mitk::TimePointType m_Geometry3MinTP;
mitk::TimePointType m_Geometry3_5MinTP;
mitk::TimePointType m_Geometry4MinTP;
mitk::TimePointType m_Geometry5MinTP;
mitk::TimePointType m_NewGeometryMinTP;
mitk::TimePointType m_Geometry1MaxTP;
mitk::TimePointType m_Geometry2MaxTP;
mitk::TimePointType m_Geometry3MaxTP;
mitk::TimePointType m_Geometry3_5MaxTP;
mitk::TimePointType m_Geometry4MaxTP;
mitk::TimePointType m_Geometry5MaxTP;
mitk::TimePointType m_NewGeometryMaxTP;
mitk::ArbitraryTimeGeometry::Pointer m_emptyTimeGeometry;
mitk::ArbitraryTimeGeometry::Pointer m_initTimeGeometry;
mitk::ArbitraryTimeGeometry::Pointer m_12345TimeGeometry;
mitk::ArbitraryTimeGeometry::Pointer m_123TimeGeometry;
+ mitk::ArbitraryTimeGeometry::Pointer m_123TimeGeometryWithCollapsedEnd;
+ mitk::ArbitraryTimeGeometry::Pointer m_123TimeGeometryWithCollapsedInterim;
public:
void setUp() override
{
mitk::TimeBounds bounds;
m_Geometry1 = mitk::Geometry3D::New();
m_Geometry2 = mitk::Geometry3D::New();
m_Geometry3 = mitk::Geometry3D::New();
m_Geometry3_5 = mitk::Geometry3D::New();
m_Geometry4 = mitk::Geometry3D::New();
m_Geometry5 = mitk::Geometry3D::New();
m_Geometry1MinTP = 1;
m_Geometry2MinTP = 2;
m_Geometry3MinTP = 3;
m_Geometry3_5MinTP = 3.5;
m_Geometry4MinTP = 4;
m_Geometry5MinTP = 5;
m_Geometry1MaxTP = 1.9;
m_Geometry2MaxTP = 2.9;
m_Geometry3MaxTP = 3.9;
m_Geometry3_5MaxTP = 3.9;
m_Geometry4MaxTP = 4.9;
m_Geometry5MaxTP = 5.9;
m_NewGeometry = mitk::Geometry3D::New();
m_NewGeometryMinTP = 20;
m_NewGeometryMaxTP = 21.9;
mitk::Point3D origin(42);
m_NewGeometry->SetOrigin(origin);
m_emptyTimeGeometry = mitk::ArbitraryTimeGeometry::New();
m_emptyTimeGeometry->ClearAllGeometries();
m_initTimeGeometry = mitk::ArbitraryTimeGeometry::New();
m_initTimeGeometry->Initialize();
m_12345TimeGeometry = mitk::ArbitraryTimeGeometry::New();
m_12345TimeGeometry->ClearAllGeometries();
m_12345TimeGeometry->AppendNewTimeStep(m_Geometry1, m_Geometry1MinTP, m_Geometry1MaxTP);
m_12345TimeGeometry->AppendNewTimeStep(m_Geometry2, m_Geometry2MinTP, m_Geometry2MaxTP);
m_12345TimeGeometry->AppendNewTimeStep(m_Geometry3, m_Geometry3MinTP, m_Geometry3MaxTP);
m_12345TimeGeometry->AppendNewTimeStep(m_Geometry4, m_Geometry4MinTP, m_Geometry4MaxTP);
m_12345TimeGeometry->AppendNewTimeStep(m_Geometry5, m_Geometry5MinTP, m_Geometry5MaxTP);
m_123TimeGeometry = mitk::ArbitraryTimeGeometry::New();
m_123TimeGeometry->ClearAllGeometries();
m_123TimeGeometry->AppendNewTimeStep(m_Geometry1, m_Geometry1MinTP, m_Geometry1MaxTP);
m_123TimeGeometry->AppendNewTimeStep(m_Geometry2, m_Geometry2MinTP, m_Geometry2MaxTP);
m_123TimeGeometry->AppendNewTimeStep(m_Geometry3, m_Geometry3MinTP, m_Geometry3MaxTP);
+
+ m_123TimeGeometryWithCollapsedEnd = mitk::ArbitraryTimeGeometry::New();
+ m_123TimeGeometryWithCollapsedEnd->ClearAllGeometries();
+ m_123TimeGeometryWithCollapsedEnd->AppendNewTimeStep(m_Geometry1, m_Geometry1MinTP, m_Geometry1MaxTP);
+ m_123TimeGeometryWithCollapsedEnd->AppendNewTimeStep(m_Geometry2, m_Geometry2MinTP, m_Geometry2MaxTP);
+ m_123TimeGeometryWithCollapsedEnd->AppendNewTimeStep(m_Geometry3, m_Geometry3MinTP, m_Geometry3MinTP);
+
+ m_123TimeGeometryWithCollapsedInterim = mitk::ArbitraryTimeGeometry::New();
+ m_123TimeGeometryWithCollapsedInterim->ClearAllGeometries();
+ m_123TimeGeometryWithCollapsedInterim->AppendNewTimeStep(m_Geometry1, m_Geometry1MinTP, m_Geometry1MaxTP);
+ m_123TimeGeometryWithCollapsedInterim->AppendNewTimeStep(m_Geometry2, m_Geometry2MinTP, m_Geometry2MinTP);
+ m_123TimeGeometryWithCollapsedInterim->AppendNewTimeStep(m_Geometry3, m_Geometry3MinTP, m_Geometry3MaxTP);
}
void tearDown() override {}
void CountTimeSteps()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->CountTimeSteps() == 0,
"Testing CountTimeSteps with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->CountTimeSteps() == 1,
"Testing CountTimeSteps with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 5,
"Testing CountTimeSteps with m_12345TimeGeometry");
}
void GetMinimumTimePoint()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMinimumTimePoint() == 0.0,
"Testing GetMinimumTimePoint with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMinimumTimePoint() == 0.0,
"Testing GetMinimumTimePoint with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMinimumTimePoint() == 1.0,
"Testing GetMinimumTimePoint with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMinimumTimePoint(2) == 0.0,
"Testing GetMinimumTimePoint(2) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMinimumTimePoint(2) == 0.0,
"Testing GetMinimumTimePoint(2) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMinimumTimePoint(2) == 2.9,
"Testing GetMinimumTimePoint(2) with m_12345TimeGeometry");
}
void GetMaximumTimePoint()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint() == 0.0,
"Testing GetMaximumTimePoint with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMaximumTimePoint() == 1.0,
"Testing GetMaximumTimePoint with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint() == 5.9,
"Testing GetMaximumTimePoint with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint(2) == 0.0,
"Testing GetMaximumTimePoint(2) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMaximumTimePoint(2) == 0.0,
"Testing GetMaximumTimePoint(2) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint(2) == 3.9,
"Testing GetMaximumTimePoint(2) with m_12345TimeGeometry");
}
void GetTimeBounds()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint(2) == 0.0,
"Testing GetMaximumTimePoint(2) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMaximumTimePoint(2) == 0.0,
"Testing GetMaximumTimePoint(2) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint(2) == 3.9,
"Testing GetMaximumTimePoint(2) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds()[0] == 0.0,
"Testing GetTimeBounds lower part with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds()[0] == 0.0,
"Testing GetTimeBounds lower part with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds()[0] == 1.0,
"Testing GetTimeBounds lower part with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds()[1] == 0.0,
"Testing GetTimeBounds with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds()[1] == 1.0,
"Testing GetTimeBounds with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds()[1] == 5.9,
"Testing GetTimeBounds with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds(3)[0] == 0.0,
"Testing GetTimeBounds(3) lower part with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds(3)[0] == 0.0,
"Testing GetTimeBounds(3) lower part with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds(3)[0] == 3.9,
"Testing GetTimeBounds(3) lower part with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds(3)[1] == 0.0,
"Testing GetTimeBounds(3) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds(3)[1] == 0.0,
"Testing GetTimeBounds(3) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds(3)[1] == 4.9,
"Testing GetTimeBounds(3) with m_12345TimeGeometry");
}
void IsValidTimePoint()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(-1) == false,
"Testing IsValidTimePoint(-1) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(-1) == false,
"Testing IsValidTimePoint(-1) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(-1) == false,
"Testing IsValidTimePoint(-1) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(0) == false,
"Testing IsValidTimePoint(0) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(0) == true,
"Testing IsValidTimePoint(0) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(0) == false,
"Testing IsValidTimePoint(0) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(1) == false,
"Testing IsValidTimePoint(1) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(1) == false,
"Testing IsValidTimePoint(1) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(1) == true,
"Testing IsValidTimePoint(1) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(2.5) == false,
"Testing IsValidTimePoint(2.5) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(2.5) == false,
"Testing IsValidTimePoint(2.5) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(2.5) == true,
"Testing IsValidTimePoint(2.5) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(5.89) == false,
"Testing IsValidTimePoint(5.89) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(5.89) == false,
"Testing IsValidTimePoint(5.89) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(5.89) == true,
"Testing IsValidTimePoint(5.89) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(10) == false,
"Testing IsValidTimePoint(10) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(10) == false,
"Testing IsValidTimePoint(10) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(10) == false,
"Testing IsValidTimePoint(10) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimeStep(0) == false,
"Testing IsValidTimeStep(0) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimeStep(0) == true,
"Testing IsValidTimeStep(0) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimeStep(0) == true,
"Testing IsValidTimeStep(0) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimeStep(1) == false,
"Testing IsValidTimeStep(1) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimeStep(1) == false,
"Testing IsValidTimeStep(1) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimeStep(1) == true,
"Testing IsValidTimeStep(1) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimeStep(6) == false,
"Testing IsValidTimeStep(6) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimeStep(6) == false,
"Testing IsValidTimeStep(6) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimeStep(6) == false,
"Testing IsValidTimeStep(6) with m_12345TimeGeometry");
+
+ //checked collapsed cases
+ MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometryWithCollapsedInterim->IsValidTimePoint(m_123TimeGeometryWithCollapsedInterim->GetMaximumTimePoint()) == false,
+ "Testing that m_123TimeGeometryWithCollapsedInterim does not inclued the max bound in validity");
+ MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometryWithCollapsedEnd->IsValidTimePoint(m_123TimeGeometryWithCollapsedEnd->GetMaximumTimePoint()) == true,
+ "Testing that m_123TimeGeometryWithCollapsedEnd does inclued the max bound in validity, because it has an collapsed final time step. (see also T27259)");
+
}
void TimeStepToTimePoint()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimeStepToTimePoint(0) == 0.0,
"Testing TimeStepToTimePoint(0) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimeStepToTimePoint(0) == 0.0,
"Testing TimeStepToTimePoint(0) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimeStepToTimePoint(0) == 1.0,
"Testing TimeStepToTimePoint(0) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimeStepToTimePoint(1) == 0.0,
"Testing TimeStepToTimePoint(1) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimeStepToTimePoint(1) == 0.0,
"Testing TimeStepToTimePoint(1) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimeStepToTimePoint(1) == 2.0,
"Testing TimeStepToTimePoint(1) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimeStepToTimePoint(6) == 0.0,
"Testing TimeStepToTimePoint(6) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimeStepToTimePoint(6) == 0.0,
"Testing TimeStepToTimePoint(6) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimeStepToTimePoint(6) == 0.0,
"Testing TimeStepToTimePoint(6) with m_12345TimeGeometry");
}
void TimePointToTimeStep()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(0.0) == 0,
"Testing TimePointToTimeStep(0.0) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(0.0) == 0,
"Testing TimePointToTimeStep(0.0) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(0.0) == 0,
"Testing TimePointToTimeStep(0.0) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(0.5) == 0,
"Testing TimePointToTimeStep(0.5) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(0.5) == 0,
"Testing TimePointToTimeStep(0.5) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(0.5) == 0,
"Testing TimePointToTimeStep(0.5) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(3.5) == 0,
"Testing TimePointToTimeStep(3.5) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(3.5) == m_initTimeGeometry->CountTimeSteps(),
"Testing TimePointToTimeStep(3.5) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(3.5) == 2,
"Testing TimePointToTimeStep(3.5) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(5.8) == 0,
"Testing TimePointToTimeStep(5.8) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(5.8) == m_initTimeGeometry->CountTimeSteps(),
"Testing TimePointToTimeStep(5.8) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(5.8) == 4,
"Testing TimePointToTimeStep(5.8) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(5.9) == m_12345TimeGeometry->CountTimeSteps(),
"Testing TimePointToTimeStep(5.9) with m_12345TimeGeometry");
+
+ //checked collapsed cases
+ MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometryWithCollapsedInterim->TimePointToTimeStep(m_123TimeGeometryWithCollapsedInterim->GetMaximumTimePoint()) == m_123TimeGeometryWithCollapsedInterim->CountTimeSteps(),
+ "Testing m_123TimeGeometryWithCollapsedInterim does not map the max time poit.");
+ MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometryWithCollapsedEnd->TimePointToTimeStep(m_123TimeGeometryWithCollapsedEnd->GetMaximumTimePoint()) == 2,
+ "Testing that m_123TimeGeometryWithCollapsedEnd does map the max bound, because it has an collapsed final time step. (see also T27259)");
+
}
void GetGeometryCloneForTimeStep()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryCloneForTimeStep(0).IsNull(),
"Testing GetGeometryCloneForTimeStep(0) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryCloneForTimeStep(0).IsNotNull(),
"Testing GetGeometryCloneForTimeStep(0) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryCloneForTimeStep(0).IsNotNull(),
"Testing GetGeometryCloneForTimeStep(0) with m_12345TimeGeometry");
}
void GetGeometryForTimeStep()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryForTimeStep(0).IsNull(),
"Testing GetGeometryForTimePoint(0) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimeStep(0).IsNotNull(),
"Testing GetGeometryForTimePoint(0) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimeStep(1).IsNull(),
"Testing GetGeometryForTimePoint(1) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(
m_12345TimeGeometry->GetGeometryForTimeStep(0).GetPointer() == m_Geometry1.GetPointer(),
"Testing GetGeometryForTimePoint(0) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(
m_12345TimeGeometry->GetGeometryForTimeStep(3).GetPointer() == m_Geometry4.GetPointer(),
"Testing GetGeometryForTimePoint(3) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(
m_12345TimeGeometry->GetGeometryForTimeStep(4).GetPointer() == m_Geometry5.GetPointer(),
"Testing GetGeometryForTimePoint(4) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryForTimeStep(5).IsNull(),
"Testing GetGeometryForTimePoint(5) with m_12345TimeGeometry");
}
void GetGeometryForTimePoint()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryForTimePoint(0).IsNull(),
"Testing GetGeometryForTimeStep(0) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimePoint(0).IsNotNull(),
"Testing GetGeometryForTimeStep(0) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryForTimePoint(0).IsNull(),
"Testing GetGeometryForTimeStep(0) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryForTimePoint(1.5).IsNull(),
"Testing GetGeometryForTimeStep(1.5) with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimePoint(1.5).IsNull(),
"Testing GetGeometryForTimeStep(1.5) with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(
m_12345TimeGeometry->GetGeometryForTimePoint(1.5).GetPointer() == m_Geometry1.GetPointer(),
"Testing GetGeometryForTimeStep(1.5) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(
m_12345TimeGeometry->GetGeometryForTimePoint(3.5).GetPointer() == m_Geometry3.GetPointer(),
"Testing GetGeometryForTimeStep(3.5) with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryForTimePoint(5.9).IsNull(),
"Testing GetGeometryForTimeStep(5.9) with m_12345TimeGeometry");
}
void IsValid()
{
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValid() == false, "Testing IsValid() with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValid() == true, "Testing IsValid() with m_initTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValid() == true, "Testing IsValid() with m_12345TimeGeometry");
}
void Expand()
{
m_12345TimeGeometry->Expand(3);
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 5,
"Testing Expand(3) doesn't change m_12345TimeGeometry");
m_12345TimeGeometry->Expand(7);
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 7,
"Testing Expand(7) with m_12345TimeGeometry");
}
void ReplaceTimeStepGeometries()
{
// Test replace time step geometries
m_12345TimeGeometry->ReplaceTimeStepGeometries(m_NewGeometry);
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 5,
"Testing ReplaceTimeStepGeometries() with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(
m_12345TimeGeometry->GetGeometryForTimeStep(0)->GetOrigin() == m_NewGeometry->GetOrigin(),
"Testing ReplaceTimeStepGeometries(): check if first geometry of m_12345TimeGeometry "
"was replaced m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(
m_12345TimeGeometry->GetGeometryForTimeStep(4)->GetOrigin() == m_NewGeometry->GetOrigin(),
"Testing ReplaceTimeStepGeometries(): check if last geometry of m_12345TimeGeometry "
"was replaced m_12345TimeGeometry");
}
void ClearAllGeometries()
{
// Test clear all geometries
m_12345TimeGeometry->ClearAllGeometries();
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 0,
"Testing ClearAllGeometries() with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMinimumTimePoint() == 0,
"Testing ClearAllGeometries() with m_12345TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint() == 0,
"Testing ClearAllGeometries() with m_12345TimeGeometry");
}
void AppendNewTimeStep()
{
// Test append
MITK_TEST_FOR_EXCEPTION(mitk::Exception, m_123TimeGeometry->AppendNewTimeStep(nullptr, 0, 1));
MITK_TEST_FOR_EXCEPTION(mitk::Exception, m_123TimeGeometry->AppendNewTimeStep(m_Geometry3_5,m_Geometry3_5MinTP,m_Geometry3_5MaxTP));
MITK_TEST_FOR_EXCEPTION(mitk::Exception, m_123TimeGeometry->AppendNewTimeStep(m_Geometry4, m_Geometry4MaxTP, m_Geometry4MinTP)); //valid but inverted bounds
m_emptyTimeGeometry->AppendNewTimeStep(m_Geometry4, m_Geometry4MinTP, m_Geometry4MaxTP);
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->CountTimeSteps() == 1,
"Testing AppendNewTimeStep() with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMinimumTimePoint() == 4,
"Testing ClearAllGeometries() with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint() == 4.9,
"Testing ClearAllGeometries() with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->CountTimeSteps() == 3,
"Testing AppendNewTimeStep() with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMinimumTimePoint() == 1,
"Testing ClearAllGeometries() with m_emptyTimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMaximumTimePoint() == 3.9,
"Testing ClearAllGeometries() with m_emptyTimeGeometry");
m_123TimeGeometry->AppendNewTimeStep(m_Geometry4, m_Geometry4MinTP, m_Geometry4MaxTP);
MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->CountTimeSteps() == 4,
"Testing AppendNewTimeStep() with m_123TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMinimumTimePoint() == 1,
"Testing AppendNewTimeStep() with m_123TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMaximumTimePoint() == 4.9,
"Testing AppendNewTimeStep() with m_123TimeGeometry");
MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMinimumTimePoint(3) == 3.9,
"Testing AppendNewTimeStep() with m_123TimeGeometry");
}
+
+ void HasCollapsedFinalTimeStep()
+ {
+ MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->HasCollapsedFinalTimeStep() == false, "Testing HasCollapsedFinalTimeStep() with m_emptyTimeGeometry");
+ MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->HasCollapsedFinalTimeStep() == false, "Testing HasCollapsedFinalTimeStep() with m_initTimeGeometry");
+ MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->HasCollapsedFinalTimeStep() == false, "Testing HasCollapsedFinalTimeStep() with m_12345TimeGeometry");
+ MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometryWithCollapsedEnd->HasCollapsedFinalTimeStep() == true, "Testing HasCollapsedFinalTimeStep() with m_123TimeGeometryWithCollapsedEnd");
+ MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometryWithCollapsedInterim->HasCollapsedFinalTimeStep() == false, "Testing HasCollapsedFinalTimeStep() with m_123TimeGeometryWithCollapsedInterim");
+ }
+
};
MITK_TEST_SUITE_REGISTRATION(mitkArbitraryTimeGeometry)