Changeset 2280 for GTP/trunk/Lib/Vis/OnlineCullingCHC/include

Timestamp:

03/22/07 18:24:13 (18 years ago)

Author:

mattausch

Message:

removed dependency on ogre in gtpvisibility

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/include

Files:

• CullingLogManager.h (added)
• CullingManager.h (modified) (4 diffs)
• DummyPreprocessingManager.h (modified) (2 diffs)
• DummyQueryManager.h (modified) (2 diffs)
• HierarchyInterface.h (modified) (3 diffs)
• PreprocessingManager.h (modified) (3 diffs)
• QueryManager.h (modified) (3 diffs)
• VisibilityInfo.h (modified) (3 diffs)
• VisibilityManager.h (modified) (1 diff)

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/CullingManager.h

@@ -2 +2 @@
 #define _CullingManager_H__
 
+#include <iostream>
+#include <fstream>
 #include "HierarchyInterface.h"
+
 
 
@@ -8 +11 @@
 
 /** This abstract class implements an interface for a specific culling 
-        algorithm. The algorithm is either used to render a scene 
-        or to make a visibility query.
+        algorithm. The algorithm is either used to render a scene or to make a visibility query.
 */
 class CullingManager
@@ -54 +56 @@
         void SetVisualizeCulledNodes(bool visualizeCulledNodes);
 
+
 protected:
         
@@ -63 +66 @@
         HierarchyInterface *mHierarchyInterface;
         bool mVisualizeCulledNodes;
+
 };
+
 } // namespace GtpVisibility
 #endif // CullingManager

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/DummyPreprocessingManager.h

@@ -42 +42 @@
       Returns false if no viewcell was found.
     */
-  virtual bool LocateViewCellIds(const Vector3 &center,
-                                 const float radius,
-                                 vector<int> *viewCellIds
-                                 );
-
+  /*virtual bool LocateViewCellIds(const Vector3 &center,
+                                                                 const float radius,
+                                                                 vector<int> *viewCellIds
+                                                                );
+*/
 
   /**
@@ -52 +52 @@
      a union with visibleNodes and visibleMeshes. Returns the number of added entries.
   */
-  virtual int AddViewCellPVS(const int cellID,
-                             NodeInfoContainer *visibleNodes,
-                             MeshInfoContainer *visibleMeshes);
+  //virtual int AddViewCellPVS(const int cellID,
+//                                               NodeInfoContainer *visibleNodes,
+//                                               MeshInfoContainer *visibleMeshes);
 
 };

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/DummyQueryManager.h

@@ -19 +19 @@
       QueryManager(hierarchyInterface, 0) {}
     
-    /**
-       @sa QueryManager::ComputeCameraVisibility()
-     */
+    /** @sa QueryManager::ComputeCameraVisibility()
+    */
     virtual void ComputeCameraVisibility(const Camera &camera,
                                                                                  NodeInfoContainer *visibleNodes,
@@ -29 +28 @@
                                                                                  const bool approximateVisibility);
     
-    /**
-       @sa QueryManager::ComputeFromPointVisibility()
+    /** @sa QueryManager::ComputeFromPointVisibility()
     */
     virtual void ComputeFromPointVisibility(const Vector3 &point,

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/HierarchyInterface.h

@@ -3 +3 @@
 
 #include "DistanceQueue.h"
-#include "VisibilityMesh.h"
+//#include "VisibilityMesh.h"
 #include <stack>
 
@@ -11 +11 @@
 
 typedef std::vector<HierarchyNode *> NodeVector;
-typedef std::vector<GtpVisibility::Mesh *> GeometryVector;
-typedef std::vector<GtpVisibility::Patch *> PatchVector;
+//typedef std::vector<GtpVisibility::Mesh *> GeometryVector;
+//typedef std::vector<GtpVisibility::Patch *> PatchVector;
+
 typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair;
 typedef std::pair<HierarchyNode *, bool> PendingQuery;
@@ -139 +140 @@
         */
         
-        /** Returns the geometry of a given hierarchy node. 
-                @param node the hierarchy node containing the geometry
-                @param geometryList geometry is returned in this list
-                @param includeChildren if the geometry of the children should be taken into account
-        */
-        virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,    
-                                                                         GeometryVector *geometryList, 
-                                                                         bool includeChildren) = 0;
-
         
         /** This is an optimization when issuing the occlusion test. 

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/PreprocessingManager.h

@@ -7 +7 @@
 #include "HierarchyInterface.h"
 #include "VisibilityInfo.h"
-#include "VisibilityVector3.h"
+//#include "VisibilityVector3.h"
 
 namespace GtpVisibility {
@@ -80 +80 @@
         added to the container. Returns true if the corresponding PVS exists.
     */
-    virtual bool GetPVS(const Vector3 &point,
+ /*   virtual bool GetPVS(const Vector3 &point,
                         const float radius,
                         NodeInfoContainer *visibleNodes,
                         MeshInfoContainer *visibleMeshes);
-    
+   */ 
     
   
@@ -115 +115 @@
         Returns false if no viewcell was found.
     */
-    virtual bool LocateViewCellIds(const Vector3 &center,
+/*    virtual bool LocateViewCellIds(const Vector3 &center,
                                    const float radius,
                                    vector<int> *viewCellIds
                                    ) = 0;
-    
+  */  
     /**
        Add a PVS of the given viewcell to the already evaluated PVS by computing
        a union with visibleNodes and visibleMeshes. Returns the number of added entries.
     */
-    virtual int AddViewCellPVS(const int cellID,
+   /* virtual int AddViewCellPVS(const int cellID,
                                                            NodeInfoContainer *visibleNodes,
                                                            MeshInfoContainer *visibleMeshes ) = 0;
-    
+    */
     HierarchyInterface *mSceneTraverser;
   };

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/QueryManager.h

@@ -5 +5 @@
 
 #include "VisibilityInfo.h"
-#include "VisibilityVector3.h"
-#include "VisibilityCamera.h"
-#include "VisibilityRay.h"
+//#include "VisibilityCamera.h"
+//#include "VisibilityRay.h"
+
 
 namespace GtpVisibility {
-  
+
+
 typedef std::vector<OcclusionQuery *> QueryList;
 
@@ -25 +26 @@
 public:
     /** Constructor taking a hierarchy interface as an argument. This allows to operate
-        on different hierarchy types, while reusing the implementation of the query methods.
+                on different hierarchy types, while reusing the implementation of the query methods.
      */
-    QueryManager(HierarchyInterface *hierarchyInterface, int queryModes);
-    
-    /** 
-        Computes restricted visibility from point by using an explicit camera to execute
-        the visibility query.
-        @param camera The camera to be used
+    //QueryManager(HierarchyInterface *hierarchyInterface, int queryModes);
+    QueryManager(int queryModes);
 
-        @param visibleNodes Pointer to the container where visible nodes should be added.
-        This set is formed of visible leafs or fully visible interior nodes.
-        If NULL no visible nodes are not evaluated.
+    /** Computes restricted visibility from point by using an explicit camera to execute
+                the visibility query.
+                @param camera The camera to be used
 
-        @param visibleGeometry Pointer to the container where visible meshes should be added.
-        If NULL no visible meshes are not evaluated.
+                @param visibleNodes Pointer to the container where visible nodes should be added.
+                This set is formed of visible leafs or fully visible interior nodes.
+                If NULL no visible nodes are not evaluated.
 
-        @param visiblePatches Pointer to the container where visible patches should be added.
-        If NULL no visible meshes are not evaluated.
+                @param visibleGeometry Pointer to the container where visible meshes should be added.
+                If NULL no visible meshes are not evaluated.
 
-        @param relativeVisibility If true the visibility member for
-        NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible
-        pixels divided by the the number of projected pixels.
+                @param visiblePatches Pointer to the container where visible patches should be added.
+                If NULL no visible meshes are not evaluated.
 
-        @return true if the corresponding PVS exists.
+                @param relativeVisibility If true the visibility member for
+                NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible
+                pixels divided by the the number of projected pixels.
+
+                @return true if the corresponding PVS exists.
     */
-    virtual void
-    ComputeCameraVisibility(const Camera &camera,
-                            NodeInfoContainer *visibleNodes,
-                            MeshInfoContainer *visibleGeometry,
-                                PatchInfoContainer *visiblePatches,
-                            const bool relativeVisibility,
-                                const bool approximateVisibility
-                            ) = 0;
-    
+    /*virtual void ComputeCameraVisibility(const Camera &camera,
+                                                                                 NodeInfoContainer *visibleNodes,
+                                                                                 MeshInfoContainer *visibleGeometry,
+                                                                                 PatchInfoContainer *visiblePatches,
+                                                                                 const bool relativeVisibility,
+                                                                                 const bool approximateVisibility) = 0;
+    */
     /** 
         Uses the specified point to execute the visibility query in all directions. 
         @sa ComputeCameraVisibility()
     */
-    virtual void
+    /*virtual void
     ComputeFromPointVisibility(const Vector3 &point,
-                               NodeInfoContainer *visibleNodes,
-                               MeshInfoContainer *visibleGeometry,
-                                   PatchInfoContainer *visiblePatches,
-                               const bool relativeVisibility,
-                                   const bool approximateVisibility
-                               ) = 0;
-    
+                                                           NodeInfoContainer *visibleNodes,
+                                                           MeshInfoContainer *visibleGeometry,
+                                                           PatchInfoContainer *visiblePatches,
+                                                           const bool relativeVisibility,
+                                                           const bool approximateVisibility) = 0;
+    */
   /** 
       Ray shooting interface: finds an intersection with objects in the scene.
 
       @param ray The given input ray (assuming the ray direction is normalized)
-
       @param visibleMeshes List of meshes intersecting the ray
-
       @param isGlobalLine If false only first intersection with opaque object is returned.
       Otherwise all intersections of the ray with the scene are found.
 
-      @return true if there is any intersection. 
+          @return true if there is any intersection. 
         */
-    virtual bool
-                ShootRay(const Ray &ray,
-             std::vector<Mesh *> *visibleMeshes,
-             bool isGlobalLine = false
-             );
-  
+    /*virtual bool ShootRay(const Ray &ray,
+                                                  std::vector<Mesh *> *visibleMeshes,
+                                                  bool isGlobalLine = false);
+*/
         /** Sets the hierarchy interface.
       @remark the traversal depends on the type of hierarchyInterface the scene consists of.
@@ -101 +95 @@
 protected:
   
-        HierarchyInterface *mHierarchyInterface;
+        //HierarchyInterface *mHierarchyInterface;
         int mQueryModes;  
 };

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/VisibilityInfo.h

@@ -4 +4 @@
 #include <vector>
 
-#include "VisibilityMesh.h"
+//#include "VisibilityMesh.h"
 #include "HierarchyInterface.h"
 
@@ -132 +132 @@
 }
 
-typedef VisibilityInfo<Patch *> PatchInfo;
-typedef VisibilityInfo<Mesh *> MeshInfo;
-typedef VisibilityInfo<HierarchyNode *> NodeInfo;
-
-
 template<class T>
 struct InfoContainer
@@ -143 +138 @@
 };
 
-typedef std::vector<PatchInfo> PatchInfoContainer;
-typedef std::vector<MeshInfo> MeshInfoContainer;
-typedef std::vector<NodeInfo> NodeInfoContainer;
 
 } // namespace GtpVisibility

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/VisibilityManager.h

@@ -68 +68 @@
         VisibilityEnvironment *GetVisibilityEnvironment();
 
+
 protected: