Changeset 2601 for GTP/trunk/Lib/Vis


Ignore:
Timestamp:
01/16/08 17:18:02 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/Lib/Vis/Preprocessing
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/Preprocessing/scripts/run_gvs_arena.sh

    r2596 r2601  
    66#TARGET=debug 
    77TARGET=release 
    8 PROGRAM=../bin/$TARGET/Preprocessor.exe 
     8COMMAND="../bin/$TARGET/Preprocessor.exe -preprocessor_quit_on_finish- -preprocessor_use_gl_renderer+ -preprocessor_evaluate_filter- -samples_per_evaluation=5000000 -samples_per_pass=500000" 
    99 
    1010echo "starting $TARGET version" 
    … …  
    2121 
    2222 
    23 $PROGRAM $ENVIRONMENT \ 
     23$COMMAND $ENVIRONMENT \ 
    2424-scene_filename=$SCENE \ 
    2525-preprocessor=gvs \ 
    … …  
    2828-gvs_samples_per_pass=50000 \ 
    2929-gvs_initial_samples=16 \ 
    30 -gvs_max_viewcells=10 \ 
     30-gvs_max_viewcells=200 \ 
    3131-gvs_min_contribution=50 \ 
    3232-gvs_per_viewcell=true \ 

  • GTP/trunk/Lib/Vis/Preprocessing/scripts/run_gvs_vienna.sh

    r2596 r2601  
    77TARGET=release 
    88PROGRAM=../bin/$TARGET/Preprocessor.exe 
     9 
     10COMMAND="../bin/$TARGET/Preprocessor.exe -preprocessor_quit_on_finish- -preprocessor_use_gl_renderer+ -preprocessor_evaluate_filter- -samples_per_evaluation=5000000 -samples_per_pass=500000" 
     11 
    912 
    1013echo "starting $TARGET version" 
    … …  
    2225 
    2326 
    24 $PROGRAM $ENVIRONMENT \ 
     27$COMMAND $ENVIRONMENT \ 
    2528-scene_filename=$SCENE \ 
    2629-preprocessor=gvs \ 
    … …  
    2932-gvs_samples_per_pass=50000 \ 
    3033-gvs_initial_samples=16 \ 
    31 -gvs_max_viewcells=10 \ 
     34-gvs_max_viewcells=100 \ 
    3235-gvs_min_contribution=50 \ 
    3336-gvs_per_viewcell=true \ 

  • GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.cpp

    r2600 r2601  
    8484mCurrentFrame(-1) 
    8585{ 
    86         mSceneGraph->CollectObjects(&mObjects); 
     86        mSceneGraph->CollectObjects(mObjects); 
    8787 
    8888#if 1 
    … …  
    400400        OcclusionQuery::GenQueries(mOcclusionQueries, 10); 
    401401 
    402         CreateVertexArrays(static_cast<SceneGraphLeaf *>(mSceneGraph->GetRoot())); 
     402        SceneGraphInterior *interior = mSceneGraph->GetRoot(); 
     403 
     404        SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     405 
     406        for (; ni != interior->mChildren.end(); ni++)  
     407        { 
     408                CreateVertexArrays(static_cast<SceneGraphLeaf *>(*ni)); 
     409        } 
    403410} 
    404411 
    … …  
    17361743                glNormalPointer(GL_FLOAT, 0, (char *)NULL + offset * sizeof(Vector3)); 
    17371744 
    1738                 glBufferDataARB(GL_ARRAY_BUFFER_ARB, leaf->mObjects.size() * 6 * sizeof(Vector3), mData, GL_STATIC_DRAW_ARB); 
     1745                glBufferDataARB(GL_ARRAY_BUFFER_ARB, leaf->mGeometry.size() * 6 * sizeof(Vector3), mData, GL_STATIC_DRAW_ARB); 
    17391746                glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); 
    17401747 

  • GTP/trunk/Lib/Vis/Preprocessing/src/GvsPreprocessor.cpp

    r2598 r2601  
    343343                hitTriangle = static_cast<TriangleIntersectable *>(tObj)->GetItem(); 
    344344        else 
    345                 cout << "border sampling: " << tObj->Type() << " not yet implemented" << endl; 
     345                cout << "border sampling: " << Intersectable::GetTypeName(tObj) << " not yet implemented" << endl; 
     346 
     347        //cout << "type: " << Intersectable::GetTypeName(tObj) << endl; 
    346348 
    347349        VertexContainer enlargedTriangle; 
    … …  
    912914                // exchange triangle pvs with objects 
    913915                //UpdatePvs(mCurrentViewCell); 
    914                 GetObjectPvs(objectPvs); 
     916        GetObjectPvs(objectPvs); 
     917 
     918                // add pvs 
     919                ObjectContainer::const_iterator it, it_end = objectPvs.end(); 
     920 
     921                for (it = objectPvs.begin(); it != it_end; ++ it) 
     922                { 
     923                        mCurrentViewCell->GetPvs().AddSampleDirty(*it, 1.0f); 
     924                } 
    915925 
    916926                cout << "triangle pvs of " << (int)mTrianglePvs.size()  
    917927                         << " was converted to object pvs of " << (int)objectPvs.size() << endl; 
     928                 
    918929 
    919930                //////// 

  • GTP/trunk/Lib/Vis/Preprocessing/src/MutualVisibility.cpp

    r2176 r2601  
    521521     
    522522    exporter->SetWireframe(); 
    523     //    exporter->ExportScene(mSceneGraph->GetRoot()); 
     523    // exporter->ExportScene(mSceneGraph->GetRoot()); 
    524524 
    525525    exporter->ExportBox(mSource); 
    … …  
    682682 
    683683MutualVisibilitySampler::MutualVisibilitySampler(SceneGraph *sceneGraph, 
    684                                                                                                                                                                                                 KdTree *kdTree, 
    685                                                                                                                                                                                                 const AxisAlignedBox3 &source, 
    686                                                                                                                                                                                                 const AxisAlignedBox3 &target, 
    687                                                                                                                                                                                                 const float solidAngleThreshold) 
    688 { 
    689   mSceneGraph = sceneGraph; 
    690   mKdTree = kdTree; 
    691   mSource = source; 
    692   mTarget = target; 
    693   mUseBoxes = true; 
    694   mSolidAngleThreshold = solidAngleThreshold; 
    695 } 
    696    
     684                                                                                                KdTree *kdTree, 
     685                                                                                                const AxisAlignedBox3 &source, 
     686                                                                                                const AxisAlignedBox3 &target, 
     687                                                                                                const float solidAngleThreshold) 
     688{ 
     689        mSceneGraph = sceneGraph; 
     690        mKdTree = kdTree; 
     691        mSource = source; 
     692        mTarget = target; 
     693        mUseBoxes = true; 
     694        mSolidAngleThreshold = solidAngleThreshold; 
     695} 
     696 
    697697 
    698698int 
    699699ComputeBoxVisibility(SceneGraph *sceneGraph, 
    700                                                                                 KdTree *kdTree, 
    701                                                                                 const AxisAlignedBox3 &source, 
    702                                                                                 const AxisAlignedBox3 &target, 
    703                                                                                 const float solidAngleThreshold) 
    704 { 
    705   MutualVisibilitySampler 
     700                                        KdTree *kdTree, 
     701                                        const AxisAlignedBox3 &source, 
     702                                        const AxisAlignedBox3 &target, 
     703                                        const float solidAngleThreshold) 
     704{ 
     705        MutualVisibilitySampler 
    706706                sampler(sceneGraph, kdTree, source, target, solidAngleThreshold); 
    707707 
    708    
    709   int visibility = sampler.ComputeVisibility(); 
    710  
    711   return visibility; 
    712    
    713 } 
    714    
    715 } 
     708        int visibility = sampler.ComputeVisibility(); 
     709 
     710        return visibility; 
     711 
     712} 
     713 
     714} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjExporter.cpp

    r2176 r2601  
    2626ObjExporter::ExportSceneNode(SceneGraphNode *node) 
    2727{ 
    28   SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
    29   for (; ni != node->mChildren.end(); ni++) 
    30     ExportSceneNode(*ni); 
    31    
    32    
    33   ObjectContainer::const_iterator mi = node->mGeometry.begin(); 
    34   for (; mi != node->mGeometry.end(); mi++) { 
    35     // export the transform... 
    36     ExportIntersectable(*mi); 
    37   } 
    38    
     28        if (!node->IsLeaf()) 
     29        { 
     30                SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
     31 
     32                SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     33 
     34                for (; ni != interior->mChildren.end(); ni++) 
     35                        ExportSceneNode(*ni); 
     36        } 
     37        else 
     38        { 
     39 
     40                SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
     41 
     42                ObjectContainer::const_iterator mi = leaf->mGeometry.begin(); 
     43 
     44                for (; mi != leaf->mGeometry.end(); mi++)  
     45                {       // export the transform ... 
     46                        ExportIntersectable(*mi); 
     47                } 
     48        } 
    3949} 
    40  
    4150 
    4251void 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PlyParser.cpp

    r2600 r2601  
    167167 ply_close (ply); 
    168168 
    169  SceneGraphNode *currentNode = root; 
     169 SceneGraphLeaf *currentNode = root; 
    170170 
    171171 cerr<<"Baking faces into meshes"<<endl; 
    … …  
    217217   meshProxy.mFaces.push_back(new Face(vc)); 
    218218 } 
    219   
     219 
    220220 if (meshProxy.mFaces.size()) { 
    221221 
    222   if (indexVertices) 
    223         meshProxy.IndexVertices(); 
    224  
    225   Mesh *mesh = new Mesh((int)meshProxy.mVertices.size(), 
    226                                                 (int)meshProxy.mFaces.size()); 
    227  
    228   mesh->mVertices = meshProxy.mVertices; 
    229     
    230   mesh->mFaces = meshProxy.mFaces; 
    231     
    232   if (useRandomMaterial) 
    233         mesh->AssignRandomMaterial(); 
    234     
    235   mesh->Preprocess(); 
    236   // make an instance of this mesh 
    237   MeshInstance *mi = new MeshInstance(mesh); 
    238   currentNode->mGeometry.push_back(mi); 
     222        if (indexVertices) 
     223                meshProxy.IndexVertices(); 
     224 
     225        Mesh *mesh = new Mesh((int)meshProxy.mVertices.size(), 
     226                (int)meshProxy.mFaces.size()); 
     227 
     228        mesh->mVertices = meshProxy.mVertices; 
     229 
     230        mesh->mFaces = meshProxy.mFaces; 
     231 
     232        if (useRandomMaterial) 
     233                mesh->AssignRandomMaterial(); 
     234 
     235        mesh->Preprocess(); 
     236        // make an instance of this mesh 
     237        MeshInstance *mi = new MeshInstance(mesh); 
     238        currentNode->mGeometry.push_back(mi); 
    239239 } 
    240240 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

    r2600 r2601  
    240240 
    241241 
    242 bool Preprocessor::ExportBinaryObj(const string &filename, SceneGraphNode *root) 
     242bool Preprocessor::ExportBinaryObj(const string &filename, SceneGraphLeaf *root) 
    243243{ 
    244244        ogzstream samplesOut(filename.c_str()); 
    … …  
    406406 
    407407        // root for different files 
    408         mSceneGraph->SetRoot(new SceneGraphNode()); 
     408        mSceneGraph->SetRoot(new SceneGraphInterior()); 
    409409 
    410410        // intel ray caster can only trace triangles 
    … …  
    421421        if (files == 1)  
    422422        { 
     423                SceneGraphLeaf *leaf = new SceneGraphLeaf(); 
     424 
    423425                if (strstr(filename.c_str(), ".x3d")) 
    424426                { 
    425427                        parser = new X3dParser; 
    426  
     428                         
    427429                        result = parser->ParseFile(filename,  
    428                                 mSceneGraph->GetRoot(), 
     430                                                                           leaf, 
     431                                                                           mLoadMeshes, 
     432                                                                           fi); 
     433                        delete parser; 
     434                } 
     435                else if (strstr(filename.c_str(), ".ply") || strstr(filename.c_str(), ".plb")) 
     436                { 
     437                        parser = new PlyParser; 
     438 
     439                        result = parser->ParseFile(filename,  
     440                                leaf, 
    429441                                mLoadMeshes, 
    430442                                fi); 
    431443                        delete parser; 
    432444                } 
    433                 else if (strstr(filename.c_str(), ".ply") || strstr(filename.c_str(), ".plb")) 
    434                 { 
    435                         parser = new PlyParser; 
    436  
    437                         result = parser->ParseFile(filename,  
    438                                 mSceneGraph->GetRoot(), 
    439                                 mLoadMeshes, 
    440                                 fi); 
    441                         delete parser; 
    442                 } 
    443445                else if (strstr(filename.c_str(), ".obj")) 
    444446                { 
    … …  
    450452                        if (!mLoadMeshes) 
    451453                        { 
    452                                 result = LoadBinaryObj(bnFile, mSceneGraph->GetRoot(), fi); 
     454                                result = LoadBinaryObj(bnFile, leaf, fi); 
    453455                        } 
    454456 
    … …  
    459461                                parser = new ObjParser; 
    460462 
    461                                 result = parser->ParseFile(filename, mSceneGraph->GetRoot(), mLoadMeshes, fi); 
    462  
    463                                 cout << "loaded " << (int)mSceneGraph->GetRoot()->mGeometry.size() << " entities" << endl; 
     463                                result = parser->ParseFile(filename, leaf, mLoadMeshes, fi); 
     464 
     465                                cout << "loaded " << (int)leaf->mGeometry.size() << " entities" << endl; 
    464466 
    465467                                // only works for triangles 
    … …  
    468470                                        cout << "exporting binary obj to " << bnFile << "... " << endl; 
    469471 
    470                                         ExportBinaryObj(bnFile, mSceneGraph->GetRoot()); 
     472                                        ExportBinaryObj(bnFile, leaf); 
    471473 
    472474                                        cout << "finished" << endl; 
    … …  
    479481                { 
    480482                        parser = new UnigraphicsParser; 
    481                         result = parser->ParseFile(filename, mSceneGraph->GetRoot(), mLoadMeshes, fi); 
     483                        result = parser->ParseFile(filename, leaf, mLoadMeshes, fi); 
    482484                        delete parser; 
     485                } 
     486 
     487                if (result) 
     488                { 
     489                        mSceneGraph->GetRoot()->mChildren.push_back(leaf); 
    483490                } 
    484491 
    … …  
    499506                                parser = new UnigraphicsParser; 
    500507 
    501                         SceneGraphNode *node = new SceneGraphNode(); 
     508                        SceneGraphLeaf *node = new SceneGraphLeaf(); 
     509 
    502510                        const bool success =  
    503511                                parser->ParseFile(filename, node, mLoadMeshes, fi); 
    … …  
    526534                 
    527535                mObjects.reserve(intersectables); 
    528                 mSceneGraph->CollectObjects(&mObjects); 
     536                mSceneGraph->CollectObjects(mObjects); 
    529537         
    530538                mSceneGraph->AssignObjectIds(); 
    … …  
    584592  KdLeaf *root = (KdLeaf *)mKdTree->GetRoot(); 
    585593         
    586   mSceneGraph->CollectObjects(&root->mObjects); 
     594  mSceneGraph->CollectObjects(root->mObjects); 
    587595   
    588596  const long startTime = GetTime(); 
    … …  
    16181626{ 
    16191627//      bool success = LoadBinaryObj(filename, mSceneGraph->GetRoot(), &mFaceParents); 
    1620         bool success = LoadBinaryObj(filename, mSceneGraph->GetRoot(), NULL); 
    1621  
    1622         return success; 
    1623 } 
    1624  
    1625 } 
     1628        SceneGraphLeaf *leaf = new SceneGraphLeaf(); 
     1629        if (LoadBinaryObj(filename, leaf, NULL)) 
     1630        { 
     1631                mSceneGraph->GetRoot()->mChildren.push_back(leaf); 
     1632                return true; 
     1633        } 
     1634 
     1635        return false; 
     1636} 
     1637 
     1638} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/QtInterface/QtGlRenderer.cpp

    r2593 r2601  
    10081008                                //                cout<<i<<":"<<costFunction[i]<<" "; 
    10091009                                // update cost function to an absolute value based on the total geometry count 
    1010                                 costFunction[i]*=mSceneGraph->GetRoot()->mGeometry.size(); 
     1010                                costFunction[i] *= mSceneGraph->GetSize(); 
    10111011                                if (costFunction[i] > maxCost) 
    10121012                                        maxCost = costFunction[i]; 
    … …  
    13341334{ 
    13351335        mUseFalseColors = true; 
    1336  
    13371336        //glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POLYGON_BIT); 
    13381337 
    … …  
    13411340        //glDisable(GL_CULL_FACE); 
    13421341 
    1343         double eq[4]; 
    1344         eq[0] = mSceneCutPlane.mNormal.x; 
    1345         eq[1] = mSceneCutPlane.mNormal.y; 
    1346         eq[2] = mSceneCutPlane.mNormal.z; 
    1347         eq[3] = mSceneCutPlane.mD; 
    1348  
    13491342        if (mCutViewCells)  
    13501343        { 
     1344                double eq[4]; 
     1345                eq[0] = mSceneCutPlane.mNormal.x; 
     1346                eq[1] = mSceneCutPlane.mNormal.y; 
     1347                eq[2] = mSceneCutPlane.mNormal.z; 
     1348                eq[3] = mSceneCutPlane.mD; 
     1349 
    13511350                glClipPlane(GL_CLIP_PLANE0, eq); 
    13521351                glEnable(GL_CLIP_PLANE0); 
    … …  
    13621361        int i; 
    13631362 
    1364         if (!mShowPvsSizes && !mShowPiercingRays && !mShowWeightedRays && !mShowWeightedCost) 
     1363        // normal rendering 
     1364        if (!mShowPvsSizes && !mShowPiercingRays && !mShowWeightedRays && !mShowWeightedCost && !mShowComparison) 
    13651365        { 
    13661366                for (i = 0; i < viewcells.size(); ++ i)  
    … …  
    13831383                } 
    13841384        } 
    1385         else 
     1385        else // using specialised colors 
    13861386        { 
    13871387                // transparency  

  • GTP/trunk/Lib/Vis/Preprocessing/src/SceneGraph.cpp

    r2600 r2601  
    6666 
    6767 
    68 SceneGraphNode *SceneGraph::GetRoot() 
     68SceneGraphInterior *SceneGraph::GetRoot() 
    6969{ 
    7070        return mRoot; 
    … …  
    7272 
    7373 
    74 void SceneGraph::SetRoot(SceneGraphLeaf *root) 
     74void SceneGraph::SetRoot(SceneGraphInterior *root) 
    7575{ 
    7676        mRoot = root; 
    … …  
    8080int SceneGraph::CollectObjects(ObjectContainer &instances) 
    8181{ 
    82         instances->clear(); 
     82        instances.clear(); 
    8383        int number = 0; 
    8484 
    … …  
    9393                if (node->IsLeaf()) 
    9494                { 
    95                         SceneGraphLeaf *leaf = static_cast<SceneGraphNodeLeaf *>(node); 
     95                        SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
    9696 
    9797                        ObjectContainer::const_iterator mi = leaf->mGeometry.begin(); 
    … …  
    9999                        for (; mi != leaf->mGeometry.end(); mi++) 
    100100                        { 
    101                                 instances->push_back(*mi); 
    102                         } 
    103                 } 
    104                 else 
    105                 { 
    106                         SceneGraphInterior *interior = static_cast<SceneGraphNodeInterior *>(node); 
     101                                instances.push_back(*mi); 
     102                        } 
     103                } 
     104                else 
     105                { 
     106                        SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
    107107                        SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
    108108 
    … …  
    133133                nodeStack.pop(); 
    134134 
    135                 if (node->IsLeaf) 
     135                if (node->IsLeaf()) 
    136136                { 
    137137                        SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
    … …  
    146146                { 
    147147                        SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
    148                         SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
    149                         for (; ni != node->mChildren.end(); ni ++)  
     148 
     149                        SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     150                         
     151                        for (; ni != interior->mChildren.end(); ni ++)  
    150152                        { 
    151153                                nodeStack.push(*ni); 
    … …  
    166168        faces = 0; 
    167169        intersectables = 0; 
    168         while (!nodeStack.empty()) { 
    169                 SceneGraphNode *node = nodeStack.top(); 
    170                 nodeStack.pop(); 
    171  
    172                 ObjectContainer::const_iterator mi = node->mGeometry.begin(); 
    173                 for (; mi != node->mGeometry.end(); mi++) { 
    174                         intersectables++; 
    175                         faces += (*mi)->NumberOfFaces(); 
    176                 } 
    177  
    178                 SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
    179                 for (; ni != node->mChildren.end(); ni++) { 
    180                         nodeStack.push(*ni); 
    181                 } 
    182         } 
    183  
    184 } 
    185  
    186  
    187 void SceneGraphInterior::UpdateBox() 
     170 
     171        while (!nodeStack.empty())  
     172        { 
     173                SceneGraphNode *node = nodeStack.top(); 
     174                nodeStack.pop(); 
     175 
     176                if (node->IsLeaf()) 
     177                { 
     178                        SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
     179 
     180                        ObjectContainer::const_iterator mi = leaf->mGeometry.begin(); 
     181                        for (; mi != leaf->mGeometry.end(); mi++)  
     182                        { 
     183                                intersectables++; 
     184                                faces += (*mi)->NumberOfFaces(); 
     185                        } 
     186                } 
     187                else 
     188                { 
     189                        SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
     190 
     191                        SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     192                        for (; ni != interior->mChildren.end(); ni++)  
     193                        { 
     194                                nodeStack.push(*ni); 
     195                        } 
     196                } 
     197        } 
     198} 
     199 
     200 
     201void SceneGraphLeaf::UpdateBox() 
    188202{ 
    189203        AxisAlignedBox3 box; 
    … …  
    198212 
    199213 
    200 void SceneGraphLeaf::UpdateBox() 
     214void SceneGraphInterior::UpdateBox() 
    201215{ 
    202216        AxisAlignedBox3 box; 
    … …  
    229243 
    230244 
    231 } 
     245int SceneGraph::GetSize() const 
     246{ 
     247        stack<SceneGraphNode *> nodeStack; 
     248 
     249        nodeStack.push(mRoot); 
     250        int size = 0; 
     251 
     252        while (!nodeStack.empty())  
     253        { 
     254                SceneGraphNode *node = nodeStack.top(); 
     255                nodeStack.pop(); 
     256 
     257                if (node->IsLeaf()) 
     258                { 
     259                        SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
     260 
     261                        size += leaf->mGeometry.size(); 
     262                } 
     263                else 
     264                { 
     265                        SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
     266 
     267                        SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     268                        for (; ni != interior->mChildren.end(); ni++)  
     269                        { 
     270                                nodeStack.push(*ni); 
     271                        } 
     272                } 
     273        } 
     274 
     275        return size; 
     276} 
     277 
     278} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SceneGraph.h

    r2600 r2601  
    3939//protected: 
    4040 
    41         NodeContainer mChildren; 
     41        SceneGraphNodeContainer mChildren; 
    4242}; 
    4343 
    … …  
    5454//protected: 
    5555 
    56         MeshContainer mGeometry; 
     56        //MeshContainer mGeometry; 
     57        ObjectContainer mGeometry; 
    5758}; 
    5859 
    … …  
    6970        bool Export(const std::string filename); 
    7071   
    71         int CollectObjects(ObjectContainer *instances); 
     72        int CollectObjects(ObjectContainer &instances); 
    7273   
    7374        int AssignObjectIds(); 
    … …  
    8586        void LoadScene(const std::string filename); 
    8687 
    87         SceneGraphNode *GetRoot(); 
     88        SceneGraphInterior *GetRoot(); 
    8889 
    89         void SetRoot(SceneGraphNode *sgNnode); 
     90        //void SetRoot(SceneGraphNode *sgNnode); 
     91        void SetRoot(SceneGraphInterior *sgNnode); 
    9092 
     93        void AddChild(SceneGraphNode *node); 
     94 
     95        int GetSize() const; 
    9196 
    9297protected: 
    9398 
    94          SceneGraphNode *mRoot; 
     99         SceneGraphInterior *mRoot; 
    95100}; 
    96101 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

    r2600 r2601  
    16881688                // create temporary scene graph for loading the view cells geometry 
    16891689                // note: delete the meshes as they are created two times for transformed mesh instances. 
    1690                 SceneGraphNode *root = new SceneGraphLeaf(); 
     1690                SceneGraphLeaf *root = new SceneGraphLeaf(); 
    16911691                const bool success = parser.ParseFile(filename, root, true); 
    16921692                 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VrmlExporter.cpp

    r2176 r2601  
    162162        stream << "Group {" << endl; 
    163163 
    164         SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
    165  
    166         for (; ni != node->mChildren.end(); ni++) 
    167         { 
    168                 ExportSceneNode(*ni); 
    169         } 
    170     ObjectContainer::const_iterator mi = node->mGeometry.begin(); 
    171    
    172         for (; mi != node->mGeometry.end(); mi++)  
    173         { 
    174                 // export the transform... 
    175                 ExportIntersectable(*mi); 
    176         } 
    177    
     164        if (!node->IsLeaf()) 
     165        { 
     166                SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
     167 
     168                SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     169 
     170                for (; ni != interior->mChildren.end(); ni++) 
     171                { 
     172                        ExportSceneNode(*ni); 
     173                } 
     174        } 
     175        else 
     176        { 
     177                SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
     178 
     179                ObjectContainer::const_iterator mi = leaf->mGeometry.begin(); 
     180 
     181                for (; mi != leaf->mGeometry.end(); mi++)  
     182                { 
     183                        // export the transform... 
     184                        ExportIntersectable(*mi); 
     185                } 
     186        } 
     187 
    178188        stream<<"</Group>"<<endl; 
    179189} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dExporter.cpp

    r2600 r2601  
    195195 
    196196          SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
    197           for (; ni != interior->mChildren.end(); ni++) 
     197          for (; ni != interior->mChildren.end(); ++ ni) 
    198198                  ExportSceneNode(*ni); 
    199199  } 
Note: See TracChangeset for help on using the changeset viewer.