TiXmlElement* mitk::PlanarFigureWriter::CreateXMLVectorElement(const char* name, itk::FixedArray<mitk::ScalarType, 3> v)
{
auto vElement = new TiXmlElement(name);
vElement->SetDoubleAttribute("x", v.GetElement(0));
vElement->SetDoubleAttribute("y", v.GetElement(1));
vElement->SetDoubleAttribute("z", v.GetElement(2));
return vElement;
}
TiXmlElement *PowerLawWidgetManager::serializeToXml() {
auto root = new TiXmlElement("PowerLaws");
for (auto &widget : m_Widgets) {
auto params = widget->getPowerLawParameters();
auto law = new TiXmlElement("PowerLawParameters");
law->SetDoubleAttribute("factor", params.factor);
law->SetDoubleAttribute("exponent", params.exponent);
law->SetDoubleAttribute("offset", params.offset);
law->SetDoubleAttribute("rangeMin", widget->getMin());
law->SetDoubleAttribute("rangeMax", widget->getMax());
root->LinkEndChild(law);
}
return root;
}
void mitk::NavigationDataRecorderDeprecated::Update()
{
if (m_Recording)
{
DataObjectPointerArray inputs = this->GetInputs(); //get all inputs
mitk::NavigationData::TimeStampType timestamp=0.0; // timestamp for mitk time
timestamp = mitk::IGTTimeStamp::GetInstance()->GetElapsed();
mitk::NavigationData::TimeStampType sysTimestamp = 0.0; // timestamp for system time
sysTimestamp = m_SystemTimeClock->GetCurrentStamp();
// cast system time double value to stringstream to avoid low precision rounding
std::ostringstream strs;
strs.precision(15); // rounding precision for system time double value
strs << sysTimestamp;
std::string sysTimeStr = strs.str();
//if csv-mode: write csv header and timestamp at beginning
if (m_OutputFormat == mitk::NavigationDataRecorderDeprecated::csv)
{
//write header only when it's the first line
if (m_firstLine)
{
m_firstLine = false;
*m_Stream << "TimeStamp";
for (unsigned int index = 0; index < inputs.size(); index++) {
*m_Stream << ";Valid_Tool" << index <<
";X_Tool" << index <<
";Y_Tool" << index <<
";Z_Tool" << index <<
";QX_Tool" << index <<
";QY_Tool" << index <<
";QZ_Tool" << index <<
";QR_Tool" << index;
}
*m_Stream << "\n";
}
//write timestamp (always)
*m_Stream << timestamp;
}
//write tool data for every tool
for (unsigned int index = 0; index < inputs.size(); index++)
{
mitk::NavigationData* nd = dynamic_cast<mitk::NavigationData*>(inputs[index].GetPointer());
nd->Update(); // call update to propagate update to previous filters
mitk::NavigationData::PositionType position;
mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
mitk::NavigationData::CovarianceMatrixType matrix;
bool hasPosition = true;
bool hasOrientation = true;
bool dataValid = false;
position.Fill(0.0);
matrix.SetIdentity();
position = nd->GetPosition();
orientation = nd->GetOrientation();
matrix = nd->GetCovErrorMatrix();
hasPosition = nd->GetHasPosition();
hasOrientation = nd->GetHasOrientation();
dataValid = nd->IsDataValid();
//use this one if you want the timestamps of the source
//timestamp = nd->GetIGTTimeStamp();
//a timestamp is never < 0! this case happens only if you are using the timestamp of the nd object instead of getting a new one
if (timestamp >= 0)
{
if (this->m_OutputFormat == mitk::NavigationDataRecorderDeprecated::xml)
{
auto elem = new TiXmlElement("NavigationData");
elem->SetDoubleAttribute("Time", timestamp);
elem->SetAttribute("SystemTime", sysTimeStr); // tag for system time
elem->SetDoubleAttribute("Tool", index);
elem->SetDoubleAttribute("X", position[0]);
elem->SetDoubleAttribute("Y", position[1]);
elem->SetDoubleAttribute("Z", position[2]);
elem->SetDoubleAttribute("QX", orientation[0]);
elem->SetDoubleAttribute("QY", orientation[1]);
elem->SetDoubleAttribute("QZ", orientation[2]);
elem->SetDoubleAttribute("QR", orientation[3]);
elem->SetDoubleAttribute("C00", matrix[0][0]);
elem->SetDoubleAttribute("C01", matrix[0][1]);
elem->SetDoubleAttribute("C02", matrix[0][2]);
elem->SetDoubleAttribute("C03", matrix[0][3]);
elem->SetDoubleAttribute("C04", matrix[0][4]);
elem->SetDoubleAttribute("C05", matrix[0][5]);
elem->SetDoubleAttribute("C10", matrix[1][0]);
elem->SetDoubleAttribute("C11", matrix[1][1]);
elem->SetDoubleAttribute("C12", matrix[1][2]);
elem->SetDoubleAttribute("C13", matrix[1][3]);
elem->SetDoubleAttribute("C14", matrix[1][4]);
elem->SetDoubleAttribute("C15", matrix[1][5]);
if (dataValid)
elem->SetAttribute("Valid",1);
else
elem->SetAttribute("Valid",0);
if (hasOrientation)
elem->SetAttribute("hO",1);
else
elem->SetAttribute("hO",0);
if (hasPosition)
elem->SetAttribute("hP",1);
else
elem->SetAttribute("hP",0);
// set additional attribute?
auto
it = m_AdditionalAttributes.find( nd );
if( it != m_AdditionalAttributes.end() )
{
elem->SetAttribute(it->second.first, it->second.second);
}
*m_Stream << " " << *elem << std::endl;
delete elem;
}
else if (this->m_OutputFormat == mitk::NavigationDataRecorderDeprecated::csv)
{
*m_Stream << ";" << dataValid << ";" << position[0] << ";" << position[1] << ";" << position[2] << ";" << orientation[0] << ";" << orientation[1] << ";" << orientation[2] << ";" << orientation[3];
}
}
}
if (this->m_OutputFormat == mitk::NavigationDataRecorderDeprecated::csv)
{
*m_Stream << "\n";
}
}
m_RecordCounter++;
if ((m_RecordCountLimit<=m_RecordCounter)&&(m_RecordCountLimit != -1)) {
StopRecording();
}
}
void mitk::PlanarFigureWriter::GenerateData()
{
m_Success = false;
if (!m_WriteToMemory && m_FileName.empty())
{
MITK_ERROR << "Could not write planar figures. File name is invalid";
throw std::invalid_argument("file name is empty");
}
TiXmlDocument document;
auto decl = new TiXmlDeclaration( "1.0", "", "" ); // TODO what to write here? encoding? etc....
document.LinkEndChild( decl );
auto version = new TiXmlElement("Version");
version->SetAttribute("Writer", __FILE__ );
version->SetAttribute("CVSRevision", "$Revision: 17055 $" );
version->SetAttribute("FileVersion", 1 );
document.LinkEndChild(version);
/* create xml element for each input */
for ( unsigned int i = 0 ; i < this->GetNumberOfInputs(); ++i )
{
// Create root element for this PlanarFigure
InputType::Pointer pf = this->GetInput( i );
if (pf.IsNull())
continue;
auto pfElement = new TiXmlElement("PlanarFigure");
pfElement->SetAttribute("type", pf->GetNameOfClass());
document.LinkEndChild(pfElement);
if ( pf->GetNumberOfControlPoints() == 0 )
continue;
//PlanarFigure::VertexContainerType* vertices = pf->GetControlPoints();
//if (vertices == NULL)
// continue;
// Serialize property list of PlanarFigure
mitk::PropertyList::Pointer propertyList = pf->GetPropertyList();
mitk::PropertyList::PropertyMap::const_iterator it;
for ( it = propertyList->GetMap()->begin(); it != propertyList->GetMap()->end(); ++it )
{
// Create seralizer for this property
const mitk::BaseProperty* prop = it->second;
std::string serializerName = std::string( prop->GetNameOfClass() ) + "Serializer";
std::list< itk::LightObject::Pointer > allSerializers = itk::ObjectFactoryBase::CreateAllInstance(
serializerName.c_str() );
if ( allSerializers.size() != 1 )
{
// No or too many serializer(s) found, skip this property
continue;
}
mitk::BasePropertySerializer* serializer = dynamic_cast< mitk::BasePropertySerializer* >(
allSerializers.begin()->GetPointer() );
if ( serializer == nullptr )
{
// Serializer not valid; skip this property
}
auto keyElement = new TiXmlElement( "property" );
keyElement->SetAttribute( "key", it->first );
keyElement->SetAttribute( "type", prop->GetNameOfClass() );
serializer->SetProperty( prop );
TiXmlElement* valueElement = nullptr;
try
{
valueElement = serializer->Serialize();
}
catch (...)
{
}
if ( valueElement == nullptr )
{
// Serialization failed; skip this property
continue;
}
// Add value to property element
keyElement->LinkEndChild( valueElement );
// Append serialized property to property list
pfElement->LinkEndChild( keyElement );
}
// Serialize control points of PlanarFigure
auto controlPointsElement = new TiXmlElement("ControlPoints");
pfElement->LinkEndChild(controlPointsElement);
for (unsigned int i = 0; i < pf->GetNumberOfControlPoints(); i++)
{
auto vElement = new TiXmlElement("Vertex");
vElement->SetAttribute("id", i);
vElement->SetDoubleAttribute("x", pf->GetControlPoint(i)[0]);
vElement->SetDoubleAttribute("y", pf->GetControlPoint(i)[1]);
controlPointsElement->LinkEndChild(vElement);
}
auto geoElement = new TiXmlElement("Geometry");
const PlaneGeometry* planeGeo = dynamic_cast<const PlaneGeometry*>(pf->GetPlaneGeometry());
if (planeGeo != nullptr)
{
// Write parameters of IndexToWorldTransform of the PlaneGeometry
typedef mitk::Geometry3D::TransformType TransformType;
const TransformType* affineGeometry = planeGeo->GetIndexToWorldTransform();
const TransformType::ParametersType& parameters = affineGeometry->GetParameters();
auto vElement = new TiXmlElement( "transformParam" );
for ( unsigned int i = 0; i < affineGeometry->GetNumberOfParameters(); ++i )
{
std::stringstream paramName;
paramName << "param" << i;
vElement->SetDoubleAttribute( paramName.str().c_str(), parameters.GetElement( i ) );
}
geoElement->LinkEndChild( vElement );
// Write bounds of the PlaneGeometry
typedef mitk::Geometry3D::BoundsArrayType BoundsArrayType;
const BoundsArrayType& bounds = planeGeo->GetBounds();
vElement = new TiXmlElement( "boundsParam" );
for ( unsigned int i = 0; i < 6; ++i )
{
std::stringstream boundName;
boundName << "bound" << i;
vElement->SetDoubleAttribute( boundName.str().c_str(), bounds.GetElement( i ) );
}
geoElement->LinkEndChild( vElement );
// Write spacing and origin of the PlaneGeometry
Vector3D spacing = planeGeo->GetSpacing();
Point3D origin = planeGeo->GetOrigin();
geoElement->LinkEndChild(this->CreateXMLVectorElement("Spacing", spacing));
geoElement->LinkEndChild(this->CreateXMLVectorElement("Origin", origin));
pfElement->LinkEndChild(geoElement);
}
}
if(m_WriteToMemory)
{
// Declare a printer
TiXmlPrinter printer;
// attach it to the document you want to convert in to a std::string
document.Accept(&printer);
// Create memory buffer and print tinyxmldocument there...
m_MemoryBufferSize = printer.Size() + 1;
m_MemoryBuffer = new char[m_MemoryBufferSize];
strcpy(m_MemoryBuffer,printer.CStr());
}
else
{
if (document.SaveFile( m_FileName) == false)
{
MITK_ERROR << "Could not write planar figures to " << m_FileName << "\nTinyXML reports '" << document.ErrorDesc() << "'";
throw std::ios_base::failure("Error during writing of planar figure xml file.");
}
}
m_Success = true;
}
