Changeset 863 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src

Timestamp:

04/29/06 19:11:23 (19 years ago)

Author:

mattausch

Message:

working on preprocessor integration
added iv stuff

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src

Files:

• OgreOcclusionCullingSceneManager.cpp (modified) (5 diffs)
• OgreTypeConverter.cpp (modified) (1 diff)

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

@@ -1 +1 @@
 #include "OgreOcclusionCullingSceneManager.h"
 #include "OgreVisibilityOptionsManager.h"
+#include "OgreTypeConverter.h"
 #include <OgreMath.h>
 #include <OgreIteratorWrappers.h>
@@ -9 +10 @@
 #include <OgreEntity.h>
 #include <OgreSubEntity.h>
+#include <OgreIteratorWrappers.h>
 #include "VspBspTree.h"
-#include <OgreIteratorWrappers.h>
+#include "Containers.h"
+#include "ViewCellsManager.h"
 
 namespace Ogre {
@@ -38 +41 @@
         mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
         
-        //mDisplayNodes = true;
-        //mShowBoundingBoxes = true;
-        //mShowBoxes = true;
-//std::stringstream d; d << "here555";
-//mDummyLog.open("");
-
+#if 0
+        mDisplayNodes = true;
+        mShowBoundingBoxes = true;
+        mShowBoxes = true;
+#endif
         // TODO: set maxdepth to reasonable value
         mMaxDepth = 50;
@@ -836 +838 @@
 }
 
-/*bool OcclusionCullingSceneManager::CompareBoundingBoxes(const AxisAlignedBox &boxa, 
-                                                                                                                const AxisAlignedBox &boxb)
-{
-}
-*/
-void OcclusionCullingSceneManager::LoadViewCells(string filename)
-{
-        ObjectContainer objects;
-        mViewCellsManager->LoadViewCells(filename, &objects);
-
-        AxisAlignedBox box;
+
+MovableObject *OcclusionCullingSceneManager::FindCorrespondingObject(const AxisAlignedBox &box)
+{
         list<SceneNode *> sceneNodeList;
 
@@ -853 +847 @@
         list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end();
 
-        for (sit = sceneNodeList.begin(); sit != sceneNodeList.end(); ++ sit)
+        bool overlap = false;
+
+        MovableObject *bestFittingObj = NULL;
+        float bestFit = 0.0;
+        
+        // find the bbox which is closest to the current bbox
+        for (sit = sceneNodeList.begin(); sit != sceneNodeList.end(), !overlap; ++ sit)
         {
                 SceneNode *sn = *sit;
                 SceneNode::ObjectIterator oit = sn->getAttachedObjectIterator();
 
-                 while (oit.hasMoreElements())
-                 {
+        while (oit.hasMoreElements())
+                {
                          MovableObject *mo = oit.getNext();
-                         AxisAlignedBox bbox = mo->getWorldBoundingBox();
-//              CompareBoundingBoxes(*oit, box);
-                 }
+                         const AxisAlignedBox bbox = mo->getWorldBoundingBox();
+                         
+                         const float overlap = GtpVisibilityPreprocessor::FactorOfOverlap(
+                                 OgreTypeConverter::ConvertFromOgre(bbox), 
+                                 OgreTypeConverter::ConvertFromOgre(box));
+
+                         if (overlap > bestFit)
+                         {
+                                 bestFit = overlap;
+                                 bestFittingObj = mo;
+
+                                 // perfect fit => object found
+                                 if (overlap > (1.0 - GtpVisibilityPreprocessor::Limits::Small))
+                                        break;
+                         }
+                }
+        }
+
+        return bestFittingObj;
+}
+
+
+void OcclusionCullingSceneManager::LoadViewCells(string filename)
+{
+        GtpVisibilityPreprocessor::ObjectContainer objects;
+        // identify the corresponding Ogre meshes using the bounding boxes
+        IdentifyObjects(objects);
+
+        // load the view cells assigning the found objects to the pvss
+        mViewCellsManager->LoadViewCells(filename, &objects);
+}
+
+
+void OcclusionCullingSceneManager::IdentifyObjects(GtpVisibilityPreprocessor::ObjectContainer &objects)
+{
+        const string bboxesFilename = "boxes.out";
+
+        GtpVisibilityPreprocessor::IndexedBoundingBoxContainer iboxes;
+        mViewCellsManager->LoadBoundingBoxes(bboxesFilename, iboxes);
+
+        GtpVisibilityPreprocessor::IndexedBoundingBoxContainer::
+                const_iterator iit, iit_end = iboxes.end();
+
+        for (iit = iboxes.begin(); iit != iit_end; ++ iit)
+        {
+                  const GtpVisibilityPreprocessor::AxisAlignedBox3 box = (*iit).second;
+                  const AxisAlignedBox currentBox = OgreTypeConverter::ConvertToOgre(box);
+                  
+                  MovableObject *mo = FindCorrespondingObject(currentBox);
+
+                  //objects.push_back(mi);
         }
 }

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreTypeConverter.cpp

@@ -2 +2 @@
 
 
-GtpVisibilityPreprocessor::AxisAlignedBox3 Ogre::OgreTypeConverter::ConvertFromOgre(const Ogre::AxisAlignedBox &box)
+namespace Ogre
 {
+
+GtpVisibilityPreprocessor::AxisAlignedBox3 OgreTypeConverter::ConvertFromOgre(const AxisAlignedBox &box)
+{
+        const GtpVisibilityPreprocessor::Vector3 bmin = ConvertFromOgre(box.getMinimum());
+        const GtpVisibilityPreprocessor::Vector3 bmax = ConvertFromOgre(box.getMaximum());
+
+        return GtpVisibilityPreprocessor::AxisAlignedBox3(bmin, bmax);
 }
 
-GtpVisibilityPreprocessor::Vector3 Ogre::OgreTypeConverter::ConvertFromOgre(const Ogre::Vector3 &v)
+GtpVisibilityPreprocessor::Vector3 OgreTypeConverter::ConvertFromOgre(const Vector3 &v)
 {
+    return GtpVisibilityPreprocessor::Vector3(v.x, v.y, v.z);
 }
         
-Ogre::AxisAlignedBox Ogre::OgreTypeConverter::ConvertToOgre(const GtpVibilityPreprocessor::AxisAlignedBox3 &box)
+AxisAlignedBox OgreTypeConverter::ConvertToOgre(const GtpVisibilityPreprocessor::AxisAlignedBox3 &box)
 {
+        const Vector3 bmin = ConvertToOgre(box.Min());
+        const Vector3 bmax = ConvertToOgre(box.Max());
+
+        return AxisAlignedBox(bmin, bmax);
 }
 
-Ogre::Vector3 Ogre::OgreTypeConverter::ConvertToOgre(const GtpVibilityPreprocessor::Vector3 &v)
+Vector3 OgreTypeConverter::ConvertToOgre(const GtpVisibilityPreprocessor::Vector3 &v)
 {
+        return Vector3(v.getX(), v.getY(), v.getZ());
 }
+}