bool mitk::NavigationToolStorageSerializer::Serialize(std::string filename, mitk::NavigationToolStorage::Pointer storage)
{
//save every tool to temp directory
mitk::NavigationToolWriter::Pointer myToolWriter = mitk::NavigationToolWriter::New();
for(int i=0; i<storage->GetToolCount();i++)
{
std::string fileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
if (!myToolWriter->DoWrite(fileName,storage->GetTool(i))) return false;
}
//add all files to zip archive
std::ofstream file( filename.c_str(), std::ios::binary | std::ios::out);
if (!file.good())
{
m_ErrorMessage = "Could not open a zip file for writing: '" + filename + "'";
return false;
}
Poco::Zip::Compress zipper( file, true );
for (int i=0; i<storage->GetToolCount();i++)
{
std::string fileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
zipper.addFile(fileName,myToolWriter->GetFileWithoutPath(fileName));
//delete file:
std::remove(fileName.c_str());
}
zipper.close();
file.close();
return true;
}
bool mitk::NavigationToolWriter::DoWrite(std::string FileName,mitk::NavigationTool::Pointer Tool)
{
//convert whole data to a mitk::DataStorage
mitk::StandaloneDataStorage::Pointer saveStorage = mitk::StandaloneDataStorage::New();
mitk::DataNode::Pointer thisTool = ConvertToDataNode(Tool);
saveStorage->Add(thisTool);
//use SceneSerialization to save the DataStorage
std::string DataStorageFileName = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + Poco::Path::separator() + GetFileWithoutPath(FileName) + ".storage";
mitk::SceneIO::Pointer mySceneIO = mitk::SceneIO::New();
mySceneIO->SaveScene(saveStorage->GetAll(),saveStorage,DataStorageFileName);
//now put the DataStorage and the Toolfile in a ZIP-file
std::ofstream file( FileName.c_str(), std::ios::binary | std::ios::out);
if (!file.good())
{
m_ErrorMessage = "Could not open a zip file for writing: '" + FileName + "'";
return false;
}
else
{
Poco::Zip::Compress zipper( file, true );
zipper.addFile(DataStorageFileName,GetFileWithoutPath(DataStorageFileName));
if (Tool->GetCalibrationFile()!="none") zipper.addFile(Tool->GetCalibrationFile(),GetFileWithoutPath(Tool->GetCalibrationFile()));
zipper.close();
}
//delete the data storage
std::remove(DataStorageFileName.c_str());
return true;
}
bool SceneFileHandlerBase::write(Node * const node,
std::ostream &os,
Char8 const *fileNameOrExtension,
bool compress )
{
bool retCode = false;
SceneFileType *type = getFileType(fileNameOrExtension);
if(type != NULL)
{
updateWriteProgress(0);
SINFO << "try to write stream as " << type->getName() << std::endl;
if(_writeFP != NULL)
{
retCode = _writeFP(type, node, os, fileNameOrExtension, compress);
}
else
{
if(compress == true)
{
#ifdef OSG_WITH_ZLIB
SINFO << "writing compressed stream." << std::endl;
zip_ostream zipper(os, true);
retCode = type->write(node, zipper, fileNameOrExtension);
zipper.zflush();
#else
SFATAL << "Compressed streams are not supported! Build "
<< "with zlib= options."
<< std::endl;
#endif
}
else
{
retCode = type->write(node, os, fileNameOrExtension);
}
}
}
else
{
SWARNING << "can't write stream unknown scene format" << std::endl;
}
return retCode;
}
void Serialize<string, float>(CNcbiOstream& ostr,
const CScoreVector<string, float>& vec)
{
CZipStreamCompressor zipper(CZipCompressor::eLevel_Best,
16384, 16384,
15 /* window bits */,
9 /* memory bits */,
kZlibDefaultStrategy,
0);
CCompressionOStream zip_str(ostr, &zipper);
typedef CScoreVector<string, float> TVector;
ITERATE (TVector, iter, vec) {
unsigned len = iter->first.size();
zip_str.write((const char*)&len, sizeof(unsigned));
zip_str.write(iter->first.data(), iter->first.size());
float score = iter->second;
zip_str.write((const char*)&score, sizeof(float));
}
//----------------------------
// Function name: write
//----------------------------
//
//Parameters:
//p: const Scene &image, const char *fileName
//GlobalVars:
//g:
//Returns:
//r:bool
// Caution
//c:
//Assumations:
//a:
//Describtions:
//d:
//SeeAlso:
//s:
//
//------------------------------
bool SceneFileHandler::write(const NodePtr &node, std::ostream &os,
const Char8 *fileNameOrExtension, bool compress)
{
bool retCode = false;
SceneFileType *type = getFileType(fileNameOrExtension);
if(type)
{
updateWriteProgress(0);
SINFO << "try to write stream as " << type->getName() << std::endl;
if(_writeFP != NULL)
{
retCode = _writeFP(type, node, os, fileNameOrExtension, compress);
}
else
{
if(compress)
{
#ifdef OSG_ZSTREAM_SUPPORTED
SINFO << "writing compressed stream." << std::endl;
zip_ostream zipper(os, true);
retCode = type->write(node, zipper, fileNameOrExtension);
zipper.zflush();
#else
SFATAL << "Compressed streams are not supported! Configure with --enable-png --with-png=DIR options." << std::endl;
#endif
}
else
{
retCode = type->write(node, os, fileNameOrExtension);
}
}
}
else
SWARNING << "can't write stream unknown scene format" << std::endl;
return retCode;
}
bool mitk::NavigationToolStorageSerializer::Serialize(std::string filename, mitk::NavigationToolStorage::Pointer storage)
{
//save every tool to temp directory
mitk::NavigationToolWriter::Pointer myToolWriter = mitk::NavigationToolWriter::New();
for(int i=0; i<storage->GetToolCount();i++)
{
std::string tempFileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
if (!myToolWriter->DoWrite(tempFileName,storage->GetTool(i)))
{
mitkThrowException(mitk::IGTIOException) << "Could not write tool to tempory directory: " << tempFileName;
}
}
//add all files to zip archive
std::ofstream file( filename.c_str(), std::ios::binary | std::ios::out);
if (!file.good()) //test if the zip archive is ready for writing
{
//first: clean up
for (int i=0; i<storage->GetToolCount();i++)
{
std::string tempFileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
std::remove(tempFileName.c_str());
}
//then: throw an exception
mitkThrowException(mitk::IGTIOException) << "Could not open a file for writing: " << filename;
}
Poco::Zip::Compress zipper( file, true );
for (int i=0; i<storage->GetToolCount();i++)
{
std::string fileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
zipper.addFile(fileName,myToolWriter->GetFileWithoutPath(fileName));
std::remove(fileName.c_str()); //delete file
}
zipper.close();
file.close();
return true;
}
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;
}
}
