mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllImagesOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion) const
{
if (m_DataStorage.IsExpired())
{
mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
}
DataNodeVector allImagesOfLesion;
// 1. get all segmentations that define the lesion
// 2. retrieve the parent node (source) of the found segmentation node
DataNodeVector allSegmentationsOfLesion = GetAllSegmentationsOfLesion(caseID, lesion);
for (const auto& segmentationNode : allSegmentationsOfLesion)
{
// get parent node of the current segmentation node with the node predicate
DataStorage::SetOfObjects::ConstPointer parentNodes = m_DataStorage.Lock()->GetSources(segmentationNode, NodePredicates::GetImagePredicate(), false);
for (auto it = parentNodes->Begin(); it != parentNodes->End(); ++it)
{
DataNode::Pointer dataNode = it->Value();
allImagesOfLesion.push_back(it->Value());
}
}
std::sort(allImagesOfLesion.begin(), allImagesOfLesion.end());
allImagesOfLesion.erase(std::unique(allImagesOfLesion.begin(), allImagesOfLesion.end()), allImagesOfLesion.end());
return allImagesOfLesion;
}
/*!
\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++;
}
}
bool mitk::PersistenceService::RestorePropertyListsFromPersistentDataNodes( const DataStorage* storage )
{
this->Initialize();
bool oneFound = false;
DataStorage::SetOfObjects::ConstPointer allNodes = storage->GetAll();
for ( mitk::DataStorage::SetOfObjects::const_iterator sourceIter = allNodes->begin();
sourceIter != allNodes->end();
++sourceIter )
{
mitk::DataNode* node = *sourceIter;
bool isPersistenceNode = false;
//node->GetBoolProperty( PERSISTENCE_PROPERTY_NAME.c_str(), isPersistenceNode ); //see bug 17729
node->GetBoolProperty( GetPersistencePropertyName().c_str(), isPersistenceNode );
if( isPersistenceNode )
{
oneFound = true;
MITK_DEBUG("mitk::PersistenceService") << "isPersistenceNode was true";
std::string name = node->GetName();
bool existed = false;
mitk::PropertyList::Pointer propList = this->GetPropertyList( name, &existed );
if( existed )
{
MITK_DEBUG("mitk::PersistenceService") << "calling replace observer before replacing values";
std::set<PropertyListReplacedObserver*>::iterator it = m_PropertyListReplacedObserver.begin();
while( it != m_PropertyListReplacedObserver.end() )
{
(*it)->BeforePropertyListReplaced( name, propList );
++it;
}
} // if( existed )
MITK_DEBUG("mitk::PersistenceService") << "replacing values";
this->ClonePropertyList( node->GetPropertyList(), propList );
if( existed )
{
MITK_DEBUG("mitk::PersistenceService") << "calling replace observer before replacing values";
std::set<PropertyListReplacedObserver*>::iterator it = m_PropertyListReplacedObserver.begin();
while( it != m_PropertyListReplacedObserver.end() )
{
(*it)->AfterPropertyListReplaced( name, propList );
++it;
}
} // if( existed )
} // if( isPersistenceNode )
} // for ( mitk::DataStorage::SetOfObjects::const_iterator sourceIter = allNodes->begin(); ...
return oneFound;
}
mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSpecificSegmentations(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::InformationType& informationType) const
{
if (m_DataStorage.IsExpired())
{
mitkThrow() << "Not a valid data storage.";
}
DataNodeVector allSpecificImages = GetAllSpecificImages(caseID, controlPoint, informationType);
DataNodeVector allSpecificSegmentations;
for (const auto& imageNode : allSpecificImages)
{
DataStorage::SetOfObjects::ConstPointer segmentationNodes = m_DataStorage.Lock()->GetDerivations(imageNode, NodePredicates::GetSegmentationPredicate(), false);
for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
{
allSpecificSegmentations.push_back(it->Value());
}
}
return allSpecificSegmentations;
}
mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSegmentationsOfCase(const SemanticTypes::CaseID& caseID) const
{
if (m_DataStorage.IsExpired())
{
mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
}
std::vector<std::string> allSegmentationIDsOfCase = RelationStorage::GetAllSegmentationIDsOfCase(caseID);
std::vector<DataNode::Pointer> allSegmentationsOfCase;
// get all segmentation nodes of the current data storage
// only those nodes are respected, that are currently held in the data storage
DataStorage::SetOfObjects::ConstPointer segmentationNodes = m_DataStorage.Lock()->GetSubset(NodePredicates::GetSegmentationPredicate());
for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
{
DataNode* segmentationNode = it->Value();
std::string caseID;
std::string segmentationID;
try
{
// find the corresponding segmentation node for the given segmentation ID
caseID = GetCaseIDFromDataNode(segmentationNode);
segmentationID = GetIDFromDataNode(segmentationNode);
}
catch (SemanticRelationException&)
{
// found a segmentation node that is not stored in the semantic relations
// this segmentation node does not have any DICOM information --> exception thrown
// continue with the next segmentation to compare IDs
continue;
}
if (caseID == caseID && (std::find(allSegmentationIDsOfCase.begin(), allSegmentationIDsOfCase.end(), segmentationID) != allSegmentationIDsOfCase.end()))
{
// found current image node in the storage, add it to the return vector
allSegmentationsOfCase.push_back(segmentationNode);
}
}
return allSegmentationsOfCase;
}
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 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();
}
}
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 );
}
};
bool mitk::SceneIO::SaveScene( DataStorage::SetOfObjects::ConstPointer sceneNodes, const DataStorage* storage,
const std::string& filename)
{
if (!sceneNodes)
{
MITK_ERROR << "No set of nodes given. Not possible to save scene.";
return false;
}
if (!storage)
{
MITK_ERROR << "No data storage given. Not possible to save scene."; // \TODO: Technically, it would be possible to save the nodes without their relation
return false;
}
if ( filename.empty() )
{
MITK_ERROR << "No filename given. Not possible to save scene.";
return false;
}
try
{
m_FailedNodes = DataStorage::SetOfObjects::New();
m_FailedProperties = PropertyList::New();
// start XML DOM
TiXmlDocument document;
TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "UTF-8", "" ); // TODO what to write here? encoding? standalone would mean that we provide a DTD somewhere...
document.LinkEndChild( decl );
TiXmlElement* version = new TiXmlElement("Version");
version->SetAttribute("Writer", __FILE__ );
version->SetAttribute("Revision", "$Revision: 17055 $" );
version->SetAttribute("FileVersion", 1 );
document.LinkEndChild(version);
//DataStorage::SetOfObjects::ConstPointer sceneNodes = storage->GetSubset( predicate );
if ( sceneNodes.IsNull() )
{
MITK_WARN << "Saving empty scene to " << filename;
}
else
{
if ( sceneNodes->size() == 0 )
{
MITK_WARN << "Saving empty scene to " << filename;
}
MITK_INFO << "Storing scene with " << sceneNodes->size() << " objects to " << filename;
m_WorkingDirectory = CreateEmptyTempDirectory();
if (m_WorkingDirectory.empty())
{
MITK_ERROR << "Could not create temporary directory. Cannot create scene files.";
return false;
}
ProgressBar::GetInstance()->AddStepsToDo( sceneNodes->size() );
// find out about dependencies
typedef std::map< DataNode*, std::string > UIDMapType;
typedef std::map< DataNode*, std::list<std::string> > SourcesMapType;
UIDMapType nodeUIDs; // for dependencies: ID of each node
SourcesMapType sourceUIDs; // for dependencies: IDs of a node's parent nodes
UIDGenerator nodeUIDGen("OBJECT_");
for (DataStorage::SetOfObjects::const_iterator iter = sceneNodes->begin();
iter != sceneNodes->end();
++iter)
{
DataNode* node = iter->GetPointer();
if (!node)
continue; // unlikely event that we get a NULL pointer as an object for saving. just ignore
// generate UIDs for all source objects
DataStorage::SetOfObjects::ConstPointer sourceObjects = storage->GetSources( node );
for ( mitk::DataStorage::SetOfObjects::const_iterator sourceIter = sourceObjects->begin();
sourceIter != sourceObjects->end();
++sourceIter )
{
if ( std::find( sceneNodes->begin(), sceneNodes->end(), *sourceIter ) == sceneNodes->end() )
continue; // source is not saved, so don't generate a UID for this source
// create a uid for the parent object
if ( nodeUIDs[ *sourceIter ].empty() )
{
nodeUIDs[ *sourceIter ] = nodeUIDGen.GetUID();
}
// store this dependency for writing
sourceUIDs[ node ].push_back( nodeUIDs[*sourceIter] );
}
if ( nodeUIDs[ node ].empty() )
{
nodeUIDs[ node ] = nodeUIDGen.GetUID();
}
}
// write out objects, dependencies and properties
for (DataStorage::SetOfObjects::const_iterator iter = sceneNodes->begin();
iter != sceneNodes->end();
++iter)
{
DataNode* node = iter->GetPointer();
if (node)
{
TiXmlElement* nodeElement = new TiXmlElement("node");
std::string filenameHint( node->GetName() );
filenameHint = itksys::SystemTools::MakeCindentifier(filenameHint.c_str()); // escape filename <-- only allow [A-Za-z0-9_], replace everything else with _
// store dependencies
UIDMapType::iterator searchUIDIter = nodeUIDs.find(node);
if ( searchUIDIter != nodeUIDs.end() )
{
// store this node's ID
nodeElement->SetAttribute("UID", searchUIDIter->second.c_str() );
}
SourcesMapType::iterator searchSourcesIter = sourceUIDs.find(node);
if ( searchSourcesIter != sourceUIDs.end() )
{
// store all source IDs
for ( std::list<std::string>::iterator sourceUIDIter = searchSourcesIter->second.begin();
sourceUIDIter != searchSourcesIter->second.end();
++sourceUIDIter )
{
TiXmlElement* uidElement = new TiXmlElement("source");
uidElement->SetAttribute("UID", sourceUIDIter->c_str() );
nodeElement->LinkEndChild( uidElement );
}
}
// store basedata
if ( BaseData* data = node->GetData() )
{
//std::string filenameHint( node->GetName() );
bool error(false);
TiXmlElement* dataElement( SaveBaseData( data, filenameHint, error ) ); // returns a reference to a file
if (error)
{
m_FailedNodes->push_back( node );
}
// store basedata properties
PropertyList* propertyList = data->GetPropertyList();
if (propertyList && !propertyList->IsEmpty() )
{
TiXmlElement* baseDataPropertiesElement( SavePropertyList( propertyList, filenameHint + "-data") ); // returns a reference to a file
dataElement->LinkEndChild( baseDataPropertiesElement );
}
nodeElement->LinkEndChild( dataElement );
}
// store all renderwindow specific propertylists
const RenderingManager::RenderWindowVector& allRenderWindows( RenderingManager::GetInstance()->GetAllRegisteredRenderWindows() );
for ( RenderingManager::RenderWindowVector::const_iterator rw = allRenderWindows.begin();
rw != allRenderWindows.end();
++rw)
{
if (vtkRenderWindow* renderWindow = *rw)
{
std::string renderWindowName( mitk::BaseRenderer::GetInstance(renderWindow)->GetName() );
BaseRenderer* renderer = mitk::BaseRenderer::GetInstance(renderWindow);
PropertyList* propertyList = node->GetPropertyList(renderer);
if ( propertyList && !propertyList->IsEmpty() )
{
TiXmlElement* renderWindowPropertiesElement( SavePropertyList( propertyList, filenameHint + "-" + renderWindowName) ); // returns a reference to a file
renderWindowPropertiesElement->SetAttribute("renderwindow", renderWindowName);
nodeElement->LinkEndChild( renderWindowPropertiesElement );
}
}
}
// don't forget the renderwindow independent list
PropertyList* propertyList = node->GetPropertyList();
if ( propertyList && !propertyList->IsEmpty() )
{
TiXmlElement* propertiesElement( SavePropertyList( propertyList, filenameHint + "-node") ); // returns a reference to a file
nodeElement->LinkEndChild( propertiesElement );
}
document.LinkEndChild( nodeElement );
}
else
{
MITK_WARN << "Ignoring NULL node during scene serialization.";
}
ProgressBar::GetInstance()->Progress();
} // end for all nodes
} // end if sceneNodes
if ( !document.SaveFile( m_WorkingDirectory + Poco::Path::separator() + "index.xml" ) )
{
MITK_ERROR << "Could not write scene to " << m_WorkingDirectory << Poco::Path::separator() << "index.xml" << "\nTinyXML reports '" << document.ErrorDesc() << "'";
return false;
}
else
{
try
{
Poco::File deleteFile( filename.c_str() );
if (deleteFile.exists())
{
deleteFile.remove();
}
// create zip at filename
std::ofstream file( filename.c_str(), std::ios::binary | std::ios::out);
if (!file.good())
{
MITK_ERROR << "Could not open a zip file for writing: '" << filename << "'";
}
else
{
Poco::Zip::Compress zipper( file, true );
Poco::Path tmpdir( m_WorkingDirectory );
zipper.addRecursive( tmpdir );
zipper.close();
}
try
{
Poco::File deleteDir( m_WorkingDirectory );
deleteDir.remove(true); // recursive
}
catch(...)
{
MITK_ERROR << "Could not delete temporary directory " << m_WorkingDirectory;
return false; // ok?
}
}
catch(std::exception& e)
{
MITK_ERROR << "Could not create ZIP file from " << m_WorkingDirectory << "\nReason: " << e.what();
return false;
}
return true;
}
}
catch(std::exception& e)
{
MITK_ERROR << "Caught exception during saving temporary files to disk. Error description: '" << e.what() << "'";
return false;
}
}
