Main Page   Namespace List   Alphabetical List   Compound List   File List   Compound Members   File Members  

Model Class Reference

model represents Inventor and RAPID model More...

#include <model.h>

List of all members.

Public Member Functions

 Model (const char *filename)
 read new model from file

 ~Model ()
 destructor

SoSeparator * getModel ()
 return Inventor model with 3D data

SoSeparator * getRootModel ()
 return Inventor root model (children: model, node, material node)

SoMaterial * getMaterial ()
 return Inventor material node

RAPID_model * getRAPIDModel ()
 return RAPID model


Public Attributes

RAPID_model * rapidModel
 RAPID collision detection model.


Private Attributes

SoSeparator * model
 Open Inventor model.

SoSeparator * rootModel
 Open Inventor model root (children: model node, material node).

SoMaterial * material
 Open Inventor material node.


Detailed Description

model represents Inventor and RAPID model

This class represents the OpenInventor and the RAPID model used for collision detection.

Author:
Rene Mueller, April 14th 2003


Constructor & Destructor Documentation

Model::Model const char *  filename  ) 
 

read new model from file

read 3D data from IV file and create Inventor and RAPID model

Parameters:
filename file name to read in

00020 {
00021    rootModel = new SoSeparator;
00022    material = new SoMaterial;
00023    rootModel->addChild(material);
00024    rapidModel = new RAPID_model;
00025 
00026    // load model from IV file 
00027    SoInput *input = new SoInput;
00028    if (!input->openFile(filename)) {
00029       cerr << "File '" << filename << "' could not be opened." << endl;
00030       exit(1);
00031    }
00032    SoDB::init();
00033    
00034    model = SoDB::readAll(input); // read entire object
00035    if (model == NULL) {
00036       cerr << "Error on read of '" << filename << "'" << endl;
00037       exit(1);
00038    }
00039    rootModel->addChild(model);
00040 
00041    // fill up RAPID structure
00042    
00043    SoCoordinate3 *coords = NULL;
00044    SoIndexedFaceSet *faces = NULL;
00045    SoIndexedTriangleStripSet* triangles = NULL;
00046    // find first SoCoordinate3 node 
00047    for (int i=0; i<model->getNumChildren(); i++) {
00048       SoNode* child = model->getChild(i);
00049       if (child->isOfType(SoCoordinate3::getClassTypeId())) {
00050          coords = dynamic_cast<SoCoordinate3*>(child); 
00051          cout << "reading model '" << filename << "': node " << child->getTypeId().getName().getString() << " read." << endl;
00052       } else if (child->isOfType(SoIndexedFaceSet::getClassTypeId())) {
00053          faces = dynamic_cast<SoIndexedFaceSet*>(child);
00054          cout << "reading model '" << filename << "': node " << child->getTypeId().getName().getString() << " read." << endl;
00055       } else if (child->isOfType(SoIndexedTriangleStripSet::getClassTypeId())) {
00056          triangles = dynamic_cast<SoIndexedTriangleStripSet*>(child);
00057          cout << "reading model '" << filename << "': node " << child->getTypeId().getName().getString() << " read." << endl;
00058       } else {
00059          cout << "reading model '" << filename << "': node " << child->getTypeId().getName().getString() << " ignored" << endl;
00060       }
00061    }
00062    if (triangles == NULL) {
00063       // we are using SoCoordinate3 and SoIndexedFaceSet
00064       assert(coords);
00065       assert(faces);
00066    
00067       // verify that face simlices are only triangles 
00068       // and create RAPID data model
00069       int vertices = 0, faceNumber = 0;
00070       double a[3], b[3], c[3];      // vertex data
00071       for (int i=0; i<faces->coordIndex.getNum(); i++) {
00072          int element = faces->coordIndex[i];
00073          if (element == -1) {
00074             if (vertices != 3) {
00075                cout << "Model '" << filename << +"' does not only contain triangular simplices! (count " << vertices << ")" << endl;
00076                exit(1);
00077             } else {
00078                rapidModel->AddTri(a, b, c, faceNumber);
00079                faceNumber++;
00080                vertices = 0;
00081             }
00082          } else {
00083             if (vertices == 0) {
00084                // first point
00085                SbVec3f point = coords->point[element];
00086                a[0] = point[0]; a[1] = point[1]; a[2] = point[2];
00087             } else if (vertices == 1) {
00088                // second point
00089                SbVec3f point = coords->point[element];
00090                b[0] = point[0]; b[1] = point[1]; b[2] = point[2];
00091             } else {
00092                // third point
00093                SbVec3f point = coords->point[element];
00094                c[0] = point[0]; c[1] = point[1]; c[2] = point[2];
00095             }
00096             vertices++;
00097          }
00098       }
00099    } else {
00100       // we are using SoIndexedTriangleStripSet
00101       assert(triangles);
00102       SoVertexProperty* prop = dynamic_cast<SoVertexProperty*>(triangles->vertexProperty.getValue());
00103       int numVertices = prop->vertex.getNum();
00104       // create RAPID model
00105       double p[2][3], a[3]; 
00106       bool stripReady = false; 
00107       int lastPtr = -1, faceNumber = 0;
00108       for (int i=0; i<triangles->coordIndex.getNum(); i++) {
00109          int element = triangles->coordIndex[i];
00110          if ((element != -1) && ((element <0) || (element > numVertices))) {
00111             cerr << "invalid vertex index " << element << "in triangle strip set." << endl;
00112             exit(1);
00113          } 
00114          if (element != -1) {
00115             // end of strip not reached yet
00116             if (stripReady) {
00117                a[0] = prop->vertex[element][0]; a[1] = prop->vertex[element][1]; 
00118                a[2] = prop->vertex[element][2];
00119                rapidModel->AddTri(p[lastPtr], p[(lastPtr+1)%2], a, faceNumber);
00120                lastPtr = (lastPtr%2)+1;
00121                faceNumber++;
00122                p[lastPtr][0] = a[0]; p[lastPtr][1] = a[1]; p[lastPtr][2] = a[2];
00123             } else {
00124                lastPtr = (lastPtr+1)%2; 
00125                p[lastPtr][0] = prop->vertex[element][0]; 
00126                p[lastPtr][1] = prop->vertex[element][1];
00127                p[lastPtr][2] = prop->vertex[element][2];
00128                if (lastPtr == 1) {
00129                   stripReady = true;
00130                }
00131             }
00132          } else {
00133             // end of strip reached
00134             lastPtr = -1;
00135             stripReady = false;
00136          }
00137       }
00138    }
00139 
00140    rapidModel->EndModel();
00141 }

Model::~Model  ) 
 

destructor

00144 { }


Member Function Documentation

SoMaterial* Model::getMaterial  )  [inline]
 

return Inventor material node

00048                              {
00049       return material;
00050    }

SoSeparator* Model::getModel  )  [inline]
 

return Inventor model with 3D data

00038                            {
00039       return model;
00040    }

RAPID_model* Model::getRAPIDModel  )  [inline]
 

return RAPID model

00053                                 {
00054       return rapidModel;
00055    }

SoSeparator* Model::getRootModel  )  [inline]
 

return Inventor root model (children: model, node, material node)

00043                                {
00044       return rootModel;
00045    }


Member Data Documentation

SoMaterial* Model::material [private]
 

Open Inventor material node.

SoSeparator* Model::model [private]
 

Open Inventor model.

RAPID_model* Model::rapidModel
 

RAPID collision detection model.

SoSeparator* Model::rootModel [private]
 

Open Inventor model root (children: model node, material node).


The documentation for this class was generated from the following files:
Generated on Tue Jul 8 13:23:02 2003 for ROM-Visualizer by doxygen 1.3.1