source: GTP/trunk/Lib/Vis/Preprocessing/src/X3dParser.cpp @ 1221

Revision 1221, 27.3 KB checked in by mattausch, 18 years ago (diff)

added intel ray tracing

Line 
1// ---------------------------------------------------------------------------
2//  Includes for all the program files to see
3// ---------------------------------------------------------------------------
4#include <string.h>
5#include <stdlib.h>
6#include <iostream>
7using namespace std;
8#include <xercesc/util/PlatformUtils.hpp>
9
10// ---------------------------------------------------------------------------
11//  Includes
12// ---------------------------------------------------------------------------
13#include <xercesc/framework/StdInInputSource.hpp>
14#include <xercesc/parsers/SAXParser.hpp>
15#include <xercesc/util/OutOfMemoryException.hpp>
16#include <xercesc/util/BinFileInputStream.hpp>
17// ---------------------------------------------------------------------------
18//  Includes
19// ---------------------------------------------------------------------------
20#include <xercesc/sax/AttributeList.hpp>
21#include <xercesc/sax/SAXParseException.hpp>
22#include <xercesc/sax/SAXException.hpp>
23
24#include "X3dParser.h"
25
26#include "X3dParserXerces.h"
27#include "Mesh.h"
28#include "SceneGraph.h"
29#include "Triangle3.h"
30#include "ViewCellsManager.h"
31#include "ResourceManager.h"
32#include <assert.h>
33
34namespace GtpVisibilityPreprocessor {
35
36float X3dParser::DEFAULT_VIEWCELL_HEIGHT = 5.0f;
37
38// ---------------------------------------------------------------------------
39//  Local data
40//
41//  doNamespaces
42//      Indicates whether namespace processing should be enabled or not.
43//      The default is no, but -n overrides that.
44//
45//  doSchema
46//      Indicates whether schema processing should be enabled or not.
47//      The default is no, but -s overrides that.
48//
49//  schemaFullChecking
50//      Indicates whether full schema constraint checking should be enabled or not.
51//      The default is no, but -s overrides that.
52//
53//  valScheme
54//      Indicates what validation scheme to use. It defaults to 'auto', but
55//      can be set via the -v= command.
56// ---------------------------------------------------------------------------
57static bool     doNamespaces       = false;
58static bool     doSchema           = false;
59static bool     schemaFullChecking = false;
60static SAXParser::ValSchemes    valScheme       = SAXParser::Val_Auto;
61
62#define ROTATE_SCENE 0
63
64static int sUniqueMeshIdx = 0;
65
66// hack: rotate mesh by n degrees
67static void RotateMesh(Mesh *mesh, const float angle)
68{
69        VertexContainer::iterator it, it_end = mesh->mVertices.end();
70
71        const float angleRad = angle * PI / 180.0f;
72        const Matrix4x4 rot = RotationYMatrix(angleRad);
73
74        for (it = mesh->mVertices.begin(); it != it_end; ++ it)
75        {
76                (*it) = rot * (*it);       
77        }
78}
79
80// ---------------------------------------------------------------------------
81//  StdInParseHandlers: Constructors and Destructor
82// ---------------------------------------------------------------------------
83X3dParseHandlers::X3dParseHandlers(SceneGraphNode *root,
84                                                                   const bool loadPolygonsAsMeshes):
85  mElementCount(0)
86  , mAttrCount(0)
87  , mCharacterCount(0)
88  , mSpaceCount(0)
89  , mLoadPolygonsAsMeshes(loadPolygonsAsMeshes)
90  , mCurrentMesh(NULL)
91{
92        mCurrentNode = root;
93
94        // this matrix should never be removed from stack
95        //mTransformations.push(IdentityMatrix());
96}
97
98X3dParseHandlers::~X3dParseHandlers()
99{
100        assert(mTransformations.empty());
101        if (0 && !mTransformations.empty())
102                cout << "error: transformation stack size: " << (int)mTransformations.size() << endl;
103}
104
105
106// ---------------------------------------------------------------------------
107//  StdInParseHandlers: Implementation of the SAX DocumentHandler interface
108// ---------------------------------------------------------------------------
109
110void X3dParseHandlers::endElement(const XMLCh* const name)
111{
112        StrX lname(name);
113        string element(lname.LocalForm());
114
115        // only create new mesh instance if define mechanism was not used
116        if (element == "Shape")
117                EndShape();
118
119        if (element == "Transform")
120                EndTransform();
121}
122
123
124void X3dParseHandlers::ApplyTransformations(TrafoStack trafos, Mesh *mesh) const
125{
126        while (!trafos.empty())
127        {
128                const Matrix4x4 m = trafos.top();
129                trafos.pop();
130
131                mesh->ApplyTransformation(m);
132        }
133}
134
135
136void X3dParseHandlers::ApplyTransformations(TrafoStack trafos,
137                                                                                        TransformedMeshInstance *mi) const
138{
139        while (!trafos.empty())
140        {
141                const Matrix4x4 m = trafos.top();
142                trafos.pop();
143
144                mi->ApplyWorldTransform(m);
145        }
146}
147
148
149void X3dParseHandlers::StartTransform(AttributeList&  attributes)
150{
151        Matrix4x4 currentTransform = IdentityMatrix();
152
153        const int len = attributes.getLength();
154
155    Matrix4x4 *rotm = NULL;
156        Matrix4x4 *scalem = NULL;
157        Matrix4x4 *translm = NULL;
158   
159        for (int i = 0; i < len; ++ i)
160        {
161                string attrName(StrX(attributes.getName(i)).LocalForm());
162                       
163                StrX attrValue(attributes.getValue(i));
164                const char *ptr = attrValue.LocalForm();
165                       
166                if (attrName == "rotation")
167                {
168                        Vector3 axis;
169                        float angle;
170                               
171                        if (sscanf(ptr, "%f %f %f %f", &axis.x, &axis.y, &axis.z, &angle) == 4)
172                        {
173                                rotm = new Matrix4x4(RotationAxisMatrix(axis, angle));
174                        }
175                }
176                else if (attrName == "translation")
177                {
178                        Vector3 transl;
179                                                       
180                        if (sscanf(ptr, "%f %f %f", &transl.x, &transl.y, &transl.z) == 3)
181                        {
182                                translm = new Matrix4x4(TranslationMatrix(transl));
183                        }
184                }
185                else if (attrName == "scale")
186                {
187                        Vector3 scale;
188
189                        if (sscanf(ptr, "%f %f %f", &scale.x, &scale.y, &scale.z) == 3)
190                        {
191                                scalem = new Matrix4x4(ScaleMatrix(scale.x, scale.y, scale.z));
192                        }
193                }
194                // todo: scale orientation
195        }
196       
197        if (scalem)
198                currentTransform *= (*scalem);
199        if (rotm)
200                currentTransform *= (*rotm);
201        if (translm)
202                currentTransform *= (*translm);
203
204        DEL_PTR(scalem);
205        DEL_PTR(rotm);
206        DEL_PTR(translm);
207
208        mTransformations.push(currentTransform);
209}
210
211
212void X3dParseHandlers::EndTransform()
213{
214        mTransformations.pop();
215}
216
217
218void X3dParseHandlers::EndShape()
219{
220         //-- if shape is merely a definition => don't create particular mesh instance
221         if (!mCurrentMesh || mIsMeshDefinition)
222         {
223                 return;
224         }
225
226         //-- each polygon is one single mesh
227         if (mLoadPolygonsAsMeshes)
228         {
229                 cout << "m";   
230                 FaceContainer::const_iterator fit, fit_end = mCurrentMesh->mFaces.end();
231               
232                 for (fit = mCurrentMesh->mFaces.begin(); fit != fit_end; ++ fit)
233                 {
234                         cout << "f";
235                         Face *face = *fit;
236               
237                         // we create a new mesh for each face from the current mesh
238                         Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
239                       
240                         VertexIndexContainer::const_iterator vit, vit_end = face->mVertexIndices.end();
241               
242                         int i = 0;
243                         // dummy vertex indices container
244                         VertexIndexContainer vcIndices;
245
246                         for (vit = face->mVertexIndices.begin(); vit != vit_end; ++ vit, ++ i)
247                         {
248                                 cout << "i";
249                                 const int index = (*vit);
250
251                                 // add vertices
252                                 mesh->mVertices.push_back(mCurrentMesh->mVertices[index]);
253
254                                 // indices don't make much sense if mesh == face,
255                                 // but we need them anyway ...
256                                 vcIndices.push_back(i);
257                         }
258
259                         mesh->mFaces.push_back(new Face(vcIndices));
260
261                         // write transformations directly in mesh
262                         // note: could be transformed in parent mesh, save some transformations
263                         ApplyTransformations(mTransformations, mesh);
264
265                         mesh->Preprocess();
266                               
267                         if (mesh->mFaces.empty())
268                         {
269                                 cout << "error: empy mesh" << endl;
270                         }
271                         else
272                         {
273                                 // make an instance of this mesh
274                                 MeshInstance *mi = new MeshInstance(mesh);
275                                 mCurrentNode->mGeometry.push_back(mi);
276
277                                 if (mCurrentMaterial)
278                                 {
279                                         // HACK: add the material to the mesh directly if no material yet
280                                         if (!mCurrentMesh->mMaterial)
281                                                 mCurrentMesh->mMaterial = mCurrentMaterial;
282                                 }
283                         }
284                 }
285
286                 // this mesh is not needed, unless it is used as a definition
287                 if (!mUsingMeshDefinition)
288                 {
289                         MeshManager::GetSingleton()->DestroyEntry(mCurrentMesh->GetId());
290                 }
291        }
292        else // default usage: create a mesh instance from the current mesh
293        {
294                MeshInstance *mi;
295
296                if (!mUsingMeshDefinition)
297                {
298                        // make an instance of this mesh
299                        mi = new MeshInstance(mCurrentMesh);
300
301                        // this mesh is used only once => write transformations directly into it
302                        ApplyTransformations(mTransformations, mCurrentMesh);
303                }
304                else
305                {
306                         // make an instance of this mesh
307                        TransformedMeshInstance *tmi = new TransformedMeshInstance(mCurrentMesh);
308
309                         // apply transformation on the instance of the mesh
310                         ApplyTransformations(mTransformations, tmi);
311                         mi = tmi;
312                }
313                       
314                if (mCurrentMaterial)
315                {
316                        // HACK: add the material to the mesh directly if no material yet
317                        if (!mCurrentMesh->mMaterial)
318                        {
319                                mCurrentMesh->mMaterial = mCurrentMaterial;
320                        }
321                        else // add material to the instance
322                        {
323                                mi->SetMaterial(mCurrentMaterial);
324                        }
325                }
326               
327                // create local mesh kd tree
328                mCurrentMesh->Preprocess();
329
330                if (mCurrentMesh->mFaces.empty())
331                {
332                        cout << "warning: empy mesh!!" << endl;
333                        delete mi;
334                }
335                else
336                {
337                        // add to scene graph
338                        mCurrentNode->mGeometry.push_back(mi);
339                }
340
341                // reset current mesh
342                mCurrentMesh = NULL;
343        }
344}
345
346
347void X3dParseHandlers::StartIndexedFaceSet(AttributeList&  attributes)
348{
349        //-- indexedfaceset corresponds  to Mesh in our implementation
350        const int len = attributes.getLength();
351
352        VertexIndexContainer vertices;
353 
354        mIsMeshDefinition = false;
355        mUsingMeshDefinition = false;
356
357        for (int i = 0; i < len; ++ i)
358        {
359                const string attrName(StrX(attributes.getName(i)).LocalForm());
360       
361                //-- we use an already defined mesh
362                if (attrName == "USE")
363                {
364                        StrX attrValue(attributes.getValue(i));
365                        const char *meshName = attrValue.LocalForm();
366
367                        mUsingMeshDefinition = true;
368
369            // retrieve mesh from mesh container
370                        const int meshIdx = mMeshDefinitions[meshName];
371
372                        mCurrentMesh =
373                                MeshManager::GetSingleton()->FindEntry(meshIdx);
374
375                        //Debug << "retrieving mesh definition: " << mCurrentMeshName << endl;
376                        cout << "u";
377                }
378                else if (attrName == "DEF") //-- a definition of a mesh
379                {
380                        const StrX attrValue(attributes.getValue(i));
381                        const char *meshName = attrValue.LocalForm();
382
383                        // this is only a definition, don't create actual  instance
384                        mIsMeshDefinition = true;
385                       
386                        //-- create new mesh definition
387                        mCurrentMesh = MeshManager::GetSingleton()->CreateResource();
388                       
389                        // store the mesh defination in a lookup table
390                        mMeshDefinitions[meshName] = mCurrentMesh->GetId();
391                        cout << "d";
392                }
393               
394                //-- read coordinate indices for current mesh
395                else if (attrName == "coordIndex")
396                {
397                        StrX attrValue(attributes.getValue(i));
398                        const char *ptr = attrValue.LocalForm();
399
400                        //-- immediate use: create a new mesh using a generic name
401                        if (!mCurrentMesh)
402                        {
403                                mCurrentMesh = MeshManager::GetSingleton()->CreateResource();
404                        }
405
406                        // handle coordIndex
407                        vertices.clear();
408                       
409                 
410                        char *endptr;
411         
412                        while (1)
413                        {
414                                int index = strtol(ptr, &endptr, 10);
415                                 
416                                if (ptr == endptr || index == -1)
417                                {
418                                        if (vertices.size() > 2)
419                                        {
420                                                Face *face = new Face(vertices);                 
421                                                mCurrentMesh->mFaces.push_back(face);
422                                        }
423                         
424                                        vertices.clear();
425                 
426                                        if (ptr == endptr)
427                                                break;
428                         
429                                  }
430                                  else
431                                  {
432                                          vertices.push_back(index);
433                                  }
434                                  ptr = endptr;
435                        }
436                }
437        }
438}
439
440
441void
442X3dParseHandlers::StartMaterial(AttributeList&  attributes)
443{
444        const int len = attributes.getLength();
445               
446        mCurrentMaterial = MaterialManager::GetSingleton()->CreateResource();
447 
448        for (int i = 0; i < len; ++ i)
449        {
450                const string attrName(StrX(attributes.getName(i)).LocalForm());
451               
452                const StrX attrValue(attributes.getValue(i));
453                const char *ptr = attrValue.LocalForm();
454
455
456                //-- we use an already defined material
457                if (attrName == "USE")
458                {
459                        //mUsingMaterialDefinition = true;
460                        string matName(ptr);
461
462            // retrieve mesh from mesh container
463                        const int matIdx = mMaterialDefinitions[matName];
464
465                        mCurrentMaterial =
466                                MaterialManager::GetSingleton()->FindEntry(matIdx);
467
468                        //Debug << "retrieving mesh definition: " << mCurrentMeshName << endl;
469                        cout << "u";
470                }
471                else if (attrName == "DEF") //-- a definition of a material
472                {
473                        //mIsMaterialDefinition = true;
474                        string matName(ptr);
475               
476                        //-- create new material definition
477                        mCurrentMaterial = MaterialManager::GetSingleton()->CreateResource();
478                        // store the mesh defination in a lookup table
479                        mMaterialDefinitions[matName] = mCurrentMaterial->GetId();
480                        cout << "d";
481                }
482                // TODO: support not only diffuse material
483                else if (attrName == "diffuseColor")
484                {
485                        float r, g, b;
486     
487                        if (sscanf(ptr, "%f %f %f", &r, &g, &b) == 3)
488                                mCurrentMaterial->mDiffuseColor = RgbColor(r, g, b);
489                }
490        }
491}
492
493
494void
495X3dParseHandlers::StartCoordinate(AttributeList&  attributes)
496{
497        const int len = attributes.getLength();
498       
499        int i;
500        VertexContainer vertices;
501       
502        for (i=0; i < len; i++)
503        {
504                const string attrName(StrX(attributes.getName(i)).LocalForm());
505         
506                if (attrName == "point")
507                {
508                        StrX attrValue(attributes.getValue(i));
509                 
510
511                        const char *ptr = attrValue.LocalForm();
512                        char *endptr;
513
514
515                        while (1)
516                        {
517                                float x = (float)strtod(ptr, &endptr);
518               
519                                if (ptr == endptr)
520                                  break;
521                         
522                                ptr = endptr;
523                               
524                                float y = (float)strtod(ptr, &endptr);
525                         
526                                if (ptr == endptr)
527                                        break;
528
529                                ptr = endptr;
530                         
531                                float z = (float)strtod(ptr, &endptr);
532                                if (ptr == endptr)
533                                        break;
534                         
535                                ptr = endptr;
536                         
537                                if (*ptr == ',')
538                                        ptr ++;
539
540                                Vector3 v(x, y, z);
541                                vertices.push_back(v);
542                        }
543       
544                        // substitute vertices into current mesh
545                        mCurrentMesh->mVertices = vertices;
546                }
547        }
548}
549
550
551void
552X3dParseHandlers::startElement(const XMLCh* const name,
553                                                           AttributeList&  attributes)
554{
555  StrX lname(name);
556  string element(lname.LocalForm());
557 
558  if (element == "IndexedFaceSet") {
559          // create a new mesh node in the scene graph
560          StartIndexedFaceSet(attributes);
561  }
562 
563  if (element == "Shape") {
564          cout << "+";
565
566          // reset current shape values
567          mCurrentMesh = NULL;
568          mCurrentMaterial = NULL;
569          mCurrentVertexIndices.clear();
570          //mCurrentVertices.clear();
571  }
572 
573  if (element == "Coordinate") {
574          StartCoordinate(attributes);
575  }
576
577  // todo
578  if (element == "Material") {
579          StartMaterial(attributes);
580  }
581 
582  if (element == "Transform") {
583          StartTransform(attributes);
584  }
585
586  ++ mElementCount;
587  mAttrCount += attributes.getLength();
588}
589
590void
591X3dParseHandlers::characters(const XMLCh* const chars,
592                                                         const unsigned int length)
593{
594  mCharacterCount += length;
595}
596
597void
598X3dParseHandlers::ignorableWhitespace(const XMLCh* const chars,
599                                                                          const unsigned int length)
600{
601  mSpaceCount += length;
602}
603
604void
605X3dParseHandlers::resetDocument()
606{
607  mAttrCount = 0;
608  mCharacterCount = 0;
609  mElementCount = 0;
610  mSpaceCount = 0;
611}
612
613
614// ---------------------------------------------------------------------------
615//  StdInParseHandlers: Overrides of the SAX ErrorHandler interface
616// ---------------------------------------------------------------------------
617
618
619void
620X3dParseHandlers::error(const SAXParseException& e)
621{
622  XERCES_STD_QUALIFIER cerr << "\nError at (file " << StrX(e.getSystemId())
623                            << ", line " << e.getLineNumber()
624                            << ", char " << e.getColumnNumber()
625                            << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
626}
627
628void
629X3dParseHandlers::fatalError(const SAXParseException& e)
630{
631  XERCES_STD_QUALIFIER cerr << "\nFatal Error at (file " << StrX(e.getSystemId())
632                            << ", line " << e.getLineNumber()
633                            << ", char " << e.getColumnNumber()
634                            << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
635}
636
637void
638X3dParseHandlers::warning(const SAXParseException& e)
639{
640  XERCES_STD_QUALIFIER cerr << "\nWarning at (file " << StrX(e.getSystemId())
641                            << ", line " << e.getLineNumber()
642                            << ", char " << e.getColumnNumber()
643                            << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
644}
645
646/*************************************************************************/
647/*                     X3dParser implementation                          */
648/*******************+*****************************************************/
649
650X3dParser::X3dParser():
651mViewCellHeight(DEFAULT_VIEWCELL_HEIGHT)
652{}
653
654bool
655X3dParser::ParseFile(const string filename,
656                                         SceneGraphNode **root,
657                                         const bool loadPolygonsAsMeshes,
658                                         vector<Intersectable *> *parents)
659{
660  // Initialize the XML4C system
661  try {
662    XMLPlatformUtils::Initialize();
663  }
664 
665  catch (const XMLException& toCatch)
666    {
667      XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
668                                << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
669      return false;
670    }
671 
672 
673  //
674  //  Create a SAX parser object. Then, according to what we were told on
675  //  the command line, set the options.
676  //
677  SAXParser* parser = new SAXParser;
678  parser->setValidationScheme(valScheme);
679  parser->setDoNamespaces(doNamespaces);
680  parser->setDoSchema(doSchema);
681  parser->setValidationSchemaFullChecking(schemaFullChecking);
682 
683
684  //
685  //  Create our SAX handler object and install it on the parser, as the
686  //  document and error handler. We are responsible for cleaning them
687  //  up, but since its just stack based here, there's nothing special
688  //  to do.
689  //
690  *root = new SceneGraphNode;
691  X3dParseHandlers handler(*root, loadPolygonsAsMeshes);
692  parser->setDocumentHandler(&handler);
693  parser->setErrorHandler(&handler);
694 
695  unsigned long duration;
696  int errorCount = 0;
697  // create a faux scope so that 'src' destructor is called before
698  // XMLPlatformUtils::Terminate
699  {
700    //
701    //  Kick off the parse and catch any exceptions. Create a standard
702    //  input input source and tell the parser to parse from that.
703    //
704    //    StdInInputSource src;
705    try
706      {
707        const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
708        parser->parse(filename.c_str());
709       
710        const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
711        duration = endMillis - startMillis;
712        errorCount = parser->getErrorCount();
713      }
714    catch (const OutOfMemoryException&)
715      {
716        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
717        errorCount = 2;
718        return false;
719      }
720    catch (const XMLException& e)
721      {
722        XERCES_STD_QUALIFIER cerr << "\nError during parsing: \n"
723                                  << StrX(e.getMessage())
724                                  << "\n" << XERCES_STD_QUALIFIER endl;
725        errorCount = 1;
726        return false;
727      }
728
729   
730    // Print out the stats that we collected and time taken
731    if (!errorCount) {
732      XERCES_STD_QUALIFIER cout << filename << ": " << duration << " ms ("
733                                << handler.GetElementCount() << " elems, "
734                                << handler.GetAttrCount() << " attrs, "
735                                << handler.GetSpaceCount() << " spaces, "
736                                << handler.GetCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
737    }
738  }
739 
740  //
741  //  Delete the parser itself.  Must be done prior to calling Terminate, below.
742  //
743  delete parser;
744 
745  XMLPlatformUtils::Terminate();
746 
747  if (errorCount > 0)
748    return false;
749  else
750    return true;
751}
752
753
754
755/************************************************************************/
756/*             class X3dViewCellsParseHandlers implementation           */
757/************************************************************************/
758
759
760// ---------------------------------------------------------------------------
761//  StdInParseHandlers: Constructors and Destructor
762// ---------------------------------------------------------------------------
763X3dViewCellsParseHandlers::X3dViewCellsParseHandlers(ViewCellsManager *viewCellsManager,
764                                                                                                         const float viewCellHeight):
765mElementCount(0),
766mAttrCount(0),
767mCharacterCount(0),
768mSpaceCount(0),
769mViewCellsManager(viewCellsManager),
770mViewCellHeight(viewCellHeight)
771{
772}
773
774X3dViewCellsParseHandlers::~X3dViewCellsParseHandlers()
775{
776}
777
778
779// ---------------------------------------------------------------------------
780//  StdInParseHandlers: Implementation of the SAX DocumentHandler interface
781// ---------------------------------------------------------------------------
782void X3dViewCellsParseHandlers::endElement(const XMLCh* const name)
783{
784        StrX lname(name);
785
786        string element(lname.LocalForm());
787
788        if (element == "Shape")
789                EndShape();
790}
791
792void
793X3dViewCellsParseHandlers::EndShape()
794{
795        // currently processing no shape
796}
797
798void
799X3dViewCellsParseHandlers::StartIndexedFaceSet(
800                                      AttributeList&  attributes)
801{
802        int len = attributes.getLength();
803        int i;
804       
805        for (i=0; i < len; i++)
806        {
807                string attrName(StrX(attributes.getName(i)).LocalForm());
808           
809
810                if (attrName == "coordIndex")
811                {
812                        StrX attrValue(attributes.getValue(i));
813                       
814                        // handle coordIndex
815                        const char *ptr = attrValue.LocalForm();
816                        char *endptr;
817               
818                        while (1)
819                        {
820                                int index = strtol(ptr, &endptr, 10);
821                               
822                                if (ptr == endptr)
823                                        break;
824
825                                if (index != -1)
826                                {
827                                        mCurrentVertexIndices.push_back(index);
828                                }
829                   
830                                ptr = endptr;
831                        }
832                }
833        }
834}
835
836
837void
838X3dViewCellsParseHandlers::StartCoordinate(AttributeList&  attributes)
839{
840        int len = attributes.getLength();
841       
842        VertexContainer vertices;
843        int i;
844        for (i=0; i < len; i++)
845        {
846                string attrName(StrX(attributes.getName(i)).LocalForm());
847               
848                if (attrName == "point")
849                {
850                        StrX attrValue(attributes.getValue(i));
851                       
852                        const char *ptr = attrValue.LocalForm();
853                       
854                        char *endptr;
855                       
856                        while (1)
857                        {
858                                float x = (float)strtod(ptr, &endptr);
859               
860                                if (ptr == endptr)
861                                        break;
862                                ptr = endptr;
863                               
864                                float y = (float)(float)strtod(ptr, &endptr);
865
866                               
867                                if (ptr == endptr)
868                                        break;
869                                ptr = endptr;
870
871                                float z = (float)(float)strtod(ptr, &endptr);
872
873                                if (ptr == endptr)
874                                        break;
875
876                                ptr = endptr;
877                                if (*ptr == ',')
878                                        ptr++;
879
880                                Vector3 v(x, y, z);
881                                vertices.push_back(v);                         
882                        }
883                }
884        }
885
886        for (i = 0; i < mCurrentVertexIndices.size(); i += 3)
887        {
888                Triangle3 baseTri(vertices[mCurrentVertexIndices[i + 0]],
889                                                  vertices[mCurrentVertexIndices[i + 1]],
890                                                  vertices[mCurrentVertexIndices[i + 2]]);
891
892                // create view cell from base triangle
893                mViewCellsManager->AddViewCell(
894                        mViewCellsManager->ExtrudeViewCell(baseTri,
895                        mViewCellHeight));
896        }
897}
898
899
900void
901X3dViewCellsParseHandlers::startElement(const XMLCh* const name,
902                                                                                AttributeList&  attributes)
903{
904  StrX lname(name);
905  string element(lname.LocalForm());
906 
907  if (element == "IndexedFaceSet") {
908    // create the viewcells from individual triangles
909    StartIndexedFaceSet(attributes);
910  }
911       
912  if (element == "Coordinate") {
913          // add coordinates to the triangles
914      StartCoordinate(attributes);
915  }
916  // do nothing
917  //if (element == "Shape") {}
918  // ignore material
919  //if (element == "Material") {}
920
921  ++ mElementCount;
922  mAttrCount += attributes.getLength();
923}
924
925void
926X3dViewCellsParseHandlers::characters(const XMLCh* const chars,
927                             const unsigned int length)
928{
929  mCharacterCount += length;
930}
931
932void
933X3dViewCellsParseHandlers::ignorableWhitespace(const XMLCh* const chars,
934                                      const unsigned int length)
935{
936  mSpaceCount += length;
937}
938
939void
940X3dViewCellsParseHandlers::resetDocument()
941{
942  mAttrCount = 0;
943  mCharacterCount = 0;
944  mElementCount = 0;
945  mSpaceCount = 0;
946}
947
948
949
950// ---------------------------------------------------------------------------
951//  StdInParseHandlers: Overrides of the SAX ErrorHandler interface
952// ---------------------------------------------------------------------------
953void
954X3dViewCellsParseHandlers::error(const SAXParseException& e)
955{
956  XERCES_STD_QUALIFIER cerr << "\nError at (file " << StrX(e.getSystemId())
957                            << ", line " << e.getLineNumber()
958                            << ", char " << e.getColumnNumber()
959                            << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
960}
961
962void
963X3dViewCellsParseHandlers::fatalError(const SAXParseException& e)
964{
965  XERCES_STD_QUALIFIER cerr << "\nFatal Error at (file " << StrX(e.getSystemId())
966                            << ", line " << e.getLineNumber()
967                            << ", char " << e.getColumnNumber()
968                            << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
969}
970
971void
972X3dViewCellsParseHandlers::warning(const SAXParseException& e)
973{
974  XERCES_STD_QUALIFIER cerr << "\nWarning at (file " << StrX(e.getSystemId())
975                            << ", line " << e.getLineNumber()
976                            << ", char " << e.getColumnNumber()
977                            << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
978}
979
980
981bool
982X3dParser::ParseFile(const string filename, ViewCellsManager &viewCells)
983{
984  // Initialize the XML4C system
985  try {
986    XMLPlatformUtils::Initialize();
987  }
988 
989  catch (const XMLException& toCatch)
990    {
991      XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
992                                << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
993      return false;
994    }
995 
996 
997  //
998  //  Create a SAX parser object. Then, according to what we were told on
999  //  the command line, set the options.
1000  //
1001  SAXParser* parser = new SAXParser;
1002  parser->setValidationScheme(valScheme);
1003  parser->setDoNamespaces(doNamespaces);
1004  parser->setDoSchema(doSchema);
1005  parser->setValidationSchemaFullChecking(schemaFullChecking);
1006 
1007
1008  //
1009  //  Create our SAX handler object and install it on the parser, as the
1010  //  document and error handler. We are responsible for cleaning them
1011  //  up, but since its just stack based here, there's nothing special
1012  //  to do.
1013  //
1014  X3dViewCellsParseHandlers handler(&viewCells, mViewCellHeight);
1015  parser->setDocumentHandler(&handler);
1016  parser->setErrorHandler(&handler);
1017 
1018  unsigned long duration;
1019  int errorCount = 0;
1020  // create a faux scope so that 'src' destructor is called before
1021  // XMLPlatformUtils::Terminate
1022  {
1023    //
1024    //  Kick off the parse and catch any exceptions. Create a standard
1025    //  input input source and tell the parser to parse from that.
1026    //
1027    //    StdInInputSource src;
1028    try
1029      {
1030        const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
1031        //GzBinFileInputStream str(filename.c_str());
1032       
1033        parser->parse(filename.c_str());
1034        const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
1035        duration = endMillis - startMillis;
1036        errorCount = parser->getErrorCount();
1037      }
1038    catch (const OutOfMemoryException&)
1039      {
1040        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
1041        errorCount = 2;
1042        return false;
1043      }
1044    catch (const XMLException& e)
1045      {
1046        XERCES_STD_QUALIFIER cerr << "\nError during parsing: \n"
1047                                  << StrX(e.getMessage())
1048                                  << "\n" << XERCES_STD_QUALIFIER endl;
1049        errorCount = 1;
1050        return false;
1051      }
1052
1053   
1054    // Print out the stats that we collected and time taken
1055    if (!errorCount) {
1056      XERCES_STD_QUALIFIER cout << filename << ": " << duration << " ms ("
1057                                << handler.GetElementCount() << " elems, "
1058                                << handler.GetAttrCount() << " attrs, "
1059                                << handler.GetSpaceCount() << " spaces, "
1060                                << handler.GetCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
1061    }
1062  }
1063 
1064  //
1065  //  Delete the parser itself.  Must be done prior to calling Terminate, below.
1066  //
1067  delete parser;
1068 
1069  XMLPlatformUtils::Terminate();
1070 
1071  if (errorCount > 0)
1072    return false;
1073  else
1074    return true;
1075}
1076
1077
1078
1079
1080}
Note: See TracBrowser for help on using the repository browser.