/*!
\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++;
}
}
mitk::DataNode::Pointer mitk::SceneReaderV1::LoadBaseDataFromDataTag( TiXmlElement* dataElement, const std::string& workingDirectory, bool& error )
{
DataNode::Pointer node;
if (dataElement)
{
const char* filename = dataElement->Attribute("file");
if ( filename )
{
try
{
std::vector<BaseData::Pointer> baseData = IOUtil::Load( workingDirectory + Poco::Path::separator() + filename );
if (baseData.size() > 1)
{
MITK_WARN << "Discarding multiple base data results from " << filename << " except the first one.";
}
node = DataNode::New();
node->SetData(baseData.front());
}
catch (std::exception& e)
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Exception says: " << e.what();
error = true;
}
if (node.IsNull())
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Factory returned NULL object.";
error = true;
}
}
}
// in case there was no <data> element we create a new empty node (for appending a propertylist later)
if (node.IsNull())
{
node = DataNode::New();
}
return node;
}
mitk::DataNode::Pointer mitk::SceneReaderV1::LoadBaseDataFromDataTag( TiXmlElement* dataElement, const std::string& workingDirectory, bool& error )
{
DataNode::Pointer node;
if (dataElement)
{
const char* filename( dataElement->Attribute("file") );
if ( filename )
{
DataNodeFactory::Pointer factory = DataNodeFactory::New();
factory->SetFileName( workingDirectory + Poco::Path::separator() + filename );
try
{
factory->Update();
node = factory->GetOutput();
}
catch (std::exception& e)
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Exception says: " << e.what();
error = true;
}
if (node.IsNull())
{
MITK_ERROR << "Error during attempt to read '" << filename << "'. Factory returned NULL object.";
error = true;
}
}
}
// in case there was no <data> element we create a new empty node (for appending a propertylist later)
if (node.IsNull())
{
node = DataNode::New();
}
return node;
}
void mitk::ClippingPlaneInteractor3D::DeselectObject(StateMachineAction*, InteractionEvent* interactionEvent)
{
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
node->SetColor( 1.0, 1.0, 1.0 );
// Colorize surface / wireframe as inactive
this->ColorizeSurface(interactionEvent->GetSender(), -1.0);
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
void mitk::ClippingPlaneInteractor3D::SelectObject(StateMachineAction*, InteractionEvent* interactionEvent)
{
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
node->SetColor(1.0, 0.0, 0.0);
// Colorize surface / wireframe dependend on distance from picked point
this->ColorizeSurface(interactionEvent->GetSender(), 0.0);
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
void mitk::AffineBaseDataInteractor3D::SelectObject(StateMachineAction*, InteractionEvent* interactionEvent)
{
DataNode::Pointer node = this->GetDataNode();
if (node.IsNull())
return;
mitk::ColorProperty::Pointer selectedColor = dynamic_cast<mitk::ColorProperty*>(node->GetProperty(selectedColorPropertyName));
if ( selectedColor.IsNotNull() )
{
node->GetPropertyList()->SetProperty("color", selectedColor);
}
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
return;
}
mitk::StdFunctionCommand::ActionFunction mitk::DisplayActionEventFunctions::SetLevelWindowAction()
{
auto actionFunction = [](const itk::EventObject& displayInteractorEvent)
{
if (DisplaySetLevelWindowEvent().CheckEvent(&displayInteractorEvent))
{
const DisplaySetLevelWindowEvent* displayActionEvent = dynamic_cast<const DisplaySetLevelWindowEvent*>(&displayInteractorEvent);
const BaseRenderer::Pointer sendingRenderer = displayActionEvent->GetSender();
if (nullptr == sendingRenderer)
{
return;
}
// get the the topmost visible image of the sending renderer
DataStorage::Pointer storage = sendingRenderer->GetDataStorage();
DataStorage::SetOfObjects::ConstPointer allImageNodes = storage->GetSubset(NodePredicateDataType::New("Image"));
Point3D worldposition;
const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(displayActionEvent->GetInteractionEvent());
sendingRenderer->DisplayToWorld(positionEvent->GetPointerPositionOnScreen(), worldposition);
auto globalCurrentTimePoint = sendingRenderer->GetTime();
DataNode::Pointer node = FindTopmostVisibleNode(allImageNodes, worldposition, globalCurrentTimePoint, sendingRenderer);
if (node.IsNull())
{
return;
}
LevelWindow levelWindow = LevelWindow();
node->GetLevelWindow(levelWindow);
ScalarType level = levelWindow.GetLevel();
ScalarType window = levelWindow.GetWindow();
level += displayActionEvent->GetLevel();
window += displayActionEvent->GetWindow();
levelWindow.SetLevelWindow(level, window);
auto* levelWindowProperty = dynamic_cast<LevelWindowProperty*>(node->GetProperty("levelwindow"));
if (nullptr != levelWindowProperty)
{
levelWindowProperty->SetLevelWindow(levelWindow);
sendingRenderer->GetRenderingManager()->RequestUpdateAll();
}
}
};
return actionFunction;
}
/*
* Checks if DataNodes associated with DataInteractors point back to them.
* If not remove the DataInteractors. (This can happen when s.o. tries to set DataNodes to multiple DataInteractors)
*/
void mitk::Dispatcher::RemoveOrphanedInteractors()
{
for (ListInteractorType::iterator it = m_Interactors.begin(); it != m_Interactors.end();)
{
DataNode::Pointer dn = (*it)->GetDataNode();
if (dn.IsNull())
{
it = m_Interactors.erase(it);
}
else
{
DataInteractor::Pointer interactor = dn->GetDataInteractor();
if (interactor != it->GetPointer())
{
it = m_Interactors.erase(it);
}
else
{
++it;
}
}
}
}
void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow* /*renWin*/)
{
if( m_DataStorage.IsNull() )
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter)
{
DataNode::Pointer node = *iter;
if ( node.IsNull() )
continue;
Mapper * mapper = node->GetMapper(m_MapperID);
if (mapper)
{
VtkMapper* vtkmapper = dynamic_cast<VtkMapper*>( mapper );
if(vtkmapper)
vtkmapper->ReleaseGraphicsResources(this);
}
}
}
void ShowSegmentationAsSmoothedSurface::ThreadedUpdateSuccessful()
{
DataNode::Pointer node = LookForPointerTargetBelowGroupNode("Surface representation");
bool addToTree = node.IsNull();
if (addToTree)
{
node = DataNode::New();
bool wireframe = false;
GetParameter("Wireframe", wireframe);
if (wireframe)
{
VtkRepresentationProperty *representation = dynamic_cast<VtkRepresentationProperty *>(
node->GetProperty("material.representation"));
if (representation != NULL)
representation->SetRepresentationToWireframe();
}
node->SetProperty("opacity", FloatProperty::New(1.0));
node->SetProperty("line width", IntProperty::New(1));
node->SetProperty("scalar visibility", BoolProperty::New(false));
UIDGenerator uidGenerator("Surface_");
node->SetProperty("FILENAME", StringProperty::New(uidGenerator.GetUID() + ".vtk"));
std::string groupNodeName = "surface";
DataNode *groupNode = GetGroupNode();
if (groupNode != NULL)
groupNode->GetName(groupNodeName);
node->SetProperty("name", StringProperty::New(groupNodeName));
}
node->SetData(m_Surface);
if (addToTree)
{
DataNode* groupNode = GetGroupNode();
if (groupNode != NULL)
{
groupNode->SetProperty("Surface representation", SmartPointerProperty::New(node));
BaseProperty *colorProperty = groupNode->GetProperty("color");
if (colorProperty != NULL)
node->ReplaceProperty("color", colorProperty);
else
node->SetProperty("color", ColorProperty::New(1.0f, 0.0f, 0.0f));
bool showResult = true;
GetParameter("Show result", showResult);
bool syncVisibility = false;
GetParameter("Sync visibility", syncVisibility);
Image::Pointer image;
GetPointerParameter("Input", image);
BaseProperty *organTypeProperty = image->GetProperty("organ type");
if (organTypeProperty != NULL)
m_Surface->SetProperty("organ type", organTypeProperty);
BaseProperty *visibleProperty = groupNode->GetProperty("visible");
if (visibleProperty != NULL && syncVisibility)
node->ReplaceProperty("visible", visibleProperty);
else
node->SetProperty("visible", BoolProperty::New(showResult));
}
InsertBelowGroupNode(node);
}
Superclass::ThreadedUpdateSuccessful();
}
mitk::DataNode *
mitk::VtkPropRenderer::PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const
{
if ( m_VtkMapperPresent )
{
m_CellPicker->InitializePickList();
// Iterate over all DataStorage objects to determine all vtkProps intended
// for picking
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
it != allObjects->End();
++it )
{
DataNode *node = it->Value();
if ( node == NULL )
continue;
bool pickable = false;
node->GetBoolProperty( "pickable", pickable );
if ( !pickable )
continue;
VtkMapper *mapper = dynamic_cast < VtkMapper * > ( node->GetMapper( m_MapperID ) );
if ( mapper == NULL )
continue;
vtkProp *prop = mapper->GetVtkProp( (mitk::BaseRenderer *)this );
if ( prop == NULL )
continue;
m_CellPicker->AddPickList( prop );
}
// Do the picking and retrieve the picked vtkProp (if any)
m_CellPicker->PickFromListOn();
m_CellPicker->Pick( displayPosition[0], displayPosition[1], 0.0, m_VtkRenderer );
m_CellPicker->PickFromListOff();
vtk2itk( m_CellPicker->GetPickPosition(), worldPosition );
vtkProp *prop = m_CellPicker->GetViewProp();
if ( prop == NULL )
{
return NULL;
}
// Iterate over all DataStorage objects to determine if the retrieved
// vtkProp is owned by any associated mapper.
for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
it != allObjects->End();
++it)
{
DataNode::Pointer node = it->Value();
if ( node.IsNull() )
continue;
mitk::Mapper * mapper = node->GetMapper( m_MapperID );
if ( mapper == NULL)
continue;
mitk::VtkMapper * vtkmapper = dynamic_cast< VtkMapper * >(mapper);
if(vtkmapper){
//if vtk-based, then ...
if ( vtkmapper->HasVtkProp( prop, const_cast< mitk::VtkPropRenderer * >( this ) ) )
{
return node;
}
}
}
return NULL;
}
else
{
return Superclass::PickObject( displayPosition, worldPosition );
}
};
