KmlPastebufferType Kml::ParseOnePlacemarkPoint( TiXmlNode* node, wxString& name ) {
double newLat = 0., newLon = 0.;
dPointList coordinates;
if( ParseCoordinates( node->ToElement(), coordinates ) ) {
newLat = coordinates[0].y;
newLon = coordinates[0].x;
}
if( newLat == 0.0 && newLon == 0.0 ) {
wxString msg( _T("KML Parser failed to convert <Point> coordinates.") );
wxLogMessage( msg );
return KML_PASTE_INVALID;
}
wxString pointName = wxEmptyString;
TiXmlElement* e = node->Parent()->FirstChild( "name" )->ToElement();
if( e ) pointName = wxString( e->GetText(), wxConvUTF8 );
wxString pointDescr = wxEmptyString;
e = node->Parent()->FirstChildElement( "description" );
// If the <description> is an XML element we must convert it to text,
// otherwise it gets lost.
if( e ) {
TiXmlNode* n = e->FirstChild();
if( n ) switch( n->Type() ){
case TiXmlNode::TINYXML_TEXT:
pointDescr = wxString( e->GetText(), wxConvUTF8 );
break;
case TiXmlNode::TINYXML_ELEMENT:
TiXmlPrinter printer;
printer.SetIndent( "\t" );
n->Accept( &printer );
pointDescr = wxString( printer.CStr(), wxConvUTF8 );
break;
}
}
// Extended data will override description.
TiXmlNode* n = node->Parent()->FirstChild( "ExtendedData" );
if( n ) {
TiXmlPrinter printer;
printer.SetIndent( "\t" );
n->Accept( &printer );
pointDescr = wxString( printer.CStr(), wxConvUTF8 );
}
// XXX leak ?
parsedRoutePoint = new RoutePoint();
parsedRoutePoint->m_lat = newLat;
parsedRoutePoint->m_lon = newLon;
parsedRoutePoint->m_bIsolatedMark = true;
parsedRoutePoint->m_bPtIsSelected = false;
parsedRoutePoint->m_MarkDescription = pointDescr;
parsedRoutePoint->SetName( pointName );
return KML_PASTE_WAYPOINT;
}
bool CSimpleXml::ModifyXmlAttri(list<XMLNODEINFO> &lstNode)
{
if(m_pDoc == NULL || m_pRoot == NULL)
{
return false;
}
list<XMLNODEINFO>::iterator itlst = lstNode.begin();
for(; itlst != lstNode.end(); ++itlst)
{
if(!ModifyOneAttri(*itlst))
{
return false;
}
}
TiXmlPrinter printer;
char szBuf[32];
memset(szBuf, 0, 32);
szBuf[0] = 0x9;
printer.SetIndent(szBuf);
szBuf[0] = 0x0a;
printer.SetLineBreak(szBuf);
if(m_pDoc->Accept(&printer))
{
m_strXml = printer.CStr();
}
else
{
return false;
}
return true;
}
wxFBDataObject::wxFBDataObject( PObjectBase obj )
:
wxDataObject()
{
if ( obj )
{
// create xml representation of ObjectBase
ticpp::Element element;
obj->SerializeObject( &element );
// add version info to xml data, just in case it is pasted into a different version of wxFB
element.SetAttribute( "fbp_version_major", AppData()->m_fbpVerMajor );
element.SetAttribute( "fbp_version_minor", AppData()->m_fbpVerMinor );
ticpp::Document doc;
doc.LinkEndChild( &element );
TiXmlPrinter printer;
printer.SetIndent( "\t" );
#if defined( __WXMSW__ )
printer.SetLineBreak( "\r\n" );
#else
printer.SetLineBreak( "\n" );
#endif
doc.Accept( &printer );
m_data = printer.Str();
}
}
void wxsCustomWidget::RebuildXmlData()
{
TiXmlPrinter Printer;
Printer.SetIndent("\t");
m_XmlDataDoc.Accept(&Printer);
m_XmlData = cbC2U(Printer.CStr());
}
void CXmlDocument::ToString(CDataBuffer& buffer)
{
TiXmlPrinter printer;
printer.SetLineBreak("\r\n");
printer.SetIndent("\t");
_doc->Accept(&printer);
buffer.Add(printer.CStr());
}
void xml_write_archive::save(const variant& what)
{
TiXmlPrinter printer;
printer.SetIndent( "\t" );
base_write_archive::save( what );
doc_.Accept( &printer );
result_ = printer.Str();
}
std::string SerializeBase::nodeToString(const TxElement& node) {
try {
TiXmlPrinter printer;
printer.SetIndent(" ");
node.Accept(&printer);
return printer.CStr();
} catch (TxException&) {
return "No valid root node";
}
}
std::string tiXmlToStr(TiXmlNode* xmlNode)
{
//print
TiXmlPrinter printer;
printer.SetIndent( "\t" );
xmlNode->Accept( &printer );
const std::string& result = printer.Str();
return result;
}
void Export_DAE(std::ostream &s, Mesh * aMesh, Options &aOptions) {
// Create the XML document
TiXmlDocument doc("model");
Export_DAE(doc, aMesh, aOptions);
// Write the document to the stream.
TiXmlPrinter printer;
printer.SetIndent(" ");
doc.Accept(&printer);
s << printer.CStr();
}
bool TinyXML::SaveDocument(const wxString& filename, TiXmlDocument* doc)
{
if (!doc)
return false;
TiXmlPrinter printer;
printer.SetIndent("\t");
doc->Accept(&printer);
return Manager::Get()->GetFileManager()->SaveUTF8(filename, printer.CStr(), printer.Size());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void XmlDocumentImpl::getAsRawData(cvf::UByteArray* buffer) const
{
TiXmlPrinter printer;
// Use tab as indent marker
printer.SetIndent( "\t" );
// Link document to printer
Accept(&printer);
buffer->assign((cvf::ubyte*)printer.CStr(), (size_t)printer.Size());
}
bool TreeVisitor::visitLeave(Solution& solution)
{
TiXmlPrinter printer;
printer.SetIndent(nullptr);
printer.SetLineBreak(nullptr);
m_document.Accept(&printer);
m_serialized = printer.CStr();
return true;
}
string GarminFilebasedDevice::getDeviceDescription() const
{
if (this->deviceDescription == NULL) { return ""; }
TiXmlPrinter printer;
printer.SetIndent( "\t" );
this->deviceDescription->Accept( &printer );
string str = printer.Str();
if (Log::enabledDbg()) Log::dbg("GarminFilebasedDevice::getDeviceDescription() Done: "+this->displayName );
return str;
}
bool CSimpleXml::AddNodes(const string &strPath, list<XMLNODEINFO> &lstaddnode)
{
if(m_pDoc == NULL || m_pRoot == NULL)
{
return false;
}
TiXmlElement *pCurrNode = m_pRoot;
list<string> lstNode;
SeperateString(lstNode, strPath, "/");
list<string>::iterator itlstNode = lstNode.begin();
while (NULL != pCurrNode)
{
if (itlstNode != lstNode.end() && *itlstNode == pCurrNode->Value())
{
string strShow = pCurrNode->Value();
if (++itlstNode == lstNode.end())
{
AddOneNode(&pCurrNode, lstaddnode);
goto SIMXML;
}
pCurrNode = pCurrNode->FirstChildElement();
}
else
{
pCurrNode = pCurrNode->NextSiblingElement();
}
}
return false;
SIMXML:
TiXmlPrinter printer;
char szBuf[32];
memset(szBuf, 0, 32);
szBuf[0] = 0x9;
printer.SetIndent(szBuf);
szBuf[0] = 0x0a;
printer.SetLineBreak(szBuf);
if(m_pDoc->Accept(&printer))
{
m_strXml = printer.CStr();
}
else
{
return false;
}
return true;
}
std::string Partida::getXMLNivel() {
XMLDocument doc;
bool cargoArchivo = doc.LoadFile(idNiveles[contadorNiveles]);
if (cargoArchivo == false) {
std::cout << "\tError al abrir el archivo XML." << std::endl;
return std::string();
}
TiXmlPrinter printer;
printer.SetIndent("");
printer.SetLineBreak("");
doc.Accept(&printer);
return printer.CStr();
}
void Archive::Close()
{
//destroy the xml root (if exists)
if (xml_objects.size())
{
//take the document to deallocate it
while (xml_objects.size()!=1) xml_objects.pop();
TiXmlDocument* xml_doc=CURNODE->ToDocument();
//close the file (==save it)
if (Saving())
{
TiXmlPrinter printer;
printer.SetIndent("\t");
xml_doc->Accept(&printer);
const char* content= printer.CStr();
int len=(int)strlen(content)+1;
bTextMode=false; //want the output to the real file
InnerWrite((void*)content,len);
}
delete xml_doc;
}
xml_objects=std::stack<StackItem >();
//destry the map for SmartPointer Objects
if (this->Loading())
{
for (std::map<uint64,uint64>::iterator it=smart_pointers.begin();it!=smart_pointers.end();it++)
{
//see: http://www.boost.org/doc/libs/1_40_0/libs/smart_ptr/sp_techniques.html#preventing_delete
//Interesting part: Using shared_ptr<void> to hold an arbitrary object
//Checked and it seems to work (probably shared_ptr probably stores inside the correct deleter!)
SmartPointer<void>* temp=(SmartPointer<void>*)(it->second);
temp->reset();
delete temp;
}
}
smart_pointers.clear();
//close the gzfile
if (this->gzfile) gzclose((gzFile)this->gzfile);
this->gzfile=0;
//close the regular file
if (this->file) fclose(this->file);
this->file=0;
}
wxString Kml::MakeKmlFromWaypoint( RoutePoint* routepoint ) {
TiXmlDocument xmlDoc;
wxString name = _("OpenCPN Waypoint");
if( routepoint->GetName().Length() ) name = routepoint->GetName();
TiXmlElement* document = StandardHead( xmlDoc, name );
insertQtVlmExtendedData = false;
PointPlacemark( document, routepoint );
TiXmlPrinter printer;
printer.SetIndent( " " );
xmlDoc.Accept( &printer );
return wxString( printer.CStr(), wxConvUTF8 );
}
void
XmlDocument::store( std::ostream& out ) const
{
TiXmlDocument doc;
doc.LinkEndChild( new TiXmlDeclaration( "1.0", "", ""));
storeNode( this, &doc );
//Use TiXmlPrinter to do pretty printing.
TiXmlPrinter printer;
printer.SetIndent(" ");
doc.Accept(&printer);
out << printer.CStr();
//out << doc;
}
bool MainFrame::TiXmlSaveDocument(const wxString& filename, TiXmlDocument* doc)
{
if (!doc)
return false;
TiXmlPrinter printer;
printer.SetIndent("\t");
doc->Accept(&printer);
wxTempFile file(filename);
if(file.IsOpened())
if(file.Write(printer.CStr(), printer.Size()) && file.Commit())
return true;
return false;
}// TiXmlSaveDocument
wxString Kml::MakeKmlFromTrack( Track* track ) {
TiXmlDocument xmlDoc;
wxString name = _("OpenCPN Track");
if( track->m_TrackNameString.Length() ) name = track->m_TrackNameString;
TiXmlElement* document = StandardHead( xmlDoc, name );
TiXmlElement* pmTrack = new TiXmlElement( "Placemark" );
document->LinkEndChild( pmTrack );
TiXmlElement* pmName = new TiXmlElement( "name" );
pmTrack->LinkEndChild( pmName );
TiXmlText* pmNameVal = new TiXmlText( track->m_TrackNameString.mb_str( wxConvUTF8 ) );
pmName->LinkEndChild( pmNameVal );
TiXmlElement* gxTrack = new TiXmlElement( "gx:Track" );
pmTrack->LinkEndChild( gxTrack );
std::stringstream lineStringCoords;
for(int i=0; i<track->GetnPoints(); i++) {
TrackPoint *trackpoint = track->GetPoint(i);
TiXmlElement* when = new TiXmlElement( "when" );
gxTrack->LinkEndChild( when );
wxDateTime whenTime( trackpoint->GetCreateTime() );
TiXmlText* whenVal = new TiXmlText( whenTime.Format( _T("%Y-%m-%dT%H:%M:%SZ") ).mb_str( wxConvUTF8 ) );
when->LinkEndChild( whenVal );
}
for(int i=0; i<track->GetnPoints(); i++) {
TrackPoint *trackpoint = track->GetPoint(i);
TiXmlElement* coord = new TiXmlElement( "gx:coord" );
gxTrack->LinkEndChild( coord );
wxString coordStr = wxString::Format( _T("%f %f 0.0"), trackpoint->m_lon, trackpoint->m_lat );
TiXmlText* coordVal = new TiXmlText( coordStr.mb_str( wxConvUTF8 ) );
coord->LinkEndChild( coordVal );
}
TiXmlPrinter printer;
printer.SetIndent( " " );
xmlDoc.Accept( &printer );
return wxString( printer.CStr(), wxConvUTF8 );
}
bool TinyXML::SaveDocument(const wxString& filename, TiXmlDocument* doc)
{
if (!doc)
return false;
TiXmlPrinter printer;
printer.SetIndent("\t");
doc->Accept(&printer);
return Manager::Get()->GetFileManager()->Save(filename, printer.CStr(), printer.Size());
// wxTempFile file(filename);
// if(file.IsOpened())
// if(file.Write(Printer.CStr(), Printer.Size()) && file.Commit())
// return true;
// return false;
}
QString reportDataThread::encode(){
//if(DEBUG){qWarning() << "Encoding XML";}
TiXmlPrinter* printer = new TiXmlPrinter();
printer->SetIndent( "\t" );
printer->SetLineBreak( "\n" );
//printer->SetStreamPrinting();
doc->Accept(printer);
const char* temp = printer->CStr();
//qWarning() << "XML:" << temp;
QByteArray array = QByteArray(temp).toPercentEncoding();
//if(DEBUG){qWarning() << "XML encoded";}
return QString(array);
}
wxString Kml::MakeKmlFromRoute( Route* route, bool insertSeq ) {
insertQtVlmExtendedData = insertSeq;
seqCounter = 0;
TiXmlDocument xmlDoc;
wxString name = _("OpenCPN Route");
if( route->m_RouteNameString.Length() ) name = route->m_RouteNameString;
TiXmlElement* document = StandardHead( xmlDoc, name );
std::stringstream lineStringCoords;
RoutePointList *pointList = route->pRoutePointList;
wxRoutePointListNode *pointnode = pointList->GetFirst();
RoutePoint *routepoint;
while( pointnode ) {
routepoint = pointnode->GetData();
lineStringCoords << PointPlacemark( document, routepoint );
seqCounter++;
pointnode = pointnode->GetNext();
}
TiXmlElement* pmPath = new TiXmlElement( "Placemark" );
document->LinkEndChild( pmPath );
TiXmlElement* pmName = new TiXmlElement( "name" );
pmPath->LinkEndChild( pmName );
TiXmlText* pmNameVal = new TiXmlText( "Path" );
pmName->LinkEndChild( pmNameVal );
TiXmlElement* linestring = new TiXmlElement( "LineString" );
pmPath->LinkEndChild( linestring );
TiXmlElement* coordinates = new TiXmlElement( "coordinates" );
linestring->LinkEndChild( coordinates );
TiXmlText* text = new TiXmlText( lineStringCoords.str() );
coordinates->LinkEndChild( text );
TiXmlPrinter printer;
printer.SetIndent( " " );
xmlDoc.Accept( &printer );
return wxString( printer.CStr(), wxConvUTF8 );
}
string Edge305Device::readGpxData() {
if (this->fitnessData == NULL) {
this->fitnessData = readFitnessDataFromGarmin();
}
if (this->fitnessData != NULL) {
transferSuccessful = true;
TiXmlDocument * output = this->fitnessData->getGpxDocument();
TiXmlPrinter printer;
printer.SetIndent( " " );
output->Accept( &printer );
string fitnessXml = printer.Str();
delete(output);
return fitnessXml;
} else {
transferSuccessful = false;
return "";
}
}
bool Scene::Serialize( const char* filename, bool compression ) const
{
#if TINYXML_FOUND
TiXmlDocument doc;
TiXmlDeclaration *decl = new TiXmlDeclaration("1.0", "", "");
doc.LinkEndChild(decl);
TiXmlElement *container = new TiXmlElement("freyja");
container->SetAttribute("version", VERSION);
container->SetAttribute("build-date", __DATE__);
container->SetAttribute("file-version", 1);
doc.LinkEndChild(container);
mCameras.Serialize( container );
mLights.Serialize( container );
mMeshes.Serialize( container );
mMetadata.Serialize( container );
mSkeletons.Serialize( container );
bool ret = false;
if ( compression )
{
TiXmlPrinter printer;
printer.SetIndent( "\t" );
doc.Accept( &printer );
const char* xml = printer.CStr();
if ( xml )
{
ret = mstl::GzFileWrite( filename, xml, strlen(xml) );
}
}
else
{
ret = doc.SaveFile(filename);
}
return ret;
#else
return false;
#endif
}
sqbind::stdString CSqXml::Encode( sqbind::CSqMulti *pData,
const sqbind::stdString &sLineBreak,
const sqbind::stdString &sTab, int bIndexed )
{_STT();
if ( !pData )
return oexT( "" );
// Encode the list into xml
TiXmlDocument xmlDoc;
// Do the encode
if ( !_Encode( &xmlDoc, pData, bIndexed ) )
return oexT( "" );
// Setup a printer
TiXmlPrinter printer;
printer.SetIndent( oexStrToMbPtr( sTab.c_str() ) );
printer.SetLineBreak( oexStrToMbPtr( sLineBreak.c_str() ) );
xmlDoc.Accept( &printer );
// Return the encoded xml
return oexMbToStrPtr( printer.CStr() );
}
/*** XmlForLua ***/
int XmlForLua::_Encode(lua_State* L){
// prepare name
if((lua_gettop(L)<1) || (!lua_istable(L, 1))){
lua_pushnil(L);
lua_pushstring(L, "invalid arg");
return 2;
}
// parse
TiXmlPrinter printer;
printer.SetIndent("\t");
TiXmlElement* ele =lua_to_xml(L, "root");
if(ele->Accept(&printer) && printer.CStr()){
lua_pushstring(L, printer.CStr());
delete ele;
return 1;
}
else{
lua_pushnil(L);
lua_pushstring(L, "tinyxml unknown error");
delete ele;
return 2;
}
}
void CAdvancedSettings::ParseSettingsFile(const CStdString &file)
{
TiXmlDocument advancedXML;
if (!CFile::Exists(file))
{
CLog::Log(LOGNOTICE, "No settings file to load (%s)", file.c_str());
return;
}
if (!advancedXML.LoadFile(file))
{
CLog::Log(LOGERROR, "Error loading %s, Line %d\n%s", file.c_str(), advancedXML.ErrorRow(), advancedXML.ErrorDesc());
return;
}
TiXmlElement *pRootElement = advancedXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(),"advancedsettings") != 0)
{
CLog::Log(LOGERROR, "Error loading %s, no <advancedsettings> node", file.c_str());
return;
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded settings file from %s", file.c_str());
// Dump contents of AS.xml to debug log
TiXmlPrinter printer;
printer.SetLineBreak("\n");
printer.SetIndent(" ");
advancedXML.Accept(&printer);
CLog::Log(LOGNOTICE, "Contents of %s are...\n%s", file.c_str(), printer.CStr());
TiXmlElement *pElement = pRootElement->FirstChildElement("audio");
if (pElement)
{
XMLUtils::GetFloat(pElement, "ac3downmixgain", m_ac3Gain, -96.0f, 96.0f);
XMLUtils::GetInt(pElement, "headroom", m_audioHeadRoom, 0, 12);
XMLUtils::GetString(pElement, "defaultplayer", m_audioDefaultPlayer);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_audioPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_musicUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_musicTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_musicTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_musicTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_musicTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_musicPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_musicPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_musicPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_musicPercentSeekBackwardBig, -100, 0);
XMLUtils::GetInt(pElement, "resample", m_musicResample, 0, 192000);
TiXmlElement* pAudioExcludes = pElement->FirstChildElement("excludefromlisting");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromListingRegExps);
pAudioExcludes = pElement->FirstChildElement("excludefromscan");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromScanRegExps);
XMLUtils::GetString(pElement, "audiohost", m_audioHost);
XMLUtils::GetBoolean(pElement, "applydrc", m_audioApplyDrc);
XMLUtils::GetBoolean(pElement, "dvdplayerignoredtsinwav", m_dvdplayerIgnoreDTSinWAV);
XMLUtils::GetFloat(pElement, "limiterhold", m_limiterHold, 0.0f, 100.0f);
XMLUtils::GetFloat(pElement, "limiterrelease", m_limiterRelease, 0.001f, 100.0f);
}
pElement = pRootElement->FirstChildElement("karaoke");
if (pElement)
{
XMLUtils::GetFloat(pElement, "syncdelaycdg", m_karaokeSyncDelayCDG, -3.0f, 3.0f); // keep the old name for comp
XMLUtils::GetFloat(pElement, "syncdelaylrc", m_karaokeSyncDelayLRC, -3.0f, 3.0f);
XMLUtils::GetBoolean(pElement, "alwaysreplacegenre", m_karaokeChangeGenreForKaraokeSongs );
XMLUtils::GetBoolean(pElement, "storedelay", m_karaokeKeepDelay );
XMLUtils::GetInt(pElement, "autoassignstartfrom", m_karaokeStartIndex, 1, 2000000000);
XMLUtils::GetBoolean(pElement, "nocdgbackground", m_karaokeAlwaysEmptyOnCdgs );
XMLUtils::GetBoolean(pElement, "lookupsongbackground", m_karaokeUseSongSpecificBackground );
TiXmlElement* pKaraokeBackground = pElement->FirstChildElement("defaultbackground");
if (pKaraokeBackground)
{
const char* attr = pKaraokeBackground->Attribute("type");
if ( attr )
m_karaokeDefaultBackgroundType = attr;
attr = pKaraokeBackground->Attribute("path");
if ( attr )
m_karaokeDefaultBackgroundFilePath = attr;
}
}
pElement = pRootElement->FirstChildElement("video");
if (pElement)
{
XMLUtils::GetFloat(pElement, "subsdelayrange", m_videoSubsDelayRange, 10, 600);
XMLUtils::GetFloat(pElement, "audiodelayrange", m_videoAudioDelayRange, 10, 600);
XMLUtils::GetInt(pElement, "blackbarcolour", m_videoBlackBarColour, 0, 255);
XMLUtils::GetString(pElement, "defaultplayer", m_videoDefaultPlayer);
XMLUtils::GetString(pElement, "defaultdvdplayer", m_videoDefaultDVDPlayer);
XMLUtils::GetBoolean(pElement, "fullscreenonmoviestart", m_fullScreenOnMovieStart);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_videoPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetInt(pElement, "ignoresecondsatstart", m_videoIgnoreSecondsAtStart, 0, 900);
XMLUtils::GetFloat(pElement, "ignorepercentatend", m_videoIgnorePercentAtEnd, 0, 100.0f);
XMLUtils::GetInt(pElement, "smallstepbackseconds", m_videoSmallStepBackSeconds, 1, INT_MAX);
XMLUtils::GetInt(pElement, "smallstepbacktries", m_videoSmallStepBackTries, 1, 10);
XMLUtils::GetInt(pElement, "smallstepbackdelay", m_videoSmallStepBackDelay, 100, 5000); //MS
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_videoUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_videoTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_videoTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_videoTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_videoTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_videoPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_videoPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_videoPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_videoPercentSeekBackwardBig, -100, 0);
TiXmlElement* pVideoExcludes = pElement->FirstChildElement("excludefromlisting");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoExcludeFromListingRegExps);
pVideoExcludes = pElement->FirstChildElement("excludefromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_moviesExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("excludetvshowsfromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_tvshowExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("cleanstrings");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoCleanStringRegExps);
XMLUtils::GetString(pElement,"cleandatetime", m_videoCleanDateTimeRegExp);
XMLUtils::GetString(pElement,"ppffmpegdeinterlacing",m_videoPPFFmpegDeint);
XMLUtils::GetString(pElement,"ppffmpegpostprocessing",m_videoPPFFmpegPostProc);
XMLUtils::GetBoolean(pElement,"vdpauscaling",m_videoVDPAUScaling);
XMLUtils::GetFloat(pElement, "nonlinearstretchratio", m_videoNonLinStretchRatio, 0.01f, 1.0f);
XMLUtils::GetBoolean(pElement,"enablehighqualityhwscalers", m_videoEnableHighQualityHwScalers);
XMLUtils::GetFloat(pElement,"autoscalemaxfps",m_videoAutoScaleMaxFps, 0.0f, 1000.0f);
XMLUtils::GetBoolean(pElement,"allowmpeg4vdpau",m_videoAllowMpeg4VDPAU);
XMLUtils::GetBoolean(pElement,"allowmpeg4vaapi",m_videoAllowMpeg4VAAPI);
XMLUtils::GetBoolean(pElement, "disablebackgrounddeinterlace", m_videoDisableBackgroundDeinterlace);
XMLUtils::GetInt(pElement, "useocclusionquery", m_videoCaptureUseOcclusionQuery, -1, 1);
TiXmlElement* pAdjustRefreshrate = pElement->FirstChildElement("adjustrefreshrate");
if (pAdjustRefreshrate)
{
TiXmlElement* pRefreshOverride = pAdjustRefreshrate->FirstChildElement("override");
while (pRefreshOverride)
{
RefreshOverride override = {0};
float fps;
if (XMLUtils::GetFloat(pRefreshOverride, "fps", fps))
{
override.fpsmin = fps - 0.01f;
override.fpsmax = fps + 0.01f;
}
float fpsmin, fpsmax;
if (XMLUtils::GetFloat(pRefreshOverride, "fpsmin", fpsmin) &&
XMLUtils::GetFloat(pRefreshOverride, "fpsmax", fpsmax))
{
override.fpsmin = fpsmin;
override.fpsmax = fpsmax;
}
float refresh;
if (XMLUtils::GetFloat(pRefreshOverride, "refresh", refresh))
{
override.refreshmin = refresh - 0.01f;
override.refreshmax = refresh + 0.01f;
void LabelSetImageIO::Write()
{
ValidateOutputLocation();
const LabelSetImage* input = static_cast<const LabelSetImage*>(this->GetInput());
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
mitkThrow() << "Could not set locale " << currLocale;
}
}
mitk::Image::Pointer inputVector = mitk::LabelSetImageConverter::ConvertLabelSetImageToImage(input);
// image write
if ( inputVector.IsNull() )
{
mitkThrow() << "Cannot write non-image data";
}
itk::NrrdImageIO::Pointer nrrdImageIo = itk::NrrdImageIO::New();
// Clone the image geometry, because we might have to change it
// for writing purposes
BaseGeometry::Pointer geometry = inputVector->GetGeometry()->Clone();
// Check if geometry information will be lost
if (inputVector->GetDimension() == 2 &&
!geometry->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = geometry->GetSpacing();
mitk::Point3D origin = geometry->GetOrigin();
geometry->SetIndexToWorldTransform(affTrans);
geometry->SetSpacing(spacing);
geometry->SetOrigin(origin);
}
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
const unsigned int dimension = inputVector->GetDimension();
const unsigned int* const dimensions = inputVector->GetDimensions();
const mitk::PixelType pixelType = inputVector->GetPixelType();
const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
const mitk::Point3D mitkOrigin = geometry->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
// though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
// Set the necessary information for imageIO
nrrdImageIo->SetNumberOfDimensions(dimension);
nrrdImageIo->SetPixelType(pixelType.GetPixelType());
nrrdImageIo->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
nrrdImageIo->SetNumberOfComponents(pixelType.GetNumberOfComponents());
itk::ImageIORegion ioRegion(dimension);
for (unsigned int i = 0; i < dimension; i++)
{
nrrdImageIo->SetDimensions(i, dimensions[i]);
nrrdImageIo->SetSpacing(i, spacing4D[i]);
nrrdImageIo->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
{
direction4D[3] = 1; // homogenous component
}
else
{
direction4D[3] = 0;
}
vnl_vector<double> axisDirection(dimension);
for (unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
nrrdImageIo->SetDirection(i, axisDirection);
ioRegion.SetSize(i, inputVector->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, inputVector->GetLargestPossibleRegion().GetIndex(i));
}
//use compression if available
nrrdImageIo->UseCompressionOn();
nrrdImageIo->SetIORegion(ioRegion);
nrrdImageIo->SetFileName(path);
// label set specific meta data
char keybuffer[512];
char valbuffer[512];
sprintf(keybuffer, "modality");
sprintf(valbuffer, "org.mitk.image.multilabel");
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
sprintf(keybuffer, "layers");
sprintf(valbuffer, "%1d", input->GetNumberOfLayers());
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
for (unsigned int layerIdx = 0; layerIdx<input->GetNumberOfLayers(); layerIdx++)
{
sprintf(keybuffer, "layer_%03d", layerIdx); // layer idx
sprintf(valbuffer, "%1d", input->GetNumberOfLabels(layerIdx)); // number of labels for the layer
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
mitk::LabelSet::LabelContainerConstIteratorType iter = input->GetLabelSet(layerIdx)->IteratorConstBegin();
unsigned int count(0);
while (iter != input->GetLabelSet(layerIdx)->IteratorConstEnd())
{
std::auto_ptr<TiXmlDocument> document;
document.reset(new TiXmlDocument());
TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "", ""); // TODO what to write here? encoding? etc....
document->LinkEndChild(decl);
TiXmlElement * labelElem = GetLabelAsTiXmlElement(iter->second);
document->LinkEndChild(labelElem);
TiXmlPrinter printer;
printer.SetIndent("");
printer.SetLineBreak("");
document->Accept(&printer);
sprintf(keybuffer, "org.mitk.label_%03u_%05u", layerIdx, count);
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), printer.Str());
++iter;
++count;
}
}
// end label set specific meta data
ImageReadAccessor imageAccess(inputVector);
nrrdImageIo->Write(imageAccess.GetData());
}
catch (const std::exception& e)
{
mitkThrow() << e.what();
}
// end image write
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
mitkThrow() << "Could not reset locale " << currLocale;
}
}
string Edge305Device::getDeviceDescription() const {
if (Log::enabledDbg()) Log::dbg("GpsDevice::getDeviceDescription() "+this->displayName);
/*
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<Device xmlns="http://www.garmin.com/xmlschemas/GarminDevice/v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.garmin.com/xmlschemas/GarminDevice/v2 http://www.garmin.com/xmlschemas/GarminDevicev2.xsd">
<Model>
<PartNumber>006-B0450-00</PartNumber>
<SoftwareVersion>320</SoftwareVersion>
<Description>EDGE305 Software Version 3.20</Description>
</Model>
<Id>3305091776</Id>
<DisplayName>Your name</DisplayName>
<MassStorageMode>
<DataType>
<Name>GPSData</Name>
<File>
<Specification>
<Identifier>http://www.topografix.com/GPX/1/1</Identifier>
<Documentation>http://www.topografix.com/GPX/1/1/gpx.xsd</Documentation>
</Specification>
<Location>
<FileExtension>GPX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessHistory</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>OutputFromUnit</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessUserProfile</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<BaseName>UserProfile</BaseName>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessCourses</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessWorkouts</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<UpdateFile>
<PartNumber>006-B0450-00</PartNumber>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
</UpdateFile>
<UpdateFile>
<PartNumber>006-B0478-00</PartNumber>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
</UpdateFile>
</MassStorageMode>
<GarminMode>
<Protocols>
<Application Id="918">
<DataType>918</DataType>
</Application>
</Protocols>
<Extensions>
<GarminModeExtension xmlns="http://www.garmin.com/xmlschemas/GarminDeviceExtensions/v3">
<MemoryRegion>
<Id>5</Id>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
<ExpectedPartNumber>006-B0450-00</ExpectedPartNumber>
<CurrentPartNumber>006-B0450-00</CurrentPartNumber>
<IsErased>true</IsErased>
<IsUserUpdateable>true</IsUserUpdateable>
</MemoryRegion>
<MemoryRegion>
<Id>14</Id>
<Version>
<Major>3</Major>
<Minor>20</Minor>
</Version>
<Description>EDGE305</Description>
<ExpectedPartNumber>006-B0450-00</ExpectedPartNumber>
<CurrentPartNumber>006-B0450-00</CurrentPartNumber>
<IsUserUpdateable>true</IsUserUpdateable>
</MemoryRegion>
<MemoryRegion>
<Id>246</Id>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
<ExpectedPartNumber>006-B0478-00</ExpectedPartNumber>
<CurrentPartNumber>006-B0478-00</CurrentPartNumber>
<IsErased>true</IsErased>
<IsUserUpdateable>true</IsUserUpdateable>
</MemoryRegion>
</GarminModeExtension>
</Extensions>
</GarminMode>
</Device>
*/
garmin_unit garmin;
if ( garmin_init(&garmin,0) != 0 ) {
garmin_close(&garmin);
} else {
Log::err("Opening of garmin device failed. No longer attached!?");
return "";
}
TiXmlDocument doc;
TiXmlDeclaration * decl = new TiXmlDeclaration( "1.0", "UTF-8", "no" );
doc.LinkEndChild( decl );
/*<Device xmlns="http://www.garmin.com/xmlschemas/GarminDevice/v2"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.garmin.com/xmlschemas/GarminDevice/v2 http://www.garmin.com/xmlschemas/GarminDevicev2.xsd">*/
TiXmlElement * device = new TiXmlElement( "Device" );
device->SetAttribute("xmlns", "http://www.garmin.com/xmlschemas/GarminDevice/v2");
device->SetAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
device->SetAttribute("xsi:schemaLocation", "http://www.garmin.com/xmlschemas/GarminDevice/v2 http://www.garmin.com/xmlschemas/GarminDevicev2.xsd");
doc.LinkEndChild( device );
/*<Model>
<PartNumber>006-B0450-00</PartNumber>
<SoftwareVersion>320</SoftwareVersion>
<Description>EDGE305 Software Version 3.20</Description>
</Model> */
TiXmlElement * model = new TiXmlElement( "Model" );
TiXmlElement * partnumber = new TiXmlElement( "PartNumber" );
partnumber->LinkEndChild(new TiXmlText("006-B0450-00"));
TiXmlElement * version = new TiXmlElement( "SoftwareVersion" );
std::stringstream ss;
ss << garmin.product.software_version;
version->LinkEndChild(new TiXmlText( ss.str() ));
TiXmlElement * descr = new TiXmlElement( "Description" );
descr->LinkEndChild(new TiXmlText(this->displayName));
model->LinkEndChild(partnumber);
model->LinkEndChild(version);
model->LinkEndChild(descr);
device->LinkEndChild( model );
/* <Id>3333333333</Id> */
TiXmlElement * id = new TiXmlElement( "Id" );
ss.str(""); // empty stringstream
ss << garmin.id;
id->LinkEndChild(new TiXmlText(ss.str()));
device->LinkEndChild(id);
/* <DisplayName>Your name</DisplayName>*/
TiXmlElement * dispName = new TiXmlElement( "DisplayName" );
dispName->LinkEndChild(new TiXmlText(this->displayName));
device->LinkEndChild(dispName);
TiXmlElement * massStorage = new TiXmlElement( "MassStorageMode" );
device->LinkEndChild(massStorage);
/*
<DataType>
<Name>GPSData</Name>
<File>
<Specification>
<Identifier>http://www.topografix.com/GPX/1/1</Identifier>
<Documentation>http://www.topografix.com/GPX/1/1/gpx.xsd</Documentation>
</Specification>
<Location>
<FileExtension>GPX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
*/
TiXmlElement * dataTypes = new TiXmlElement( "DataType" );
massStorage->LinkEndChild(dataTypes);
TiXmlElement * name = new TiXmlElement( "Name" );
name->LinkEndChild(new TiXmlText("GPSData"));
dataTypes->LinkEndChild(name);
TiXmlElement * file = new TiXmlElement( "File" );
dataTypes->LinkEndChild(file);
TiXmlElement * spec = new TiXmlElement( "Specification" );
file->LinkEndChild(spec);
TiXmlElement * identifier = new TiXmlElement( "Identifier" );
identifier->LinkEndChild(new TiXmlText("http://www.topografix.com/GPX/1/1"));
spec->LinkEndChild(identifier);
TiXmlElement * docu = new TiXmlElement( "Documentation" );
docu->LinkEndChild(new TiXmlText("http://www.topografix.com/GPX/1/1/gpx.xsd"));
spec->LinkEndChild(docu);
TiXmlElement * loc = new TiXmlElement( "Location" );
file->LinkEndChild(loc);
TiXmlElement * fileEx = new TiXmlElement( "FileExtension" );
fileEx->LinkEndChild(new TiXmlText("GPX"));
loc->LinkEndChild(fileEx);
TiXmlElement * transferDir = new TiXmlElement( "TransferDirection" );
transferDir->LinkEndChild(new TiXmlText("InputOutput"));
file->LinkEndChild(transferDir);
/*
<DataType>
<Name>FitnessHistory</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>OutputFromUnit</TransferDirection>
</File>
</DataType>
*/
dataTypes = new TiXmlElement( "DataType" );
massStorage->LinkEndChild(dataTypes);
name = new TiXmlElement( "Name" );
name->LinkEndChild(new TiXmlText("FitnessHistory"));
dataTypes->LinkEndChild(name);
file = new TiXmlElement( "File" );
dataTypes->LinkEndChild(file);
spec = new TiXmlElement( "Specification" );
file->LinkEndChild(spec);
identifier = new TiXmlElement( "Identifier" );
identifier->LinkEndChild(new TiXmlText("http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2"));
spec->LinkEndChild(identifier);
docu = new TiXmlElement( "Documentation" );
docu->LinkEndChild(new TiXmlText("http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd"));
spec->LinkEndChild(docu);
loc = new TiXmlElement( "Location" );
file->LinkEndChild(loc);
fileEx = new TiXmlElement( "FileExtension" );
fileEx->LinkEndChild(new TiXmlText("TCX"));
loc->LinkEndChild(fileEx);
transferDir = new TiXmlElement( "TransferDirection" );
transferDir->LinkEndChild(new TiXmlText("InputOutput"));
file->LinkEndChild(transferDir);
TiXmlPrinter printer;
printer.SetIndent( "\t" );
doc.Accept( &printer );
string str = printer.Str();
if (Log::enabledDbg()) Log::dbg("GpsDevice::getDeviceDescription() Done: "+this->displayName );
return str;
}
