VRUT::RDFWriter Class Reference

Class for writing RDF files. More...

#include <rdfwriter.h>

List of all members.

Public Member Functions

 RDFWriter (wxBufferedOutputStream *_outputStream, const Scene *_scene)
 ~RDFWriter ()
 Class destructor.
void Write ()
 Write RDF stream.

Private Attributes

wxOutputStream * outputStream
 Input stream.
const Scene * scene
 Scene container to be built.

Detailed Description

Class for writing RDF files.

Definition at line 22 of file rdfwriter.h.

Constructor & Destructor Documentation

RDFWriter::RDFWriter ( wxBufferedOutputStream *  _outputStream,
const Scene *  _scene 
)

Class constructor

Parameters:
[in] _outputStream Stream to read data from
[in] _scene Scene to asve

Definition at line 19 of file rdfwriter.cpp.

00019                                                                                  : outputStream(_outputStream), scene(_scene)
00020 {
00021 }

RDFWriter::~RDFWriter (  ) 

Class destructor.

Is called by wxWidgets itself on wxApp end but it doesn't work in dynamic library

Definition at line 23 of file rdfwriter.cpp.

00024 {
00026 }

Member Function Documentation

void RDFWriter::Write (  ) 

Write RDF stream.

Definition at line 28 of file rdfwriter.cpp.

00029 {
00030        TextWriter textWriter((wxBufferedOutputStream *)outputStream);
00031        //write header
00032        textWriter.Write("$---------------------------------------------------------------------MDI_HEADER\r\n");
00033        textWriter.Write("[MDI_HEADER]\r\n");
00034        textWriter.Write("FILE_TYPE  =  'rdf'\r\n");
00035        textWriter.Write("FILE_VERSION  =  5.00\r\n");
00036        textWriter.Write("FILE_FORMAT  =  'ASCII'\r\n");
00037        textWriter.Write("(COMMENTS)\r\n");
00038        textWriter.Write("{comment_string)\r\n");
00039        textWriter.Write("'")->Write(scene->GetName())->Write("'\r\n");
00040        textWriter.Write("$--------------------------------------------------------------------------units\r\n");
00041        textWriter.Write("[UNITS]\r\n");
00042        textWriter.Write(" LENGTH             = 'mm'\r\n");
00043        textWriter.Write(" FORCE              = 'newton'\r\n");
00044        textWriter.Write(" ANGLE              = 'radians'\r\n");
00045        textWriter.Write(" MASS               = 'kg'\r\n");
00046        textWriter.Write(" TIME               = 'sec'\r\n");
00047        textWriter.Write("$---------------------------------------------------------------------definition\r\n");
00048        textWriter.Write("[MODEL]\r\n");
00049        textWriter.Write(" METHOD             = '3D'\r\n");
00050        textWriter.Write(" FUNCTION_NAME      = 'ARC904'\r\n");
00051        textWriter.Write("$-------------------------------------------------------------------------offset\r\n");
00052        textWriter.Write("[OFFSET]\r\n");
00053        textWriter.Write(" X                  =  0.0\r\n");
00054        textWriter.Write(" y                  =  0.0\r\n");
00055        textWriter.Write(" Z                  =  0.0\r\n");
00056        textWriter.Write("$--------------------------------------------------------------------------nodes\r\n");
00057 
00058        std::vector<NODE_ID> nodes;
00059        scene->GetNodeIDs(&nodes);
00060 
00061        //write nodes
00062        textWriter.Write("[NODES]\r\n");
00063        //compute vertices count and elements count
00064        size_t vertsCount=0, elementsCount=0;
00065        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00066        {
00067               const SceneNode * node = scene->GetNode(*nodeIt);
00068               if (!node || !node->IsOfType(SceneNode::GEOMETRY))
00069                      continue;
00070               scene->UpdateTransformation(*nodeIt);
00071 
00072               const Geometry * geom = scene->GetGeometry(((const GeometryNode *)node)->GetGeometryID());
00073               if (geom && geom->type == Geometry::GEOMETRY_TRIANGLE)
00074               {
00075                      GeometryTriangles *geoTri = ((GeometryTriangles *)geom);
00076                      vertsCount+=geoTri->vertices.size();
00077                      for (size_t j=0; j<geoTri->triDescList.size(); j++)
00078                      {
00079                             long count = long(((j+1<geoTri->triDescList.size())?geoTri->triDescList.at(j+1).first:geoTri->indices.size()) - geoTri->triDescList.at(j).first);
00080                             switch (geoTri->triDescList.at(j).second)
00081                             {
00082                             case GeometryTriangles::TRI_LIST:
00083                                    elementsCount+=count/3;
00084                                    break;
00085                             case GeometryTriangles::TRI_FAN:
00086                             case GeometryTriangles::TRI_STRIP:
00087                             case GeometryTriangles::POLYGON:
00088                                    elementsCount+=count-2;
00089                                    break;
00090                             case GeometryTriangles::LINES:
00091                             case GeometryTriangles::LINE_STRIP:
00092                             case GeometryTriangles::POINTS:
00093                                    break;
00094                             case GeometryTriangles::QUADS:
00095                                    elementsCount+=count/2;
00096                                    break;
00097                             }
00098                      }
00099               }
00100        }
00101        textWriter.Write(" NUMBER_OF_NODES    = ")->Write((long)vertsCount)->Write("\r\n");
00102        //write vertices
00103        size_t vertIndex=1;
00104        textWriter.Write("{ node   x_value   y_value   z_value }\r\n");
00105        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00106        {
00107               const SceneNode * node = scene->GetNode(*nodeIt);
00108               if (!node || !node->IsOfType(SceneNode::GEOMETRY))
00109                      continue;
00110               scene->UpdateTransformation(*nodeIt);
00111 
00112               const Geometry * geom = scene->GetGeometry(((const GeometryNode *)node)->GetGeometryID());
00113               if (geom && geom->type == Geometry::GEOMETRY_TRIANGLE)
00114               {
00115                      const std::vector<VECTOR3> * vertices = &((GeometryTriangles *)geom)->vertices;
00116                      MATRIX transf(*node->GetWorldTransMatrix());
00117                      for (size_t i=0; i<vertices->size(); i++)
00118                      {
00119                             vector3 transformed(transf.TransformCoord(vertices->at(i)));
00120                             textWriter.Write((long)vertIndex++)->Write("\t")->Write(transformed._v, 3, "\t")->Write("\r\n");
00121                      }
00122               }
00123        }
00124 
00125        //write elements
00126        textWriter.Write("\r\n")->Write("\r\n");
00127        textWriter.Write("$----------------------------------------------------------------------elements\r\n");
00128        textWriter.Write("[ELEMENTS]\r\n");
00129        textWriter.Write(" NUMBER_OF_ELEMENTS    = ")->Write((long)elementsCount)->Write("\r\n");
00130        textWriter.Write("{ node_1   node_2  node_3   mu   }\r\n");
00131        size_t geometryOffset=0;
00132 
00133        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00134        {
00135               const SceneNode * node = scene->GetNode(*nodeIt);
00136               if (!node || !node->IsOfType(SceneNode::GEOMETRY))
00137                      continue;
00138               scene->UpdateTransformation(*nodeIt);
00139 
00140               const Geometry * geom = scene->GetGeometry(((const GeometryNode *)node)->GetGeometryID());
00141               if (geom && geom->type == Geometry::GEOMETRY_TRIANGLE)
00142               {
00143                      GeometryTriangles *geoTri = ((GeometryTriangles *)geom);
00144                      elementsCount=0;
00145                      for (size_t j=0; j<geoTri->triDescList.size(); j++)
00146                      {
00147                             long count = long(((j+1<geoTri->triDescList.size())?geoTri->triDescList.at(j+1).first:geoTri->indices.size()) - geoTri->triDescList.at(j).first);
00148                             size_t first = geoTri->triDescList.at(j).first;
00149                             switch (geoTri->triDescList.at(j).second)
00150                             {
00151                             case GeometryTriangles::TRI_LIST:
00152                                    {
00153                                           for (size_t i=0; i<count; i++)
00154                                           {
00155                                                  textWriter.Write((long)(geoTri->indices.at(first+i)+1+geometryOffset))->Write("\t");
00156                                                  textWriter.Write((long)(geoTri->indices.at(first+i+1)+1+geometryOffset))->Write("\t");
00157                                                  textWriter.Write((long)(geoTri->indices.at(first+i+2)+1+geometryOffset))->Write("\t1\t\r\n");
00158                                                  i+=2;
00159                                           }
00160                                    }
00161                                    break;
00162                             case GeometryTriangles::TRI_FAN:
00163                             case GeometryTriangles::TRI_STRIP:
00164                             case GeometryTriangles::POLYGON:
00165                             case GeometryTriangles::LINES:
00166                             case GeometryTriangles::LINE_STRIP:
00167                             case GeometryTriangles::POINTS:
00168                                    LOGERROR(wxT("<RDFWriter>Not supported geometry type."));
00169                                    break;
00170                             case GeometryTriangles::QUADS:
00171                                    {
00172                                           for (size_t i=0; i<count; i++)
00173                                           {
00174                                                  textWriter.Write((long)(geoTri->indices.at(first+i)+1+geometryOffset))->Write("\t");
00175                                                  textWriter.Write((long)(geoTri->indices.at(first+i+1)+1+geometryOffset))->Write("\t");
00176                                                  textWriter.Write((long)(geoTri->indices.at(first+i+2)+1+geometryOffset))->Write("\t1\t\r\n");
00177                                                  textWriter.Write((long)(geoTri->indices.at(first+i)+1+geometryOffset))->Write("\t");
00178                                                  textWriter.Write((long)(geoTri->indices.at(first+i+2)+1+geometryOffset))->Write("\t");
00179                                                  textWriter.Write((long)(geoTri->indices.at(first+i+3)+1+geometryOffset))->Write("\t1\t\r\n");
00180                                                  i+=3;
00181                                           }
00182                                    }
00183                                    break;
00184                             }
00185                      }
00186                      geometryOffset+=geoTri->vertices.size();
00187               }
00188        }
00189 }

Member Data Documentation

wxOutputStream* VRUT::RDFWriter::outputStream [private]

Input stream.

Definition at line 26 of file rdfwriter.h.

const Scene* VRUT::RDFWriter::scene [private]

Scene container to be built.

Definition at line 28 of file rdfwriter.h.

The documentation for this class was generated from the following files:
Generated on Tue Mar 10 14:41:40 2009 for VRUT by  doxygen 1.5.5