source: trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.h @ 517

Revision 517, 15.5 KB checked in by mattausch, 19 years ago (diff)
Line 
1#ifndef _ViewCellsManager_H__
2#define _ViewCellsManager_H__
3
4#include "Ray.h"
5#include "VssRay.h"
6#include "Containers.h"
7#include "ViewCell.h"
8
9class ViewCell;
10class Intersectable;
11class RenderSimulator;
12class Renderer;
13class Mesh;
14struct Triangle3;
15class SimulationStatistics;
16class BspTree;
17class KdTree;
18class VspKdTree;
19class VspBspTree;
20class KdNode;
21class KdLeaf;
22class VspKdTree;
23class AxisAlignedBox3;
24class BspLeaf;
25class ViewCellsStatistics;
26class Exporter;
27
28struct BspRay;
29
30/**
31        Manages different higher order operations on the view cells.
32*/
33class ViewCellsManager
34{
35
36public:
37  struct PvsStatistics {
38        int minPvs;
39        int maxPvs;
40        float avgPvs;
41        int viewcells;
42  };
43 
44  /// view cell container types
45  enum {BSP, KD, VSP_KD, VSP_BSP};
46 
47        /** Constructor taking the maximal number of samples used for construction
48        */
49        ViewCellsManager(const int constructionSamples);
50
51        ViewCellsManager();
52
53        virtual ~ViewCellsManager();
54
55        /** Constructs view cell container with a given number of samples.
56        */
57        virtual int Construct(const ObjectContainer &objects,
58                                                  const VssRayContainer &rays) = 0;
59
60        /** Computes sample contributions of the rays to the view cells PVS.
61       
62                @param rays bundle of rays used to find intersections with view cells and
63                adding the contribution
64                @param castRays true if ray should be cast to gain the information, false if rays
65                already hold the view cells intersection information and need not be recast.
66                @param sampleContributions returns the number of sample contributions
67                @param contributingSamples returns the number of contributingSamples
68        */
69        void  ComputeSampleContributions(const VssRayContainer &rays);
70
71
72        /** Computes sample contribution of a simgle ray to the view cells PVS.
73                @param ray finds intersections with view cells and holds the contribution
74                @param castRay true if ray should be cast to gain the information, false if ray
75                is already holding the information and need not be recast.
76         
77                @returns number of sample contributions
78        */
79        virtual void ComputeSampleContributions(VssRay &ray);
80 
81        /** Prints out statistics of the view cells.
82        */
83        virtual void PrintStatistics(ostream &s) const;
84
85        /** Post processes view cells givemŽa number of rays.
86        */
87        virtual int PostProcess(const ObjectContainer &objects,
88                                                        const VssRayContainer &rays) = 0;
89
90        /** Show visualization of the view cells.
91        */
92        virtual void Visualize(const ObjectContainer &objects,
93                                                   const VssRayContainer &sampleRays) = 0;
94
95        /** type of the view cell container.
96        */
97        virtual int GetType() const = 0;
98
99        /** Load the input viewcells. The input viewcells should be given as a collection
100                of meshes. Each mesh is assume to form a bounded polyhedron defining the interior of
101                the viewcell. The method then builds a BSP tree of these view cells.
102               
103                @param filename file to load
104                @return true on success
105    */
106    virtual bool LoadViewCells(const string filename, ObjectContainer *objects);
107
108        /** Constructs view cell from base triangle. The ViewCell is extruded along the normal vector.
109                @param the base triangle
110                @param the height of the newly created view cell
111        */
112        ViewCell *ExtrudeViewCell(const Triangle3 &baseTri, const float height) const;
113
114        /** Merges two view cells.
115                @note the piercing rays of the front and back will be ordered   
116                @returns new view cell based on the merging.
117        */
118        ViewCell *MergeViewCells(ViewCell &front, ViewCell &back) const;
119       
120        /** Generates view cell of type specified by this manager
121        */
122        virtual ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
123
124        /** Adds a new view cell to the list of predefined view cells.
125        */
126        void AddViewCell(ViewCell *viewCell);
127
128        /** Derive view cells from objects.
129        */
130        void DeriveViewCells(const ObjectContainer &objects,
131                                                 ViewCellContainer &viewCells,
132                                                 const int maxViewCells) const;
133
134        /** Sets maximal number of samples used for the
135                construction of the view cells.
136        */
137        void SetVisualizationSamples(const int visSamples);
138
139        /** Sets maximal number of samples used for the visualization of the view cells.
140        */
141        void SetConstructionSamples(const int constructionSamples);
142
143        /** Sets maximal number of samples used for the post processing of the view cells.
144        */
145        void SetPostProcessSamples(const int postProcessingSamples);
146
147        /** See set.
148        */
149        int GetVisualizationSamples() const;
150
151        /** See set.
152        */
153        int GetConstructionSamples() const;
154
155        /** See set.
156        */
157        int GetPostProcessSamples() const;
158
159        /** Returns true if view cells wer already constructed.
160        */
161        virtual bool ViewCellsConstructed() const = 0;
162
163        /** cast line segment to get a list of unique viewcells which are intersected
164                by this line segment
165        */
166 
167        virtual int CastLineSegment(const Vector3 &origin,
168                                                          const Vector3 &termination,
169                                                          ViewCellContainer &viewcells
170                                                          ) = 0;
171
172        virtual void GetPvsStatistics(PvsStatistics &stat);
173
174        /** Get a viewcell containing the specified point */
175        virtual ViewCell *GetViewCell(const Vector3 &point) = 0;
176 
177        virtual void PrintPvsStatistics(ostream &s);
178
179        /** Returns probability that view point lies in one view cell.
180        */
181        virtual float GetProbability(ViewCell *viewCell) = 0;
182
183        /** Returns render cost of a single view cell given the render cost of an object.
184        */
185        virtual float GetRendercost(ViewCell *viewCell, float objRendercost) const = 0;
186
187        /** Returns vector of loaded / generated view cells.
188        */
189        ViewCellContainer &GetViewCells();
190
191        /** Helper function used to split ray sets uniformly
192                into one that is currently used and the other that
193                is saved for later processing.
194                @param sourceRays the input ray set
195                @param maxSize the maximal number of rays that will be used
196                @param usedRays returns the used ray set
197                @param savedRays if not null, returns the saved ray set
198        */
199        void GetRaySets(const VssRayContainer &sourceRays,
200                                        const int maxSize,
201                                        VssRayContainer &usedRays,
202                                        VssRayContainer *savedRays = NULL) const;
203       
204        /** Returns accumulated area of all view cells.
205        */
206        float GetAccVcArea();
207
208        /** Returns area of one view cell.
209        */
210        virtual float GetArea(ViewCell *viewCell) const;
211
212        /** Returns volume of view cells.
213        */
214        virtual float GetVolume(ViewCell *viewCell) const;
215
216        virtual AxisAlignedBox3 GetSceneBbox() const = 0;
217
218        /** Sets the current renderer mainly for view cells statistics.
219        */
220        void SetRenderer(Renderer *renderer);
221
222        /** Computes a (random) view point in the valid view space.
223                @returns true if valid view point was found
224        */
225        virtual bool GetViewPoint(Vector3 &viewPoint) const;
226
227        /** Returns true if this view point is in the valid view space.
228        */
229        virtual bool ViewPointValid(const Vector3 &viewPoint) const;
230
231        /** Sets a view space boundary.
232        */
233        void SetViewSpaceBox(const AxisAlignedBox3 &box);
234
235        /** Creates mesh for this view cell.
236        */
237        virtual void CreateMesh(ViewCell *vc) = NULL;
238
239        /** Writes view cells to disc.
240        */
241        virtual bool ExportViewCells(const string filename);
242
243protected:
244
245        void ParseEnvironment();
246
247        /** Creates unique view cell ids.
248        */
249        void CreateUniqueViewCellIds();
250        /** Recollects view cells and resets statistics.
251        */
252        void ResetViewCells();
253       
254        /** Collects the view cells in the view cell container.
255        */
256        virtual void CollectViewCells() = 0;
257       
258        /** Evaluates view cells statistics and stores it in
259                mViewCellsStatistics.
260        */
261        void EvaluateViewCellsStats();
262
263        //-- helper functions for view cell visualization
264
265        /** Exports the view cell partition.
266        */
267        void ExportViewCellsForViz(Exporter *exporter) const;
268
269        /** Sets exporter color.
270        */
271        virtual void ExportColor(Exporter *exporter, ViewCell *vc) const = 0;
272
273        /** Exports view cell geometry.
274        */
275        virtual void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const = 0;
276
277        /** Creates meshes from the view cells.
278        */
279        void CreateViewCellMeshes();
280
281        /**
282                Exports single view cell.
283                NOTE: should be in exporter!!
284        */
285        void ExportViewCell(ViewCell *viewCell, ofstream &stream);
286
287        /// the view cell corresponding to space ouside the valid view space
288        //ViewCell *mOutOfBoundsCell;
289
290        /// Renders the view cells.
291        Renderer *mRenderer;
292
293        /// Loaded view cells
294        ViewCellContainer mViewCells;
295
296        /// maximum number of samples taken for construction of the view cells
297        int mConstructionSamples;
298        int mPostProcessSamples;
299        int mVisualizationSamples;
300
301        //-- thresholds used for view cells merge
302        int mMinPvsDif;
303        int mMinPvs;
304        int mMaxPvs;
305
306        float mTotalAreaValid;
307        float mTotalArea;
308
309        ViewCellsStatistics mViewCellsStats;
310        /// the scene bounding box
311        AxisAlignedBox3 mSceneBox;
312        /// holds the view cell meshes
313        MeshContainer mMeshContainer;
314        /// if view cells should be exported
315        bool mExportViewCells;
316        //-- visualization options
317       
318        /// color code for view cells
319        int mColorCode;
320        bool mExportGeometry;
321        bool mExportRays;
322
323        bool mViewCellsFinished;
324};
325
326
327
328/**
329        Manages different higher order operations on the view cells.
330*/
331class BspViewCellsManager: public ViewCellsManager
332{
333
334public:
335        /** Constructor taking the bsp tree and the number of samples
336                used to construct the bsp tree.
337        */
338        BspViewCellsManager(BspTree *tree, int constructionSamples);
339
340        ~BspViewCellsManager();
341
342        int Construct(const ObjectContainer &objects,
343                                  const VssRayContainer &rays);
344
345
346        int PostProcess(const ObjectContainer &objects,
347                                        const VssRayContainer &rays);
348
349        void Visualize(const ObjectContainer &objects,
350                                   const VssRayContainer &sampleRays);
351
352        int GetType() const;
353       
354        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
355
356        bool ViewCellsConstructed() const;
357
358        //void PrintStatistics(ostream &s) const;
359
360        int CastLineSegment(const Vector3 &origin,
361                                                const Vector3 &termination,
362                                                ViewCellContainer &viewcells);
363       
364        float GetProbability(ViewCell *viewCell);
365        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
366
367        AxisAlignedBox3 GetSceneBbox() const;
368
369        /** Get a viewcell containing the specified point */
370        ViewCell *GetViewCell(const Vector3 &point);
371
372        void CreateMesh(ViewCell *vc);
373
374protected:
375
376        void CollectViewCells();
377
378        /** Merges view cells front and back leaf view cell.
379        */
380        bool MergeBspLeafViewCells(BspLeaf *front, BspLeaf *back) const;
381
382        /** Returns true if front and back leaf should be merged.
383        */
384        bool ShouldMerge(BspLeaf *front, BspLeaf *back) const;
385
386        void ConstructBspRays(const VssRayContainer &rays,
387                                                  const int numSamples);
388
389        void ExportColor(Exporter *exporter, ViewCell *vc) const;
390        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;
391
392        /// the BSP tree.
393        BspTree *mBspTree;
394       
395        vector<BspRay *> mBspRays;
396
397private:
398
399        /** Exports visualization of the BSP splits.
400        */
401        void ExportSplits(const ObjectContainer &objects);
402
403        /** Exports visualization of the BSP PVS.
404        */
405        void ExportBspPvs(const ObjectContainer &objects);
406
407};
408
409/**
410        Manages different higher order operations on the KD type view cells.
411*/
412class KdViewCellsManager: public ViewCellsManager
413{
414
415public:
416
417        KdViewCellsManager(KdTree *tree);
418
419        int Construct(const ObjectContainer &objects,
420                                  const VssRayContainer &rays);
421
422        int CastLineSegment(const Vector3 &origin,
423                                                const Vector3 &termination,
424                                                ViewCellContainer &viewcells);
425
426        int PostProcess(const ObjectContainer &objects,
427                                        const VssRayContainer &rays);
428
429        void Visualize(const ObjectContainer &objects,
430                                   const VssRayContainer &sampleRays);
431
432        int GetType() const;
433
434        bool ViewCellsConstructed() const;
435
436
437        /** Prints out statistics of this approach.
438        */
439        //  virtual void PrintStatistics(ostream &s) const;
440        ViewCell *GetViewCell(const Vector3 &point) { return NULL; }
441
442        float GetProbability(ViewCell *viewCell);
443        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
444 
445        AxisAlignedBox3 GetSceneBbox() const;
446
447        void CreateMesh(ViewCell *vc);
448
449protected:
450
451        void CollectViewCells();
452        KdNode *GetNodeForPvs(KdLeaf *leaf);
453
454        void ExportColor(Exporter *exporter, ViewCell *vc) const;
455        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;
456
457        /// the BSP tree.
458        KdTree *mKdTree;
459
460        /// depth of the KD tree nodes with represent the view cells
461        int mKdPvsDepth;
462};
463
464/**
465        Manages different higher order operations on the view cells
466        for vsp kd tree view cells.
467*/
468class VspKdViewCellsManager: public ViewCellsManager
469{
470
471public:
472
473        VspKdViewCellsManager(VspKdTree *vspKdTree, int constructionSamples);
474
475        int Construct(const ObjectContainer &objects,
476                                  const VssRayContainer &rays);
477
478
479        int PostProcess(const ObjectContainer &objects,
480                                        const VssRayContainer &rays);
481
482        void Visualize(const ObjectContainer &objects,
483                                   const VssRayContainer &sampleRays);
484
485        int GetType() const;
486       
487        bool ViewCellsConstructed() const;
488
489        //virtual void PrintStatistics(ostream &s) const;
490
491        ViewCell *GenerateViewCell(Mesh *mesh) const;
492
493
494    int CastLineSegment(const Vector3 &origin,
495                                                const Vector3 &termination,
496                                                ViewCellContainer &viewcells);
497
498        ViewCell *GetViewCell(const Vector3 &point) { return NULL; }
499
500        float GetProbability(ViewCell *viewCell);
501        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
502
503        AxisAlignedBox3 GetSceneBbox() const;
504
505        void CreateMesh(ViewCell *vc);
506
507protected:
508
509        void ExportLeaves(const ObjectContainer &objects,
510                                          const VssRayContainer &sampleRays);
511
512        void CollectViewCells();
513
514        void ExportColor(Exporter *exporter, ViewCell *vc) const;
515        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;
516
517
518        /// the BSP tree.
519        VspKdTree *mVspKdTree;
520};
521
522
523
524/**
525        Manages different higher order operations on the view cells.
526*/
527class VspBspViewCellsManager: public ViewCellsManager
528{
529
530public:
531
532        VspBspViewCellsManager(VspBspTree *tree, int constructionSamples);
533        ~VspBspViewCellsManager();
534
535        int Construct(const ObjectContainer &objects,
536                                  const VssRayContainer &rays);
537
538        int PostProcess(const ObjectContainer &objects,
539                                        const VssRayContainer &rays);
540
541        void Visualize(const ObjectContainer &objects,
542                                   const VssRayContainer &sampleRays);
543
544        int GetType() const;
545       
546        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
547
548        bool ViewCellsConstructed() const;
549
550       
551        int CastLineSegment(const Vector3 &origin,
552                                                const Vector3 &termination,
553                                                ViewCellContainer &viewcells);
554
555        float GetProbability(ViewCell *viewCell);
556        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
557       
558        AxisAlignedBox3 GetSceneBbox() const;
559       
560        ViewCell *GetViewCell(const Vector3 &point);
561
562        bool GetViewPoint(Vector3 &viewPoint) const;
563
564        bool ViewPointValid(const Vector3 &viewPoint) const;
565
566        void CreateMesh(ViewCell *vc);
567
568        bool LoadViewCells(const string filename, ObjectContainer *objects);
569        bool ExportViewCells(const string filename);
570
571protected:
572
573        /** Merges the view cells.
574        */
575        void MergeViewCells(const VssRayContainer &rays,
576                                                const ObjectContainer &objects);
577       
578        void RefineViewCells(const VssRayContainer &rays);
579
580        void CollectViewCells();
581
582        /** Returns maximal depth difference of view cell
583                leaves in tree.
584        */
585        int GetMaxTreeDiff(ViewCell *vc) const;
586       
587
588        void ExportColor(Exporter *exporter, ViewCell *vc) const;
589        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;
590
591
592        /// the view space partition BSP tree.
593        VspBspTree *mVspBspTree;
594
595private:
596
597        /** Exports visualization of the BSP splits.
598        */
599        void ExportSplits(const ObjectContainer &objects,
600                                          const VssRayContainer &rays);
601
602        /** Exports visualization of the BSP PVS.
603        */
604        void ExportBspPvs(const ObjectContainer &objects,
605                                          const VssRayContainer &rays);
606
607};
608
609#endif
Note: See TracBrowser for help on using the repository browser.