VRUT::Optimize Class Reference

Module for scene optimization. More...

#include <optimize.h>

Inheritance diagram for VRUT::Optimize:

VRUT::SceneModule VRUT::Module

List of all members.

Public Member Functions

 Optimize (const MODULE_ID &_id, const wxString &_name, EventHandler *msgSink)
 Class constructor - do not alter.
virtual ~Optimize ()
 Class destructor - deinitialize your data.
virtual wxString GetDesc () const
 Always overload method giving description for your module.

Protected Member Functions

void parseMask (wxString mask, std::vector< wxString > &maskList)
bool nameHasMask (wxString name, std::vector< wxString > &maskList)
void deleteAction (SCENE_ID _sceneID, wxString mask)
bool simplifyStructureRecursion (Scene *scene, const SceneNode *node, std::vector< wxString > &maskList, long &delCount)
void simplifyStructureAction (SCENE_ID _sceneID, wxString mask)
void removeUnusedMaterialsAction (SCENE_ID _sceneID)
void unifyMaterialsAction (SCENE_ID _sceneID)
void unifyVerticesAction (SCENE_ID _sceneID)
void removeUnusedGeometriesAction (SCENE_ID _sceneID)
void mergePrimitive (std::vector< size_t > &canMerge, GeometryTriangles::PRIMITIVE_TYPE primType, GeometryTriangles::TriDescList &ntriD, GeometryTriangles::TriDescList *triDescList, std::vector< GeometryTriangles::Indice > &nind, std::vector< bool > &primUsed, std::vector< GeometryTriangles::Indice > *indices, long &delCount)
 Merge one type of primitives (help method for mergePrimitivesAction).
void mergePrimitivesAction (SCENE_ID _sceneID)
void deleteNormalsAction (SCENE_ID _sceneID, wxString mask)
void deleteTexCoordsAction (SCENE_ID _sceneID, wxString mask)
void statisticsAction (SCENE_ID _sceneID)
virtual void processEvent (wxCommandEvent &evt)
 Overload this to process events you need.

Protected Attributes

wxString nameMask
 name mask for delete action
Parameter::ParameterIdentificator nameMaskParamID
 Add nameMask param identificator to register this as parameter.
Parameter::ParameterIdentificator deleteActionParamID
 Add delete push button param identificator to register this as parameter.
Parameter::ParameterIdentificator simplifyStructureActionParamID
 Add simplifyStructure push button param identificator to register this as parameter.
Parameter::ParameterIdentificator removeUnusedMaterialsActionParamID
 Add removeUnusedMaterials push button param identificator to register this as parameter.
Parameter::ParameterIdentificator unifyMaterialsActionParamID
 Add unifyMaterials push button param identificator to register this as parameter.
Parameter::ParameterIdentificator unifyVerticesActionParamID
 Add unifyVertices push button param identificator to register this as parameter.
Parameter::ParameterIdentificator removeUnusedGeometriesActionParamID
 Add removeUnusedGeometries push button param identificator to register this as parameter.
Parameter::ParameterIdentificator mergePrimitivesActionParamID
 Add mergePrimitives push button param identificator to register this as parameter.
Parameter::ParameterIdentificator deleteNormalsActionParamID
 Add deleteNormals push button param identificator to register this as parameter.
Parameter::ParameterIdentificator deleteTexCoordsActionParamID
 Add deleteTexCoords push button param identificator to register this as parameter.
Parameter::ParameterIdentificator statisticsActionParamID
 Add statistics push button param identificator to register this as parameter.

Detailed Description

Module for scene optimization.

Definition at line 29 of file optimize.h.

Constructor & Destructor Documentation

VRUT::Optimize::Optimize ( const MODULE_ID &  _id,
const wxString &  _name,
EventHandler *  msgSink 
) [inline]

Class constructor - do not alter.

Definition at line 164 of file optimize.h.

00165                      : SceneModule(_id, _name, 0, msgSink)
00166               {
00167                      REGISTER_PARAM_GUI_TEXTCONTROL(nameMaskParamID, wxT("nameMask"), wxT("*"), wxT("Mame mask for Delete and Simplify structure.\n* - any number on any characters\n? - any character"));
00168                      REGISTER_PARAM_GUI_BUTTON(deleteActionParamID, wxT("delete"), wxT("Delete nodes with given nameMask."));
00169                      REGISTER_PARAM_GUI_BUTTON(simplifyStructureActionParamID, wxT("simplifyStructure"), wxT("Delete nodes with given nameMask, if they have only one children."));
00170                      REGISTER_PARAM_GUI_BUTTON(removeUnusedMaterialsActionParamID, wxT("removeUnusedMaterials"), wxT("Remove materials not used in any node."));
00171                      REGISTER_PARAM_GUI_BUTTON(unifyMaterialsActionParamID, wxT("unifyMaterials"), wxT("Remove duplicated materials (that differs only by the name)."));
00172                      REGISTER_PARAM_GUI_BUTTON(unifyVerticesActionParamID, wxT("unifyVertices"), wxT("Unify vertices with the same coordinates, normal and texture coordinates"));
00173                      REGISTER_PARAM_GUI_BUTTON(removeUnusedGeometriesActionParamID, wxT("removeUnusedGeometries"), wxT("Delete geometries not used in any node."));
00174                      REGISTER_PARAM_GUI_BUTTON(mergePrimitivesActionParamID, wxT("mergePrimitives"), wxT("Merge primitives (for example TRIANGLES, QUADS, etc.).\nIt can also convert some types to another (triangle strip with three vertices is triangle, etc."));
00175                      REGISTER_PARAM_GUI_BUTTON(deleteNormalsActionParamID, wxT("deleteNormals"), wxT("Detete normals from nodes with given nameMask."));
00176                      REGISTER_PARAM_GUI_BUTTON(deleteTexCoordsActionParamID, wxT("deleteTexCoords"), wxT("Detete texture coordinates from nodes with given nameMask."));
00177                      REGISTER_PARAM_GUI_BUTTON(statisticsActionParamID, wxT("statistics"), wxT("Compute and log information about scene.\nCorrect LogLevel must be set to see results."));
00178               }

virtual VRUT::Optimize::~Optimize (  )  [inline, virtual]

Class destructor - deinitialize your data.

Definition at line 180 of file optimize.h.

00181               {
00182               }

Member Function Documentation

void Optimize::parseMask ( wxString  mask,
std::vector< wxString > &  maskList 
) [protected]

Definition at line 18 of file optimize.cpp.

00019 {
00020        while (!mask.IsEmpty())
00021        {
00022               int pos = mask.Find(wxT(','));
00023               if (pos != wxNOT_FOUND)
00024               {
00025                      if (pos>0)
00026                             maskList.push_back(mask.SubString(0,pos-1));
00027                      mask.Remove(0, pos+1);
00028               }
00029               else 
00030               {
00031                      maskList.push_back(mask.SubString(0,pos-1));
00032                      mask.Clear();
00033               }
00034        }
00035 }

bool Optimize::nameHasMask ( wxString  name,
std::vector< wxString > &  maskList 
) [protected]

Definition at line 37 of file optimize.cpp.

00038 {
00039        for (std::vector<wxString>::iterator maskIt = maskList.begin(); maskIt != maskList.end(); maskIt++)
00040        {
00041               if (name.Matches(*maskIt))
00042                      return true;
00043        }
00044        return false;
00045 }

void Optimize::deleteAction ( SCENE_ID  _sceneID,
wxString  mask 
) [protected]

Delete nodes with name matching mask

Parameters:
[in] _sceneID Scene to be processed
[in] mask Name mask (arbitrary number separated by comma)

Definition at line 47 of file optimize.cpp.

00048 {
00049        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00050        if (!scene)
00051               return;
00052 
00053        std::vector<wxString> maskList;
00054        parseMask(mask, maskList);
00055        long delCount=0;
00056 
00057        std::vector<NODE_ID> nodes;
00058        scene->GetNodeIDs(&nodes);
00059 
00060        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin();
00061               nodeIt != nodes.end(); nodeIt++)
00062        {
00063               const SceneNode * node = scene->GetNode(*nodeIt);
00064               if (nameHasMask(node->GetName(),maskList))
00065               {
00066                      //scene->Remove(*nodeIt);
00067                      wxCommandEvent evNodeRemove = Event::GET_EVT_SCENE_NODE_REMOVE(_sceneID, *nodeIt);
00068                      PostToKernel(evNodeRemove);
00069                      delCount++;
00070               }
00071        }
00072        LOG(wxString::Format(wxT("<Optimize>deleteAction removed %li nodes"), delCount));
00073 }

bool Optimize::simplifyStructureRecursion ( Scene *  scene,
const SceneNode *  node,
std::vector< wxString > &  maskList,
long &  delCount 
) [protected]

Recursive traversing function for scene simplification

Parameters:
[in] scene Scene to be processed
[in] node current node
[in] maskList The list of masks
[in] delCount Deleted nodes counter (only for logging)

Definition at line 75 of file optimize.cpp.

00076 {
00077        const SceneNode::NodeIDList *children = node->GetChildren();
00078        for (SceneNode::NodeIDList::const_iterator it = children->begin(); it != children->end();)
00079        {
00080               const SceneNode *child = scene->GetNode(*it);
00081               if ((child->IsOfType(SceneNode::ASSEMBLY))||(child->IsOfType(SceneNode::GEOMETRY)))
00082               {
00083                      if (simplifyStructureRecursion(scene, child, maskList, delCount))
00084                             it = children->begin();
00085                      else
00086                             it++;
00087               }
00088               else
00089                      it++;
00090        }
00091 
00092        if (node->GetID()==0)
00093               return false;
00094        if ((children->size()==0)&&(node->IsOfType(SceneNode::ASSEMBLY))&&(nameHasMask(node->GetName(), maskList)))
00095        {
00096               scene->Remove(node->GetID());
00097               delCount++;
00098               return true;
00099        }
00100        if (children->size()==1)
00101        {
00102               if (nameHasMask(node->GetName(), maskList))
00103               {
00104                      NODE_ID childID = children->front();
00105                      MATRIX transf((*node->GetLocalTransMatrix())*(*(scene->GetNode(childID)->GetLocalTransMatrix())));
00106                      scene->Move(childID, node->GetParent());
00107                      scene->SetTransformation(childID, transf);
00108                      scene->Remove(node->GetID());
00109                      delCount++;
00110                      return true;
00111               } else if (nameHasMask(scene->GetNode(children->front())->GetName(), maskList))
00112               {
00113                      NODE_ID childID = children->front();
00114                      MATRIX transf((*node->GetLocalTransMatrix())*(*(scene->GetNode(childID)->GetLocalTransMatrix())));
00115                      scene->Move(childID, node->GetParent());
00116                      scene->SetTransformation(childID, transf);
00117                      wxString name(node->GetName());
00118                      scene->Remove(node->GetID());
00119                      scene->SetName(childID, name);
00120                      delCount++;
00121                      return true;
00122               }
00123        }
00124        return false;
00125 }

void Optimize::simplifyStructureAction ( SCENE_ID  _sceneID,
wxString  mask 
) [protected]

Simplifies structure of scene, deletes ASSEMBLY nodes with name matching mask that contains only one child, deletes ASSEMBLY that contains only one child and the child has name matching mask

Parameters:
[in] _sceneID Scene to be processed
[in] mask Name mask (arbitrary number separated by comma)

Definition at line 127 of file optimize.cpp.

00128 {
00129        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00130        if (!scene)
00131               return;
00132 
00133        std::vector<wxString> maskList;
00134        parseMask(mask, maskList);
00135        long delCount = 0;
00136        simplifyStructureRecursion(scene, scene->GetNode(scene->GetRootID()), maskList, delCount);
00137        LOG(wxString::Format(wxT("<Optimize>simplifyStructureAction removed %li nodes"), delCount));
00138 }

void Optimize::removeUnusedMaterialsAction ( SCENE_ID  _sceneID  )  [protected]

Removes unused materials from scene

Parameters:
[in] _sceneID Scene to be processed

Definition at line 140 of file optimize.cpp.

00141 {
00142        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00143        if (!scene)
00144               return;
00145 
00146        const Scene::MaterialList *materials = scene->GetMaterials();
00147        std::vector<bool> matUsed;
00148        matUsed.insert(matUsed.end(), materials->size(), false);
00149        std::vector<NODE_ID> nodes;
00150        scene->GetNodeIDs(&nodes);
00151        long delCount = 0;
00152        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin();
00153               nodeIt != nodes.end(); nodeIt++)
00154        {
00155               const SceneNode * node = scene->GetNode(*nodeIt);
00156               if (node && node->IsOfType(SceneNode::GEOMETRY))
00157                      if (((GeometryNode*)node)->GetMaterialID()!=MATERIAL_ID_NONE)
00158                             matUsed[((GeometryNode*)node)->GetMaterialID()]=true;
00159        }
00160        for (size_t i=0; i<matUsed.size(); i++)
00161        {
00162               if (!matUsed[i])
00163               {
00164                      const Material *mat = scene->GetMaterial((MATERIAL_ID)i);
00165                      if (mat)
00166                      {
00167                             LOG(wxString::Format(wxT("<Optimize>remove Material: %s"), mat->name.c_str()));
00168                             scene->RemoveMaterial((MATERIAL_ID)i);
00169                             delCount++;
00170                      }
00171               }
00172        }
00173        LOG(wxString::Format(wxT("<Optimize>removeUnusedMaterialsAction removed %li materials"), delCount));
00174 }

void Optimize::unifyMaterialsAction ( SCENE_ID  _sceneID  )  [protected]

Unifies materials in scene

Parameters:
[in] _sceneID Scene to be processed

Definition at line 176 of file optimize.cpp.

00177 {
00178        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00179        if (!scene)
00180               return;
00181 
00182        long uniCount = 0;
00183        const Scene::MaterialList *materials = scene->GetMaterials();
00184        for (size_t i=0; i<materials->size(); i++)
00185        {
00186               const Material *firstMat = scene->GetMaterial((MATERIAL_ID)i);
00187               if (!firstMat)
00188                      continue;
00189               for (size_t j=i+1; j<materials->size(); j++)
00190               {
00191                      const Material *secMat = scene->GetMaterial((MATERIAL_ID)j);
00192                      if (!secMat)
00193                             continue;
00194                      if (firstMat->IsSameAs(*secMat, 28))
00195                      {
00196                             uniCount++;
00197                             //use material matIt for all geometry that use matIt2 and remove material matId2
00198                             LOG(wxString::Format(wxT("<Optimize>unifyMaterialsAction: materials %s and %s are the same"), firstMat->name.c_str(), secMat->name.c_str()));
00199                             std::vector<NODE_ID> nodes;
00200                             scene->GetNodeIDs(&nodes);
00201                             for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00202                             {
00203                                    const SceneNode * node = scene->GetNode(*nodeIt);
00204                                    if (node && node->IsOfType(SceneNode::GEOMETRY))
00205                                    {
00206                                           if ((((GeometryNode*)node)->GetMaterialID())==j)
00207                                           {
00208                                                  scene->SetMaterial(*nodeIt, (MATERIAL_ID)i);
00209                                                  /*wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_MATERIAL_SET(_sceneID, *nodeIt, firstMat->name);
00210                                                  PostToKernel(ev);*/
00211                                           }
00212                                    }
00213                             }
00214                             scene->RemoveMaterial((MATERIAL_ID)j);
00215                      }
00216               }
00217        }
00218        LOG(wxString::Format(wxT("<Optimize>unifyMaterialsAction merged %li materials"), uniCount));
00219 }

void Optimize::unifyVerticesAction ( SCENE_ID  _sceneID  )  [protected]

Unifies vertices in geometries, the vertices with the same coordinates, normals and texture coordinates are merged

Parameters:
[in] _sceneID Scene to be processed

Definition at line 266 of file optimize.cpp.

00267 {
00268        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00269        if (!scene)
00270               return;
00271 
00272        long uniCount = 0;
00273        std::vector<NODE_ID> nodes;
00274        scene->GetNodeIDs(&nodes);
00275        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00276        {
00277               const SceneNode * node = scene->GetNode(*nodeIt);
00278               if (node && node->IsOfType(SceneNode::GEOMETRY))
00279               {
00280                      const Geometry *geom = scene->GetGeometry(((GeometryNode*)node)->GetGeometryID());
00281                      if (geom && geom->type==Geometry::GEOMETRY_TRIANGLE)
00282                      {
00283                             GeometryTriangles *geoTri = (GeometryTriangles*)geom->Clone();
00284                             std::vector<VECTOR3> * verts = &(geoTri->vertices);
00285                             std::vector<VECTOR3> * norms = &(geoTri->normals);
00286                             std::vector<GeometryTriangles::TexCoord> * texs = &(geoTri->texCoords);
00287                             std::vector<GeometryTriangles::Indice> * inds = &(geoTri->indices);
00288                             //sort verts
00289                             std::vector<size_t> ind(verts->size());
00290                             for (size_t i=0; i<ind.size(); i++)
00291                                    ind[i]=GeometryTriangles::Indice(i);
00292                             //std::sort(ind.begin(), ind.end(), VerticesVectorSort(verts));
00293                             std::sort(ind.begin(), ind.end(), VerticesVectorSort2(verts, norms, texs));
00294                             //test equivalence and merge
00295                             bool geomChanged = false;
00296                             std::vector<std::vector<size_t> > vertsref(verts->size());
00297                             for (size_t i=0; i<inds->size(); i++)
00298                                    vertsref[inds->at(i)].push_back(i);
00299                             size_t lastNotMerged = 0;
00300                             for (size_t i=1; i<ind.size(); i++)
00301                             {
00302                                    if (verts->at(ind[lastNotMerged])!=verts->at(ind[i]))
00303                                    {
00304                                           lastNotMerged = i;
00305                                           continue;
00306                                    }
00307                                    if (norms->size()==verts->size())
00308                                           if (norms->at(ind[lastNotMerged])!=norms->at(ind[i]))
00309                                           {
00310                                                  lastNotMerged = i;
00311                                                  continue;
00312                                           }
00313                                    if (texs->size()==verts->size())
00314                                           if (texs->at(ind[lastNotMerged])!=texs->at(ind[i]))
00315                                           {
00316                                                  lastNotMerged = i;
00317                                                  continue;
00318                                           }
00319                                    //replace in inds
00320                                    while (vertsref[ind[i]].size())
00321                                    {
00322                                           inds->at(vertsref[ind[i]].back())=(GeometryTriangles::Indice)ind[lastNotMerged];
00323                                           vertsref[ind[lastNotMerged]].push_back(vertsref[ind[i]].back());
00324                                           vertsref[ind[i]].pop_back();
00325                                    }
00326                                    geomChanged = true;
00327                             }
00328                             if (!geomChanged)
00329                             {
00330                                    for (size_t i=0; i<vertsref.size(); i++)
00331                                    {
00332                                           if (vertsref.at(i).size()==0)
00333                                           {
00334                                                  geomChanged=true;
00335                                                  break;
00336                                           }
00337                                    }
00338                             }
00339                             if (geomChanged)
00340                             {
00341                                    //remove unused vertices
00342                                    size_t lastUsed = vertsref.size()-1;
00343                                    for (size_t i=0; i<vertsref.size() && i<=lastUsed; i++)
00344                                    {
00345                                           if (!vertsref[i].size())
00346                                           {
00347                                                  while (!vertsref[lastUsed].size())
00348                                                  {
00349                                                         lastUsed--;
00350                                                         if (norms->size()==verts->size())
00351                                                                norms->pop_back();
00352                                                         if (texs->size()==verts->size())
00353                                                                texs->pop_back();
00354                                                         verts->pop_back();
00355                                                         uniCount++;
00356                                                  }
00357                                                  if (i>=lastUsed)
00358                                                         break;
00359                                                  verts->at(i)=verts->at(lastUsed);
00360                                                  if (norms->size()==verts->size())
00361                                                         norms->at(i)=norms->at(lastUsed);
00362                                                  if (texs->size()==verts->size())
00363                                                         texs->at(i)=texs->at(lastUsed);
00364                                                  while (vertsref[lastUsed].size())
00365                                                  {
00366                                                         inds->at(vertsref[lastUsed].back())=(GeometryTriangles::Indice)i;
00367                                                         vertsref[i].push_back(vertsref[lastUsed].back());
00368                                                         vertsref[lastUsed].pop_back();
00369                                                  }
00370                                           }
00371                                    }
00372                                    scene->AddGeometry(geoTri);
00373                                    if (TestExit())
00374                                           return;
00375                             }
00376                      }
00377               }
00378        }
00379        LOG(wxString::Format(wxT("<Optimize>unifyVerticesAction merged %li vertices"), uniCount));
00380 }

void Optimize::removeUnusedGeometriesAction ( SCENE_ID  _sceneID  )  [protected]

Removes unused geometries from scene

Parameters:
[in] _sceneID Scene to be processed

Definition at line 382 of file optimize.cpp.

00383 {
00384        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00385        if (!scene)
00386               return;
00387 
00388        const Scene::GeometryList *geometries = scene->GetGeometries();
00389        std::vector<bool> geoUsed;
00390        geoUsed.insert(geoUsed.end(), geometries->size(), false);
00391        std::vector<NODE_ID> nodes;
00392        scene->GetNodeIDs(&nodes);
00393        long delCount = 0;
00394        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin();
00395               nodeIt != nodes.end(); nodeIt++)
00396        {
00397               const SceneNode * node = scene->GetNode(*nodeIt);
00398               if (node->IsOfType(SceneNode::GEOMETRY))
00399                      if (((GeometryNode*)node)->GetGeometryID()!=GEOMETRY_ID_NONE)
00400                             geoUsed[((GeometryNode*)node)->GetGeometryID()]=true;
00401        }
00402        for (size_t i=0; i<geoUsed.size(); i++)
00403        {
00404               if (!geoUsed[i])
00405               {
00406                      const Geometry *geo = scene->GetGeometry((GEOMETRY_ID)i);
00407                      if (geo)
00408                      {
00409                             LOG(wxString::Format(wxT("<Optimize>remove Geometry: %s"), geo->GetName().c_str()));
00410                             scene->RemoveGeometry((GEOMETRY_ID)i);
00411                             delCount++;
00412                      }
00413               }
00414        }
00415        LOG(wxString::Format(wxT("<Optimize>removeUnusedGeometriesAction removed %li geometries"), delCount));
00416 }

void Optimize::mergePrimitive ( std::vector< size_t > &  canMerge,
GeometryTriangles::PRIMITIVE_TYPE  primType,
GeometryTriangles::TriDescList &  ntriD,
GeometryTriangles::TriDescList *  triDescList,
std::vector< GeometryTriangles::Indice > &  nind,
std::vector< bool > &  primUsed,
std::vector< GeometryTriangles::Indice > *  indices,
long &  delCount 
) [protected]

Merge one type of primitives (help method for mergePrimitivesAction).

Definition at line 418 of file optimize.cpp.

00421 {
00422        if (canMerge.size()>1)
00423        {
00424               ntriD.push_back(triDescList->at(canMerge[0]));
00425               ntriD.back().first=(GeometryTriangles::Indice)nind.size();
00426               ntriD.back().second=primType;
00427               for (size_t j=0; j<canMerge.size(); j++)
00428               {
00429                      primUsed[canMerge[j]]=true;
00430                      size_t last = (canMerge[j]+1<triDescList->size())?triDescList->at(canMerge[j]+1).first:indices->size();
00431                      for (size_t k=triDescList->at(canMerge[j]).first; k<last; k++)
00432                             nind.push_back(indices->at(k));
00433               }
00434               delCount+=long(canMerge.size()-1);
00435        }
00436 }

void Optimize::mergePrimitivesAction ( SCENE_ID  _sceneID  )  [protected]

Merge triangles into one TRI_LIST

Parameters:
[in] _sceneID Scene to be processed

!!Conversion to QUAD switchs triangles and can cause visible artefacts!!!

Definition at line 438 of file optimize.cpp.

00439 {
00440        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00441        if (!scene)
00442               return;
00443 
00444        long delCount = 0;
00445        const Scene::GeometryList *geometries = scene->GetGeometries();
00446        for (size_t i=0; i<geometries->size(); i++)
00447        {
00448               if (!geometries->at(i))
00449                      continue;
00450               if (geometries->at(i)->type==Geometry::GEOMETRY_TRIANGLE)
00451               {
00452                      GeometryTriangles *geoTri = (GeometryTriangles*)geometries->at(i)->Clone();
00453                      std::vector<GeometryTriangles::Indice> * indices = &(geoTri->indices);
00454                      GeometryTriangles::TriDescList *triDescList = &(geoTri->triDescList);
00455                      std::vector<size_t> canTriangles, canLines, canPoints, canQuads;
00456                      for (size_t j=0; j<geoTri->triDescList.size(); j++)
00457                      {
00458                             long count = long(((j+1<triDescList->size())?triDescList->at(j+1).first:indices->size()) - triDescList->at(j).first);
00459                             switch (triDescList->at(j).second)
00460                             {
00461                             case GeometryTriangles::TRI_STRIP:
00462                                    if (count==4)
00463                                    {
00465 /*                                        //convert to QUAD
00466                                           size_t itmp=triDescList->at(j).first+2;
00467                                           GeometryTriangles::Indice tmp=indices->at(itmp);
00468                                           indices->at(itmp)=indices->at(itmp+1);
00469                                           indices->at(itmp+1)=tmp;
00470                                           triDescList->at(j).second=GeometryTriangles::QUADS;
00471                                           canQuads.push_back(j);*/
00472                                           break;
00473                                    }
00474                             case GeometryTriangles::TRI_FAN:
00475                             case GeometryTriangles::POLYGON:
00476                                    if (count==3)
00477                                           canTriangles.push_back(j);
00478                                    else if (count==4)
00479                                           canQuads.push_back(j);
00480                                    break;
00481                             case GeometryTriangles::TRI_LIST:
00482                                    canTriangles.push_back(j);
00483                                    break;
00484                             case GeometryTriangles::LINE_STRIP:
00485                                    if (count!=2)
00486                                           break;
00487                             case GeometryTriangles::LINES:
00488                                    canLines.push_back(j);
00489                                    break;
00490                             case GeometryTriangles::POINTS:
00491                                    canPoints.push_back(j);
00492                                    break;
00493                             case GeometryTriangles::QUADS:
00494                                    canQuads.push_back(j);
00495                                    break;
00496                             }
00497                      }
00498                      //really merge
00499                      std::vector<GeometryTriangles::Indice> nind;
00500                      GeometryTriangles::TriDescList ntriD;
00501                      std::vector<bool> primUsed;
00502                      primUsed.insert(primUsed.end(), triDescList->size(), false);
00503                      mergePrimitive(canTriangles, GeometryTriangles::TRI_LIST, ntriD, triDescList, nind, primUsed, indices, delCount);
00504                      mergePrimitive(canLines, GeometryTriangles::LINES, ntriD, triDescList, nind, primUsed, indices, delCount);
00505                      mergePrimitive(canPoints, GeometryTriangles::POINTS, ntriD, triDescList, nind, primUsed, indices, delCount);
00506                      mergePrimitive(canQuads, GeometryTriangles::QUADS, ntriD, triDescList, nind, primUsed, indices, delCount);
00507                      if (ntriD.size()>0)
00508                      {
00509                             for (size_t j=0; j<triDescList->size(); j++)
00510                             {
00511                                    if (primUsed[j])
00512                                           continue;
00513                                    ntriD.push_back(triDescList->at(j));
00514                                    ntriD.back().first=(GeometryTriangles::Indice)nind.size();
00515                                    size_t last = (j+1<triDescList->size())?triDescList->at(j+1).first:indices->size();
00516                                    for (size_t k=triDescList->at(j).first; k<last; k++)
00517                                           nind.push_back(indices->at(k));
00518                             }
00519                             indices->assign(nind.begin(), nind.end());
00520                             triDescList->assign(ntriD.begin(), ntriD.end());
00521                             scene->AddGeometry(geoTri);
00522                             if (TestExit())
00523                                    return;
00524                      }
00525               }
00526        }
00527        LOG(wxString::Format(wxT("<Optimize>mergePrimitivesAction merged %li primitives"), delCount));
00528 }

void Optimize::deleteNormalsAction ( SCENE_ID  _sceneID,
wxString  mask 
) [protected]

Delete normals from scene

Parameters:
[in] _sceneID Scene to be processed

Definition at line 530 of file optimize.cpp.

00531 {
00532        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00533        if (!scene)
00534               return;
00535 
00536        std::vector<wxString> maskList;
00537        parseMask(mask, maskList);
00538        long delCount=0;
00539 
00540        std::vector<NODE_ID> nodes;
00541        scene->GetNodeIDs(&nodes);
00542 
00543        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00544        {
00545               const SceneNode * node = scene->GetNode(*nodeIt);
00546               if (node->IsOfType(SceneNode::GEOMETRY) && nameHasMask(node->GetName(),maskList))
00547               {
00548                      const Geometry *geom = scene->GetGeometry(((GeometryNode*)node)->GetGeometryID());
00549                      if (geom->type==Geometry::GEOMETRY_TRIANGLE)
00550                      {
00551                             GeometryTriangles *geoTri = (GeometryTriangles*)geom->Clone();
00552                             if (geoTri->normals.size()>0)
00553                             {
00554                                    geoTri->normals.clear();
00555                                    delCount++;
00556                                    scene->AddGeometry(geoTri);
00557                             }
00558                      }
00559               }
00560        }
00561        LOG(wxString::Format(wxT("<Optimize>deleteNormalsAction removed normals from %li nodes"), delCount));
00562 }

void Optimize::deleteTexCoordsAction ( SCENE_ID  _sceneID,
wxString  mask 
) [protected]

Delete texture coordinates from scene

Parameters:
[in] _sceneID Scene to be processed

Definition at line 564 of file optimize.cpp.

00565 {
00566        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00567        if (!scene)
00568               return;
00569 
00570        std::vector<wxString> maskList;
00571        parseMask(mask, maskList);
00572        long delCount=0;
00573 
00574        std::vector<NODE_ID> nodes;
00575        scene->GetNodeIDs(&nodes);
00576 
00577        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00578        {
00579               const SceneNode * node = scene->GetNode(*nodeIt);
00580               if (node->IsOfType(SceneNode::GEOMETRY) && nameHasMask(node->GetName(),maskList))
00581               {
00582                      const Geometry *geom = scene->GetGeometry(((GeometryNode*)node)->GetGeometryID());
00583                      if (geom->type==Geometry::GEOMETRY_TRIANGLE)
00584                      {
00585                             GeometryTriangles *geoTri = (GeometryTriangles*)geom->Clone();
00586                             if (geoTri->texCoords.size()>0)
00587                             {
00588                                    geoTri->texCoords.clear();
00589                                    delCount++;
00590                                    scene->AddGeometry(geoTri);
00591                             }
00592                      }
00593               }
00594        }
00595        LOG(wxString::Format(wxT("<Optimize>deleteTexCoordsAction removed texture coordinates from %li nodes"), delCount));
00596 }

void Optimize::statisticsAction ( SCENE_ID  _sceneID  )  [protected]

Computes statistics about scene

Parameters:
[in] _sceneID Scene to be processed

Definition at line 598 of file optimize.cpp.

00599 {
00600        Scene * scene = GetSceneMgr()->GetScene(_sceneID);
00601        if (!scene)
00602               return;
00603 
00604        std::vector<NODE_ID> nodes;
00605        scene->GetNodeIDs(&nodes);
00606        
00607        long ass = 0, geo = 0, lig = 0, cam = 0;
00608        for (std::vector<NODE_ID>::const_iterator nodeIt = nodes.begin(); nodeIt != nodes.end(); nodeIt++)
00609        {
00610               switch (scene->GetNode(*nodeIt)->GetType())
00611               {
00612               case SceneNode::ASSEMBLY:
00613                      ass++;
00614                      break;
00615               case SceneNode::GEOMETRY:
00616                      geo++;
00617                      break;
00618               case SceneNode::CAMERA:
00619                      cam++;
00620                      break;
00621               case SceneNode::LIGHT:
00622                      lig++;
00623                      break;
00624               }
00625        }
00626        
00627        long geos = 0, ver = 0, nor = 0, tco = 0, ind = 0, fac = 0;
00628        long tri = 0, fan = 0, str = 0, pol = 0, lin = 0, lli = 0, poi = 0, qua = 0;
00629        long tris = 0;
00630        const Scene::GeometryList *geometries = scene->GetGeometries();
00631        for (size_t i=0; i<geometries->size(); i++)
00632        {
00633               if (geometries->at(i))
00634                      geos++;
00635               else
00636                      continue;
00637               if (geometries->at(i)->type==Geometry::GEOMETRY_TRIANGLE)
00638               {
00639                      GeometryTriangles *geoTri = (GeometryTriangles*)geometries->at(i);
00640                      ver+=long(geoTri->vertices.size());
00641                      nor+=long(geoTri->normals.size());
00642                      tco+=long(geoTri->texCoords.size());
00643                      ind+=long(geoTri->indices.size());
00644                      fac+=long(geoTri->triDescList.size());
00645                      for (size_t j=0; j<geoTri->triDescList.size(); j++)
00646                      {
00647                             long count = long(((j+1<geoTri->triDescList.size())?geoTri->triDescList.at(j+1).first:geoTri->indices.size()) - geoTri->triDescList.at(j).first);
00648                             switch (geoTri->triDescList.at(j).second)
00649                             {
00650                             case GeometryTriangles::TRI_LIST:
00651                                    tri++;
00652                                    tris+=count/3;
00653                                    break;
00654                             case GeometryTriangles::TRI_FAN:
00655                                    tris+=count-2;
00656                                    fan++;
00657                                    break;
00658                             case GeometryTriangles::TRI_STRIP:
00659                                    tris+=count-2;
00660                                    str++;
00661                                    break;
00662                             case GeometryTriangles::POLYGON:
00663                                    tris+=count-2;
00664                                    pol++;
00665                                    break;
00666                             case GeometryTriangles::LINES:
00667                                    lin++;
00668                                    break;
00669                             case GeometryTriangles::LINE_STRIP:
00670                                    lli++;
00671                                    break;
00672                             case GeometryTriangles::POINTS:
00673                                    poi++;
00674                                    break;
00675                             case GeometryTriangles::QUADS:
00676                                    tris+=count/2;
00677                                    qua++;
00678                                    break;
00679                             }
00680                      }
00681               }
00682        }
00683        long mat = 0, sha = 0, tex = 0;
00684        const Scene::MaterialList *materials = scene->GetMaterials();
00685        for (size_t i=0; i<materials->size(); i++)
00686        {
00687               if (scene->GetMaterial((MATERIAL_ID)i))
00688               {
00689                      mat++;
00690                      if (scene->GetMaterial((MATERIAL_ID)i)->shader)
00691                             sha++;
00692                      if (!scene->GetMaterial((MATERIAL_ID)i)->imageName.IsEmpty())
00693                             tex++;
00694               }
00695        }
00696        wxString result(wxString::Format(wxT("<Optimize>statistics, scene=%i ("), _sceneID));
00697        result+=scene->GetName()+wxT(")\n");
00698        result+=wxString::Format(wxT("Nodes=%li, ASSEMBLY=%li, GEOMETRY=%li, CAMERA=%li, LIGHT=%li\n"), nodes.size(), ass, geo, cam, lig);
00699        result+=wxString::Format(wxT("Geometries=%li, Vertices=%li, Normals=%li, TexCoords=%li, Indices=%li, Faces=%li\n"),geos, ver, nor, tco, ind, fac);
00700        result+=wxString::Format(wxT("Materials=%li, Shaders=%li, Textures=%li, Triangles=%li\n"), mat, sha, tex, tris);
00701        result+=wxString::Format(wxT("TRI_LIST=%li, TRI_FAN=%li, TRI_STRIP=%li, POLYGON=%li, LINES=%li, LINE_STRIP=%li, POINTS=%li, QUADS=%li\n"), tri, fan, str, pol, lin, lli, poi, qua);
00702        LOG(result);         
00703 }

virtual void VRUT::Optimize::processEvent ( wxCommandEvent &  evt  )  [inline, protected, virtual]

Overload this to process events you need.

Always call base method

Remember to process registered param update events

Reimplemented from VRUT::SceneModule.

Definition at line 125 of file optimize.h.

00126               {
00128                      SceneModule::processEvent(evt);
00129 
00130                      switch (evt.GetEventType())
00131                      {
00133                      case Event::EVT_PARAM_SET:
00134                             {
00135                                    UPDATE_PARAM_FROM_EVENT_STRING(nameMaskParamID, nameMask, evt);
00136 
00137                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == deleteActionParamID)
00138                                           deleteAction(sceneID, nameMask);
00139                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == simplifyStructureActionParamID)
00140                                           simplifyStructureAction(sceneID, nameMask);
00141                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == removeUnusedMaterialsActionParamID)
00142                                           removeUnusedMaterialsAction(sceneID);
00143                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == unifyMaterialsActionParamID)
00144                                           unifyMaterialsAction(sceneID);
00145                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == unifyVerticesActionParamID)
00146                                           unifyVerticesAction(sceneID);
00147                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == removeUnusedGeometriesActionParamID)
00148                                           removeUnusedGeometriesAction(sceneID);
00149                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == mergePrimitivesActionParamID)
00150                                           mergePrimitivesAction(sceneID);
00151                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == deleteNormalsActionParamID)
00152                                           deleteNormalsAction(sceneID, nameMask);
00153                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == deleteTexCoordsActionParamID)
00154                                           deleteTexCoordsAction(sceneID, nameMask);
00155                                    if (Parameter::ParameterIdentificator::FromEvent(evt) == statisticsActionParamID)
00156                                           statisticsAction(sceneID);
00157                                    break;
00158                             }
00159                      }
00160               }

virtual wxString VRUT::Optimize::GetDesc (  )  const [inline, virtual]

Always overload method giving description for your module.

Implements VRUT::Module.

Definition at line 185 of file optimize.h.

00186               {
00187                      return wxT("Optimization module");
00188               }

Member Data Documentation

wxString VRUT::Optimize::nameMask [protected]

name mask for delete action

Definition at line 33 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::nameMaskParamID [protected]

Add nameMask param identificator to register this as parameter.

Definition at line 35 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::deleteActionParamID [protected]

Add delete push button param identificator to register this as parameter.

Definition at line 38 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::simplifyStructureActionParamID [protected]

Add simplifyStructure push button param identificator to register this as parameter.

Definition at line 41 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::removeUnusedMaterialsActionParamID [protected]

Add removeUnusedMaterials push button param identificator to register this as parameter.

Definition at line 44 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::unifyMaterialsActionParamID [protected]

Add unifyMaterials push button param identificator to register this as parameter.

Definition at line 47 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::unifyVerticesActionParamID [protected]

Add unifyVertices push button param identificator to register this as parameter.

Definition at line 50 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::removeUnusedGeometriesActionParamID [protected]

Add removeUnusedGeometries push button param identificator to register this as parameter.

Definition at line 53 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::mergePrimitivesActionParamID [protected]

Add mergePrimitives push button param identificator to register this as parameter.

Definition at line 56 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::deleteNormalsActionParamID [protected]

Add deleteNormals push button param identificator to register this as parameter.

Definition at line 59 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::deleteTexCoordsActionParamID [protected]

Add deleteTexCoords push button param identificator to register this as parameter.

Definition at line 62 of file optimize.h.

Parameter::ParameterIdentificator VRUT::Optimize::statisticsActionParamID [protected]

Add statistics push button param identificator to register this as parameter.

Definition at line 65 of file optimize.h.

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