Hab gerade in der Uni die Aufgabe bekommen, eine XML-Datei in eine STL-Datei umzuwandeln und soll ein eigenes Programm schreiben.
Ich bin Maschinenbauer und besitzte leider rudimentäre Kenntnisse über C++ und wollte daher euch um Hilfe bitten(eine Schleife kann ich schon schreiben).

Ich hab mich schon über XML Parser schlau gemacht, sehe da aber leider nicht so durch.
Könnt ihr mir bitte helfen oder mir den richtigen Weg weisen.
Eine Dankeschön schon mal im vorraus.

Die XML-Datei ist eine Schiffssection, in der Platten, Löcher, Cutouts und noch einiges mehr drin stehen.

Die Daten beinhalten die Eckpunkte der Platten, erzeugt vektoren, um die Kontur darzustellen und daraufhin werden Löcher reingemacht oder etwas anderes drauf.

Die STL-Datei halbiert die Platten. Die stellt alles mit Dreiecken dar. Außerdem benötigt diese Datei viel weniger informationen, um die Schiffssection wieder darzustellen.

Ich glaube zwar nicht, dass ich deine Frage beantwortet habe. Wenn also nicht, bitte etwas genauer.

Mein Problem:
Ich weiß nicht, wie ich einem Programm sage: Nimm die Informationen raus(XML), die ich brauche und schreibe sie in ein STL-Format. Beim STL-Format könnte es auch sein, dass ich dem Programm den Quellcode vorgebe

ob das hilft, ist eine andere Frage, aber so ähnlich könnte das STL-Format am ende aussehen

solid plate
facet normal nx1 ny1 nz1
outer loop
vertex x1 y1 z1
vertex x2 y2 z2
vertex x4 y4 z4
endloop
endfacet
facet normal nx2 ny2 nz2
outer loop
vertex x2 y2 z2
vertex x3 y3 z3
vertex x4 y4 z4
endloop
endfacet
endsolid plate

Wieviel Programmiererfahrung hast du denn? Hast du überhaupt schonmal ein Programm geschrieben, das mit Dateien arbeitet!?
Dass du C++ als "Programm" bezeichnest, würd ich mal als Zeichen dafür werten, dass du bei einer anderen Sprache besser aufgehoben wärst

<Ship Version="1.3">
<Material Grade="Default" Density="7840" YoungsModulus="206000" PoissonRatio="0.3" YieldStress="220" UltimateStress="360"/><Block ObjId="TRAIN0">
<Extent>
<Min X="-1.0000000000E000" Y="-1.0000000000E000" Z="-1.0000000000E000"/>
<Max X="1.0000000000E000" Y="1.0000000000E000" Z="1.0000000000E000"/>
</Extent>
<PlanePanel ObjId="TRAIN0-PLATE1" DataType="101" Instance="AsDefined"><Extent>
<Min X="7.9200000000E004" Y="2.5100000000E003" Z="1.4000000000E003"/>
<Max X="7.9212000000E004" Y="5.7100000000E003" Z="2.8000000000E003"/>
</Extent>
<CoordSys>
<Origin X="7.9200000000E004" Y="0.0000000000E000" Z="0.0000000000E000"/>
<Waxis X="1.0000000000E000" Y="0.0000000000E000" Z="0.0000000000E000"/>
<Uaxis X="0.0000000000E000" Y="1.0000000000E000" Z="0.0000000000E000"/></CoordSys>
<Boundary>
<Limit CompId="1">
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
</Limit>
<Limit CompId="2">
<StartPoint2d U="2.5100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit CompId="3">
<StartPoint2d U="5.7100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit CompId="4"><StartPoint2d U="5.7100000000E003" V="2.8000000000E003"/></Limit>
<SimpleContour>
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="2.8000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="2.8000000000E003"/>
</Segment2d>
</SimpleContour>
<DetailedContour>
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="2.8000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="2.8000000000E003"/>
</Segment2d>
</DetailedContour>
</Boundary>
<PlateGroup GroupId="4">
<Material Grade="Default">
<Thickness>12.0</Thickness>
</Material>
<MaterialSide>Forward</MaterialSide>
<Plate CompId="1">
<Limit>
<ModelRef ObjType="PlanePanel" ObjId="TRAIN0-PLATE1" CompType="Limit" CompId="1"/>
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
</Limit>
<Limit>
<ModelRef ObjType="PlanePanel" ObjId="TRAIN0-PLATE1" CompType="Limit" CompId="2"/>
<StartPoint2d U="2.5100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit>
<ModelRef ObjType="PlanePanel" ObjId="TRAIN0-PLATE1" CompType="Limit" CompId="3"/>
<StartPoint2d U="5.7100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit>
<ModelRef ObjType="PlanePanel" ObjId="TRAIN0-PLATE1" CompType="Limit" CompId="4"/>
<StartPoint2d U="5.7100000000E003" V="2.8000000000E003"/>
</Limit>
<SimpleContour>
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="2.8000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="2.8000000000E003"/>
</Segment2d>
</SimpleContour>
<DetailedContour>
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="1.4000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="5.7100000000E003" V="2.8000000000E003"/>
</Segment2d>
<Segment2d>
<Amplitude2d U="0.0000000000E000" V="0.0000000000E000"/>
<Node2d U="2.5100000000E003" V="2.8000000000E003"/>
</Segment2d>
</DetailedContour>
</Plate>
</PlateGroup>
</PlanePanel>
</Block>
</Ship>

hat etwas länger gedauert, dass alles ordentlich aufzuschreiben

Da du wohl sowieso noch nicht besonders viel Zeit in C++ investiert hast, würd ich davon eher abraten. Mit C# wirst du dein Ziel vermutlich sehr viel schneller und einfacher erreichen. Rein prinzipiell lässt sich dein Problem jedenfalls in jeder beliebigen general-purpose Programmiersprache lösen.

C# bekommst du hier: http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-csharp-express
Ein, dem Hörensagen nach, ganz brauchbares Buch gibts hier: http://openbook.galileocomputing.de/visual_csharp_2010/

Dann gehts so:
- XML File einlesen
- Die interne Repräsentation des XML Files (=DOM) prozessieren
- Daraus die STL Datei generieren

Wegen PugiXml. Ich schau mir das mal an.

=DOM prozessieren
Was meinst du damit? So zusagen die relevanten Daten rausfiltern und aufschreiben.

Auch wenn ich kein Idiot bin, aber schreibt es mir doch bitte Idiotensicher auf.

solid plate
facet normal nx1 ny1 nz1
outer loop
vertex x1 y1 z1
vertex x2 y2 z2
vertex x4 y4 z4
endloop
endfacet
facet normal nx2 ny2 nz2
outer loop
vertex x2 y2 z2
vertex x3 y3 z3
vertex x4 y4 z4
endloop
endfacet
endsolid plate

Wie sähe denn die dazugehörige XML Datei aus? Einen Zusammmenhang zu dem Beispiel das du gepostet hast, kann ich nicht erkennen.

Das wäre nämlich der erste Schritt: Überlege dir wie die generell von der XML Datei zur STL Datei kommen kannst. Wie wird z.B. ein vertex in der XML Datei repräsentiert? Wie ein outer loop ? Etc.

=DOM prozessieren
Was meinst du damit? So zusagen die relevanten Daten rausfiltern und aufschreiben.

XML Parser erzeugen ein DOM - eine baumartige Repräsentation deiner XML Datei (siehe hier). Und mit diesem DOM kannst du dann arbeiten, z.B. indem du in einer Schleife durch alle <Segment2d> Knoten iterierst. Dabei hilft dir dann die XML Bibliothek deiner Wahl, in die du dich dann wohl oder übel einarbeiten musst.

Ich würde auch mal meinen, dass ein DOM für das Problem hier nicht nötig ist. Ein einfacher XmlReader sollte imo völlig ausreichend sein.

Die Zuordnung von XML Elementen nach STL File habe ich geraten und liege wahrscheinlich daneben:

Es muss ein File Platte.xml mit dem XML Inhalt existieren, daraus wird eine Datei Platte.txt erzeugt.

#include <iostream>
#include <fstream>

#include "pugixml.hpp"

// STL file format (eg.)
// ==========================
// solid plate
// facet normal nx1 ny1 nz1
// outer loop
// vertex x1 y1 z1
// vertex x2 y2 z2
// vertex x4 y4 z4
// endloop
// endfacet
// facet normal nx2 ny2 nz2
// outer loop
// vertex x2 y2 z2
// vertex x3 y3 z3
// vertex x4 y4 z4
// endloop
// endfacet
// endsolid plate

int main()
{
    pugi::xml_document document;
    pugi::xml_parse_result result = document.load_file("Platte.xml");
    if (!result)
    {
        std::cerr << "Could not open XML file: " << result << std::endl;
        return 1;
    }

    std::ofstream output("Platte.txt");
    if (!output)
    {
        std::cerr << "Could not open STL file." << std::endl;
        return 1;
    }

    pugi::xml_node coordSysNode = document.select_single_node("Ship/Block/PlanePanel/CoordSys").node();

    pugi::xml_node originNode = coordSysNode.child("Origin");
    double originX = originNode.attribute("X").as_double();
    double originY = originNode.attribute("Y").as_double();
    double originZ = originNode.attribute("Z").as_double();
    output << "vertex " << originX << " " << originY << " " << originZ << std::endl;

    pugi::xml_node waxisNode = coordSysNode.child("Waxis");
    double waxisX = waxisNode.attribute("X").as_double();
    double waxisY = waxisNode.attribute("Y").as_double();
    double waxisZ = waxisNode.attribute("Z").as_double();
    output << "vertex " << waxisX << " " << waxisY << " " << waxisZ << std::endl;

    pugi::xml_node uaxisNode = coordSysNode.child("Uaxis");
    double uaxisX = uaxisNode.attribute("X").as_double();
    double uaxisY = uaxisNode.attribute("Y").as_double();
    double uaxisZ = uaxisNode.attribute("Z").as_double();
    output << "vertex " << uaxisX << " " << uaxisY << " " << uaxisZ << std::endl;

    return 0;
}

Edit:
Die 3 PugiXMml Files wären: pugiconfig.hpp, pugixml.hpp, pugixml.cpp

Anmerkung:
Im File Platte.txt steht anschliessend:

vertex 79200 0 0
vertex 1 0 0
vertex 0 1 0

Ich werd grad etwas überschlagen von Fragen und Antworten.
Das von theta werd ich erstmal probieren.

Wenn ansonsten C# so empfohlen wird, könnte ich es auch auf diese Weise versuchen. Erstmal danke.

Ich meld mich ansonsten später nochmal

das ding hat ja sogar bei mir funktioniert. Echt super. Muss mal sehn, dass ich den Code nun weiterschreibe, damit auch der Rest der Informationen gespeichert werden können.

Aber schonmal vielen Dank, natürlich auch an dot.

Schön Abend euch noch

Ich hätte noch zwei Fragen wegen meinem Thema

Und zwar ist meine XML-Datei Ebenenbasiert:

Also
-Ship
-Block
-PlanePanel
-Boundary
-Limit

Da es nun weiteres Limits gibt, in dem Punkte gespeichert sind, kann mir bitte jemand sagen, wie ich dem Programm sage, dass er das zweite, dritte, vierte Limit auswählen soll?

der Code von C++

pugi::xml_node coordSysNode2 = document.select_single_node("Ship/Block/PlanePanel/Boundary/Limit").node();

pugi::xml_node originNode2 = coordSysNode2.child("StartPoint2d");
double U = originNode2.attribute("U").as_double();
double V = originNode2.attribute("V").as_double();
output << "U/V " << U << " " << V << std::endl;

die XML-Datei

<Boundary>
<Limit CompId="1">
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
</Limit>
<Limit CompId="2">
<StartPoint2d U="2.5100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit CompId="3">
<StartPoint2d U="5.7100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit CompId="4"><StartPoint2d U="5.7100000000E003" V="2.8000000000E003"/>

hoffe, ihr könnt mir helfen.

select_nodes scheint das zu sein was du suchst.

Es dann auf meine Bedürfnisse umzuschreiben ist dann das geringste Problem

pugi::xpath_node_set tools = doc.select_nodes("/Profile/Tools/Tool[@AllowRemote='true' and @DeriveCaptionFrom='lastparam']");

std::cout << "Tools:";

for (pugi::xpath_node_set::const_iterator it = tools.begin(); it != tools.end(); ++it)
{
    pugi::xpath_node node = *it;
    std::cout << " " << node.node().attribute("Filename").value();
}

pugi::xpath_node build_tool = doc.select_single_node("//Tool[contains(Description, 'build system')]");

std::cout << "\nBuild tool: " << build_tool.node().attribute("Filename").value() << "\n";

Hier mal ein bisschen für dich umgeschrieben, damit klarer wird wie das mit deinem Problem zusammenhängt:

pugi::xpath_node_set tools = doc.select_nodes("Ship/Block/PlanePanel/Boundary/Limit");

for (pugi::xpath_node_set::const_iterator it = tools.begin(); it != tools.end(); ++it)
{
    pugi::xpath_node limit_node = *it;
    // Hier muss jetzt das hin, was du mit dem <Limit ...> Knoten (limit_node) machen möchtest. 
}

Erstmal danke an Comonad.
Ich sitz immernoch an meinem Programm fest.

Hab zur Zeit es hinbekommen, dass die Schleife nur bis zu einem bestimmten Punkt arbeitet, jedoch bekomm ich das einlesen der Punkte nicht hin.

Könnt ihr mir da vielleich auf die Sprünge helfen, was falsch ist?

das System sieht so aus (XML)

<Boundary>
<Limit CompId="1">
<StartPoint2d U="2.5100000000E003" V="2.8000000000E003"/>
</Limit>
<Limit CompId="2">
<StartPoint2d U="2.5100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit CompId="3">
<StartPoint2d U="5.7100000000E003" V="1.4000000000E003"/>
</Limit>
<Limit CompId="4"><StartPoint2d U="5.7100000000E003" V="2.8000000000E003"/>

der anfang lautet
----------------------------------------------------------------------------
pugi::xpath_node_set tools = document.select_nodes("Ship/Block/PlanePanel/Boundary/Limit/StartPoint2d");

for (pugi::xpath_node_set::const_iterator it = tools.begin(); it != tools.end(); ++it)
{
pugi::xpath_node limit_node = *it;
double U = tools.attribute("U").as_double();
output << "vertex " << U << std::endl;
}
----------------------------------------------------------------------------

oder

----------------------------------------------------------------------------
pugi::xpath_node_set tools = document.select_nodes("Ship/Block/PlanePanel/Boundary/Limit");

for (pugi::xpath_node_set::const_iterator it = tools.begin(); it != tools.end(); ++it)
{
pugi::xpath_node limit_node = *it;
pugi::xpath_node originNode2 = tools.child("StartPoint2d");
double U = originNode2.attribute("U").as_double();
output << "vertex " << U << std::endl;
}
----------------------------------------------------------------------------

ich weiß leider nicht genau, wie ich das definier muss, damit die Punkte eingelesen werden können.
Hoffe ihr könnt mir helfen

Ich komm gerade nicht weiter und hoffe, dass ihr mir einen Tipp geben könnt.

So sieht mein Code aus

cout << "\nX=: " << node.node().attribute("X").value();

und gibt mir aus
X=: 7.650000 E003
X=: 0.000000 E000
usw.

jedoch kann ich den Wert nicht vergleichen lassen.
so in etwa

if(node.node().attribute("X").value()>0)
{}

das funktiert leider nicht und ich hab auch schon versucht den Wert zu übergeben
int o;
o=*node.node().attribute("X").value();

leider auch ohne den gewünschten erfolg.

Kann mir mal bitte jemand sagen, wie ich das schreiben kann, damit ich den Wert richtig übergebe und somit vergleichen kann?

Danke schonmal im vorraus.

Ich hoffe ihr könnt mir mit eurer Erfahrung helfen.
Hab ein Programm geschrieben, dass Punkte aus einer Datei raussucht und in ein .txt file speichert.

Mein Problem ist nun, dass das Programm bis zu über 100 Punkte ordentlich macht und dann auf einmal Fehler macht, obwohl er immernoch das selbe macht.
Vllt hab ich ja einen Fehler bei der Definition der Variablen gemacht.
Weiß vielleicht einer von euch, woran das liegen könnte???

Ich kann euch auch den Code schreiben, aber ist halt etwas länger.
Danke schon mal