/*!
\brief PrepareMapperQueue iterates the datatree
PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers
wrt to their layer.
*/
void mitk::VtkPropRenderer::PrepareMapperQueue()
{
// variable for counting LOD-enabled mappers
m_NumberOfVisibleLODEnabledMappers = 0;
// Do we have to update the mappers ?
if (m_LastUpdateTime < GetMTime() || m_LastUpdateTime < this->GetCurrentWorldPlaneGeometry()->GetMTime())
{
Update();
}
else if (m_MapperID >= 1 && m_MapperID < 6)
Update();
// remove all text properties before mappers will add new ones
m_TextRenderer->RemoveAllViewProps();
for (unsigned int i = 0; i < m_TextCollection.size(); i++)
{
m_TextCollection[i]->Delete();
}
m_TextCollection.clear();
// clear priority_queue
m_MappersMap.clear();
int mapperNo = 0;
// DataStorage
if (m_DataStorage.IsNull())
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it)
{
const DataNode::Pointer node = it->Value();
if (node.IsNull())
continue;
const mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
if (mapper.IsNull())
continue;
bool visible = true;
node->GetVisibility(visible, this, "visible");
// The information about LOD-enabled mappers is required by RenderingManager
if (mapper->IsLODEnabled(this) && visible)
{
++m_NumberOfVisibleLODEnabledMappers;
}
// mapper without a layer property get layer number 1
int layer = 1;
node->GetIntProperty("layer", layer, this);
int nr = (layer << 16) + mapperNo;
m_MappersMap.insert(std::pair<int, Mapper *>(nr, mapper));
mapperNo++;
}
}
void mitk::VtkPropRenderer::Update()
{
if (m_DataStorage.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
Update(it->Value());
Modified();
m_LastUpdateTime = GetMTime();
}
void mitk::ExtrudedContour::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if(GetMTime() > m_LastCalculateExtrusionTime)
{
BuildGeometry();
BuildSurface();
}
//if ( ( m_CalculateBoundingBox ) && ( m_PolyDataSeries.size() > 0 ) )
// CalculateBoundingBox();
}
void mitk::Mapper::Update(mitk::BaseRenderer *renderer)
{
const DataNode* node = GetDataNode();
assert(node!=NULL);
//safety cause there are datatreenodes that have no defined data (video-nodes and root)
unsigned int dataMTime = 0;
mitk::BaseData::Pointer data = static_cast<mitk::BaseData *>(node->GetData());
if (data.IsNotNull())
{
dataMTime = data->GetMTime();
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
// Check if time step is valid
const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
if ( ( dataTimeGeometry == NULL )
|| ( dataTimeGeometry->GetTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTime( m_TimeStep ) ) )
{
// TimeSlicedGeometry or time step is not valid for this data:
// reset mapper so that nothing is displayed
this->ResetMapper( renderer );
return;
}
if(
(m_LastUpdateTime < GetMTime()) ||
(m_LastUpdateTime < node->GetDataReferenceChangedTime()) ||
(m_LastUpdateTime < dataMTime) ||
(renderer && (m_LastUpdateTime < renderer->GetTimeStepUpdateTime()))
)
{
this->GenerateData();
m_LastUpdateTime.Modified();
}
this->GenerateDataForRenderer(renderer);
}
void mitk::VtkPropRenderer::UpdatePaths()
{
if (m_DataStorage.IsNull())
{
return;
}
if (GetMTime() > m_PathTime || (m_Paths != nullptr && m_Paths->GetMTime() > m_PathTime))
{
// Create the list to hold all the paths
m_Paths = vtkSmartPointer<vtkAssemblyPaths>::New();
DataStorage::SetOfObjects::ConstPointer objects = m_DataStorage->GetAll();
for (auto iter = objects->begin(); iter != objects->end(); ++iter)
{
vtkSmartPointer<vtkAssemblyPath> onePath = vtkSmartPointer<vtkAssemblyPath>::New();
Mapper *mapper = (*iter)->GetMapper(BaseRenderer::Standard3D);
if (mapper)
{
auto *vtkmapper = dynamic_cast<VtkMapper *>(mapper);
if (nullptr != vtkmapper)
{
vtkProp *prop = vtkmapper->GetVtkProp(this);
if (prop && prop->GetVisibility())
{
// add to assembly path
onePath->AddNode(prop, prop->GetMatrix());
m_Paths->AddItem(onePath);
}
}
}
}
m_PathTime.Modified();
}
}
void SliceNavigationController::Update(SliceNavigationController::ViewDirection viewDirection,
bool top,
bool frontside,
bool rotated)
{
TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
if (m_BlockUpdate || (m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull()) ||
((worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0)))
{
return;
}
m_BlockUpdate = true;
if (m_InputWorldTimeGeometry.IsNotNull() && m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime())
{
Modified();
}
if (m_InputWorldGeometry3D.IsNotNull() && m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime())
{
Modified();
}
this->SetViewDirection(viewDirection);
this->SetTop(top);
this->SetFrontSide(frontside);
this->SetRotated(rotated);
if (m_LastUpdateTime < GetMTime())
{
m_LastUpdateTime = GetMTime();
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry = SlicedGeometry3D::Pointer();
BaseGeometry::ConstPointer currentGeometry = BaseGeometry::ConstPointer();
if (m_InputWorldTimeGeometry.IsNotNull())
if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
else
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
else
currentGeometry = m_InputWorldGeometry3D;
m_CreatedWorldGeometry = mitk::TimeGeometry::Pointer();
switch (viewDirection)
{
case Original:
if (worldTimeGeometry.IsNotNull())
{
m_CreatedWorldGeometry = worldTimeGeometry->Clone();
worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
if (slicedWorldGeometry.IsNotNull())
{
break;
}
}
else
{
const SlicedGeometry3D *worldSlicedGeometry =
dynamic_cast<const SlicedGeometry3D *>(currentGeometry.GetPointer());
if ( worldSlicedGeometry != nullptr )
{
slicedWorldGeometry = static_cast<SlicedGeometry3D *>(currentGeometry->Clone().GetPointer());
break;
}
}
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::None, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Axial:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Axial, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Frontal, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Sagittal, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
default:
itkExceptionMacro("unknown ViewDirection");
}
m_Slice->SetPos(0);
m_Slice->SetSteps((int)slicedWorldGeometry->GetSlices());
if ( worldTimeGeometry.IsNull() )
{
auto createdTimeGeometry = ProportionalTimeGeometry::New();
createdTimeGeometry->Initialize( slicedWorldGeometry, 1 );
m_CreatedWorldGeometry = createdTimeGeometry;
m_Time->SetSteps(0);
m_Time->SetPos(0);
m_Time->InvalidateRange();
}
else
{
m_BlockUpdate = true;
m_Time->SetSteps(worldTimeGeometry->CountTimeSteps());
m_Time->SetPos(0);
const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
m_Time->SetRange(timeBounds[0], timeBounds[1]);
m_BlockUpdate = false;
const auto currentTemporalPosition = this->GetTime()->GetPos();
assert( worldTimeGeometry->GetGeometryForTimeStep( currentTemporalPosition ).IsNotNull() );
if ( dynamic_cast<const mitk::ProportionalTimeGeometry*>( worldTimeGeometry.GetPointer() ) != nullptr )
{
const TimePointType minimumTimePoint =
worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition );
const TimePointType stepDuration =
worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition + 1 ) - minimumTimePoint;
auto createdTimeGeometry = ProportionalTimeGeometry::New();
createdTimeGeometry->Initialize( slicedWorldGeometry, worldTimeGeometry->CountTimeSteps() );
createdTimeGeometry->SetFirstTimePoint( minimumTimePoint );
createdTimeGeometry->SetStepDuration( stepDuration );
m_CreatedWorldGeometry = createdTimeGeometry;
}
else
{
auto createdTimeGeometry = mitk::ArbitraryTimeGeometry::New();
const TimeStepType numberOfTimeSteps = worldTimeGeometry->CountTimeSteps();
createdTimeGeometry->ReserveSpaceForGeometries( numberOfTimeSteps );
for ( TimeStepType i = 0; i < numberOfTimeSteps; ++i )
{
const BaseGeometry::Pointer clonedGeometry = slicedWorldGeometry->Clone().GetPointer();
const auto bounds = worldTimeGeometry->GetTimeBounds( i );
createdTimeGeometry->AppendNewTimeStep( clonedGeometry,
bounds[0], bounds[1]);
}
createdTimeGeometry->Update();
m_CreatedWorldGeometry = createdTimeGeometry;
}
}
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}
TEST(MinidumpCallbackTest, GetMTimeTest) {
time_t mytime;
EXPECT_TRUE(GetMTime("./minidump_callback_unittest.cpp", &mytime));
}
void
SliceNavigationController::Update(
SliceNavigationController::ViewDirection viewDirection,
bool top, bool frontside, bool rotated )
{
const TimeSlicedGeometry* worldTimeSlicedGeometry =
dynamic_cast< const TimeSlicedGeometry * >(
m_InputWorldGeometry.GetPointer() );
if( m_BlockUpdate ||
m_InputWorldGeometry.IsNull() ||
( (worldTimeSlicedGeometry != NULL) && (worldTimeSlicedGeometry->GetTimeSteps() == 0) )
)
{
return;
}
m_BlockUpdate = true;
if ( m_LastUpdateTime < m_InputWorldGeometry->GetMTime() )
{
Modified();
}
this->SetViewDirection( viewDirection );
this->SetTop( top );
this->SetFrontSide( frontside );
this->SetRotated( rotated );
if ( m_LastUpdateTime < GetMTime() )
{
m_LastUpdateTime = GetMTime();
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry = NULL;
m_CreatedWorldGeometry = NULL;
switch ( viewDirection )
{
case Original:
if ( worldTimeSlicedGeometry != NULL )
{
m_CreatedWorldGeometry = static_cast< TimeSlicedGeometry * >(
m_InputWorldGeometry->Clone().GetPointer() );
worldTimeSlicedGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometry3D( this->GetTime()->GetPos() ) );
if ( slicedWorldGeometry.IsNotNull() )
{
break;
}
}
else
{
const SlicedGeometry3D *worldSlicedGeometry =
dynamic_cast< const SlicedGeometry3D * >(
m_InputWorldGeometry.GetPointer());
if ( worldSlicedGeometry != NULL )
{
slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
m_InputWorldGeometry->Clone().GetPointer());
break;
}
}
//else: use Transversal: no "break" here!!
case Transversal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(
m_InputWorldGeometry, PlaneGeometry::Transversal,
top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
PlaneGeometry::Frontal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
PlaneGeometry::Sagittal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
default:
itkExceptionMacro("unknown ViewDirection");
}
m_Slice->SetPos( 0 );
m_Slice->SetSteps( (int)slicedWorldGeometry->GetSlices() );
if ( m_CreatedWorldGeometry.IsNull() )
{
// initialize TimeSlicedGeometry
m_CreatedWorldGeometry = TimeSlicedGeometry::New();
}
if ( worldTimeSlicedGeometry == NULL )
{
m_CreatedWorldGeometry->InitializeEvenlyTimed( slicedWorldGeometry, 1 );
m_Time->SetSteps( 0 );
m_Time->SetPos( 0 );
m_Time->InvalidateRange();
}
else
{
m_BlockUpdate = true;
m_Time->SetSteps( worldTimeSlicedGeometry->GetTimeSteps() );
m_Time->SetPos( 0 );
const TimeBounds &timeBounds = worldTimeSlicedGeometry->GetTimeBounds();
m_Time->SetRange( timeBounds[0], timeBounds[1] );
m_BlockUpdate = false;
assert( worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() ) != NULL );
slicedWorldGeometry->SetTimeBounds(
worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() )->GetTimeBounds() );
//@todo implement for non-evenly-timed geometry!
m_CreatedWorldGeometry->InitializeEvenlyTimed(
slicedWorldGeometry, worldTimeSlicedGeometry->GetTimeSteps() );
}
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}