source: GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.h @ 2187

Revision 2187, 8.0 KB checked in by mattausch, 18 years ago (diff)
Line 
1#ifndef _Preprocessor_H__
2#define _Preprocessor_H__
3
4#include <string>
5//
6#include "Containers.h"
7#include "Mesh.h"
8#include "KdTree.h"
9#include "SimpleRay.h"
10
11namespace GtpVisibilityPreprocessor {
12  class PreprocessorThread;
13 
14class RenderSimulator;
15class SceneGraph;
16class Exporter;
17class ViewCellsManager;
18class BspTree;
19class VspOspTree;
20class VspBspTree;
21class RenderSimulator;
22struct VssRayContainer;
23class SamplingStrategy;
24class GlRendererBuffer;
25class VspTree;
26class HierarchyManager;
27class BvHierarchy;
28class Intersectable;
29class VssRay;
30class RayCaster;
31class GlobalLinesRenderer;
32
33
34/** Namespace for the external visibility preprocessor
35
36    This namespace includes all classes which are created by the VUT (Vienna University
37    of Technology) for the External Visibility Preprocessor of the GTP (GameTools Project)
38    (www.gametools.org).
39*/
40 
41/** Main class of the visibility preprocessor. Responsible for loading and
42    saving of the input and output files. Initiates construction of the kD-tree,
43    viewcell loading/generation and the visibility computation itself.
44*/
45class Preprocessor
46{
47        friend class RayCaster;
48        friend class IntelRayCaster;
49        friend class InternalRayCaster;
50
51public:
52        /** Default constructor initialising e.g., KD tree and BSP tree.
53        */
54        Preprocessor();
55
56        virtual ~Preprocessor();
57
58        /** Load the input scene.
59                @param filename file to load
60                @return true on success
61        */
62        virtual bool LoadScene(const string filename);
63
64        /** Export all preprocessed data in a XML format understandable by the
65                PreprocessingInterface of the GtpVisibilityPreprocessor Module.
66                The file can be compressed depending on the environement settings.
67                @return true on successful export
68        */
69        virtual bool ExportPreprocessedData(const string filename);
70
71        /** Build the KdTree of currently loaded occluders/occludees/viewcells. The construction
72                is driven by the environment settings, which also sais which of the three types of
73                entities should be used to drive the heuristical construction (only occluders by default)
74        */
75        virtual bool BuildKdTree();
76
77        /** Compute visibility method. This method has to be reimplemented by the actual
78                Preprocessor implementation (e.g. SamplingPreprocessor, ExactPreprocessor,
79                GlobalSamplingpreprocessor)
80        */
81        virtual bool ComputeVisibility() = 0;
82
83        /** Post Process the computed visibility. By default applys the visibility filter
84                (if specified in the environment and export the preprocessed data
85                */
86        virtual bool PostProcessVisibility();
87
88        /** View cells are either loaded or prepared for generation, according to the chosen environment
89                object. Important evironment options are, e.g, the view cell type.
90                Should be done after scene loading (i.e., some options are based on scene type).
91        */
92        bool PrepareViewCells();
93
94        /** Construct viewcells from the scratch
95        */
96        bool ConstructViewCells();
97
98        /** Returns the specified sample strategy, NULL if no valid strategy.
99        */
100        SamplingStrategy *GenerateSamplingStrategy(const int strategyId);
101
102        /** Export preprocessor data.
103        */
104        bool Export(const string filename, const bool scene, const bool kdtree); 
105
106        virtual void KdTreeStatistics(ostream &s);
107        virtual void BspTreeStatistics(ostream &s);
108
109        /** Loads samples from file.
110        @param samples returns the stored sample rays
111        @param objects needed to associate the objects ids
112        @returns true if samples were loaded successfully
113        */
114        bool LoadSamples(VssRayContainer &samples, ObjectContainer &objects) const;
115
116        /** Exports samples to file.
117                @returns true if samples were written successfully
118        */
119        bool ExportSamples(const VssRayContainer &samples) const;
120
121        bool LoadKdTree(const string filename);
122        bool ExportKdTree(const string filename);
123
124        virtual bool
125        ExportRays(const char *filename,
126                           const VssRayContainer &vssRays,
127                           const int number,
128                           const bool exportScene = false
129                           );
130
131        bool ExportRayAnimation(const char *filename,
132                                                        const vector<VssRayContainer> &vssRays);
133
134        virtual int     GenerateRays(const int number,
135                                                         SamplingStrategy &strategy,
136                                                         SimpleRayContainer &rays);
137
138        virtual int GenerateRays(const int number,
139                                                         const int raysType,
140                                                         SimpleRayContainer &rays);
141
142        bool GenerateRayBundle(SimpleRayContainer &rayBundle,
143                                                   const SimpleRay &mainRay,
144                                                   const int number,
145                                                   const int shuffleType) const;
146
147        virtual void CastRays(SimpleRayContainer &rays,
148                                                  VssRayContainer &vssRays,
149                                                  const bool castDoubleRays,
150                                                  const bool pruneInvalidRays = true);
151
152  virtual void
153  CastRaysWithHwGlobalLines(
154                                                        SimpleRayContainer &rays,
155                                                        VssRayContainer &vssRays,
156                                                        const bool castDoubleRays,
157                                                        const bool pruneInvalidRays
158                                                        );
159
160        /** Compute pixel error of the current PVS solution by sampling given number of viewpoints.
161        */
162        virtual void ComputeRenderError();
163
164        /** Returns a view cells manager of the given name.
165        */
166        ViewCellsManager *CreateViewCellsManager(const char *name);
167
168        GlRendererBuffer *GetRenderer();
169
170        bool InitRayCast(const string externKdTree, const string internKdTree);
171
172        bool LoadInternKdTree(const string internKdTree);
173
174        bool ExportObj(const string filename, const ObjectContainer &objects);
175
176        Intersectable *GetParentObject(const int index) const;
177        Vector3 GetParentNormal(const int index) const;
178
179        /** Sets a Preprocessor thread.
180        */
181        void SetThread(PreprocessorThread *t);
182
183        /** Returns a Preprocessor thread.
184        */
185        PreprocessorThread *GetThread() const;
186
187        Intersectable *GetObjectById(const int id);
188
189        void PrepareHwGlobalLines();
190
191        virtual void DeterminePvsObjects(VssRayContainer &rays);
192
193        static bool LoadObjects(const string &filename,
194                                                        ObjectContainer &pvsObjects,
195                                                        const ObjectContainer &preprocessorObject);
196
197        ////////////////////////////////////////////////
198
199        /// scene graph loaded from file
200        SceneGraph *mSceneGraph;
201
202        /// raw array of objects
203        ObjectContainer mObjects;
204
205        /// kD-tree organizing the scene graph (occluders + occludees) + viewcells
206        KdTree *mKdTree;
207        /// View space partition bsp tree
208        VspBspTree *mVspBspTree;
209        /// BSP tree representing the viewcells
210        BspTree *mBspTree;
211
212        /// list of all loaded occluders
213        ObjectContainer mOccluders;
214        /// list of all loaded occludees
215        ObjectContainer mOccludees;
216
217
218        ViewCellsManager *mViewCellsManager;
219
220        /// greedy optimized hierarchy for both objects and view cells
221        VspOspTree *mVspOspTree;
222
223        bool mUseGlRenderer;
224        bool mUseGlDebugger;
225       
226        bool mUseHwGlobalLines;
227        bool mLoadViewCells;
228
229        bool mDetectEmptyViewSpace;
230
231        bool mQuitOnFinish;
232        bool mLoadMeshes;
233        bool mComputeVisibility;
234
235        bool mExportVisibility;
236        string mVisibilityFileName;
237
238        bool mApplyVisibilityFilter;
239        bool mApplyVisibilitySpatialFilter;
240
241        float mVisibilityFilterWidth;
242
243        int mPass;
244 
245        bool mStopComputation;
246 
247        bool mExportObj;
248
249        bool mExportRays;
250        bool mExportAnimation;
251        int mExportNumRays;
252
253        ofstream mStats;
254
255        GlRendererBuffer *renderer;
256 
257        int mTotalSamples;
258        int mTotalTime;
259        int mSamplesPerPass;
260        int mSamplesPerEvaluation;
261
262        RayCaster *mRayCaster;
263
264
265protected:
266
267        bool LoadBinaryObj(const std::string &filename,
268                                           SceneGraphNode *root,
269                                           std::vector<FaceParentInfo> *parents);
270
271        bool ExportBinaryObj(const std::string filename, SceneGraphNode *root);
272
273        void SetupRay(Ray &ray, const Vector3 &point, const Vector3 &direction) const;
274
275        void EvalPvsStat();
276
277        virtual void EvalViewCellHistogram();
278
279        /////////////////////////
280
281        GlobalLinesRenderer *mGlobalLinesRenderer;
282
283        /// samples used for construction of the BSP view cells tree.
284        int mBspConstructionSamples;
285        /// samples used for construction of the VSP OSP tree.
286        int mVspOspConstructionSamples;
287        /// Simulates rendering of the scene.
288        RenderSimulator *mRenderSimulator;
289
290        vector<FaceParentInfo> mFaceParents;
291
292        /// if box around view space should be used
293        bool mUseViewSpaceBox;
294
295        PreprocessorThread *mThread;
296};
297
298extern Preprocessor *preprocessor;
299
300}
301
302#endif
Note: See TracBrowser for help on using the repository browser.