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

Revision 2017, 7.5 KB checked in by mattausch, 17 years ago (diff)

changed to static cast

Line 
1#ifndef _Preprocessor_H__
2#define _Preprocessor_H__
3
4#include <string>
5using namespace std;
6#include "Containers.h"
7#include "Mesh.h"
8#include "KdTree.h"
9
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        virtual bool PostProcessVisibility();
86
87        /** View cells are either loaded or prepared for generation, according to the chosen environment
88        object. Important evironment options are, e.g, the view cell type.
89        Should be done after scene loading (i.e., some options are based on scene type).
90        */
91        bool PrepareViewCells();
92
93        /** Construct viewcells from the scratch
94        */
95        bool ConstructViewCells();
96
97        /** Returns the specified sample strategy, NULL if no valid strategy.
98        */
99        SamplingStrategy *GenerateSamplingStrategy(const int strategyId);
100
101        /** Export preprocessor data.
102        */
103        bool Export(const string filename, const bool scene, const bool kdtree); 
104
105        virtual void KdTreeStatistics(ostream &s);
106        virtual void BspTreeStatistics(ostream &s);
107
108        /** Loads samples from file.
109        @param samples returns the stored sample rays
110        @param objects needed to associate the objects ids
111        @returns true if samples were loaded successfully
112        */
113        bool LoadSamples(VssRayContainer &samples,
114                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
132  ExportRayAnimation(const char *filename,
133                                         const vector<VssRayContainer> &vssRays
134                                         );
135
136        virtual int
137                GenerateRays(const int number,
138                SamplingStrategy &strategy,
139                SimpleRayContainer &rays);
140
141        virtual int GenerateRays(const int number,
142                const int raysType,
143                SimpleRayContainer &rays);
144
145        bool GenerateRayBundle(SimpleRayContainer &rayBundle,
146                const SimpleRay &mainRay,
147                const int number,
148                const int shuffleType) const;
149
150        virtual void CastRays(SimpleRayContainer &rays,
151                                                  VssRayContainer &vssRays,
152                                                  const bool castDoubleRays,
153                                                  const bool pruneInvalidRays = true);
154
155        /** Compute pixel error of the current PVS solution by sampling given number of viewpoints */
156        virtual void ComputeRenderError();
157
158        /** Returns a view cells manager of the given name.
159        */
160        ViewCellsManager *CreateViewCellsManager(const char *name);
161
162        GlRendererBuffer *GetRenderer();
163
164        bool InitRayCast(const string externKdTree, const string internKdTree);
165
166        bool LoadInternKdTree(const string internKdTree);
167
168        bool ExportObj(const string filename, const ObjectContainer &objects);
169
170        Intersectable *GetParentObject(const int index) const;
171        Vector3 GetParentNormal(const int index) const;
172
173        /** Sets a Preprocessor thread.
174        */
175        void SetThread(PreprocessorThread *t);
176
177        /** Returns a Preprocessor thread.
178        */
179        PreprocessorThread *GetThread() const;
180
181       
182        Intersectable *GetObjectById(const int id);
183
184        void PrepareHwGlobalLines();
185        ////////////////////////////////////////////////
186
187        /// scene graph loaded from file
188        SceneGraph *mSceneGraph;
189
190        /// raw array of objects
191        ObjectContainer mObjects;
192
193        /// kD-tree organizing the scene graph (occluders + occludees) + viewcells
194        KdTree *mKdTree;
195        /// View space partition bsp tree
196        VspBspTree *mVspBspTree;
197        /// BSP tree representing the viewcells
198        BspTree *mBspTree;
199
200        /// list of all loaded occluders
201        ObjectContainer mOccluders;
202        /// list of all loaded occludees
203        ObjectContainer mOccludees;
204
205
206        ViewCellsManager *mViewCellsManager;
207
208        /// greedy optimized hierarchy for both objects and view cells
209        VspOspTree *mVspOspTree;
210
211        bool mUseGlRenderer;
212        bool mUseGlDebugger;
213
214        bool mLoadViewCells;
215
216        bool mDetectEmptyViewSpace;
217
218        bool mQuitOnFinish;
219        bool mLoadMeshes;
220        bool mComputeVisibility;
221
222        bool mExportVisibility;
223        string mVisibilityFileName;
224
225        bool mApplyVisibilityFilter;
226        bool mApplyVisibilitySpatialFilter;
227
228        float mVisibilityFilterWidth;
229
230        int mPass;
231 
232        bool mStopComputation;
233 
234        bool mExportObj;
235
236        bool mExportRays;
237        bool mExportAnimation;
238        int mExportNumRays;
239
240        ofstream mStats;
241
242        GlRendererBuffer *renderer;
243 
244        int mTotalSamples;
245        int mSamplesPerPass;
246        int mSamplesPerEvaluation;
247
248protected:
249
250        bool LoadBinaryObj(const string filename,
251                                           SceneGraphNode *root,
252                                           vector<FaceParentInfo> *parents);
253
254        bool ExportBinaryObj(const string filename, SceneGraphNode *root);
255
256        void SetupRay(Ray &ray, const Vector3 &point, const Vector3 &direction) const;
257
258        void EvalPvsStat();
259
260        virtual void EvalViewCellHistogram();
261
262        /////////////////////////
263
264        GlobalLinesRenderer *mGlobalLinesRenderer;
265
266        RayCaster *mRayCaster;
267        /// samples used for construction of the BSP view cells tree.
268        int mBspConstructionSamples;
269        /// samples used for construction of the VSP OSP tree.
270        int mVspOspConstructionSamples;
271        /// Simulates rendering of the scene.
272        RenderSimulator *mRenderSimulator;
273
274        vector<FaceParentInfo> mFaceParents;
275
276
277 
278        /// if box around view space should be used
279        bool mUseViewSpaceBox;
280
281        PreprocessorThread *mThread;
282};
283
284extern Preprocessor *preprocessor;
285
286}
287
288#endif
Note: See TracBrowser for help on using the repository browser.