source: GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.h @ 664

Revision 664, 20.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#include "ViewCellBsp.h"
9
10class ViewCell;
11class Intersectable;
12class RenderSimulator;
13class Renderer;
14class Mesh;
15struct Triangle3;
16class SimulationStatistics;
17class BspTree;
18class KdTree;
19class VspKdTree;
20class VspBspTree;
21class KdNode;
22class KdLeaf;
23class VspKdTree;
24class AxisAlignedBox3;
25class BspLeaf;
26class ViewCellsStatistics;
27class Exporter;
28class Beam;
29class Preprocessor;
30class ViewCellsTree;
31class MergeCandidate;
32
33struct BspRay;
34
35/**
36        Manages different higher order operations on the view cells.
37*/
38class ViewCellsManager
39{
40
41public:
42  struct PvsStatistics {
43        int minPvs;
44        int maxPvs;
45        float avgPvs;
46        int viewcells;
47  };
48 
49  /// view cell container types
50  enum {BSP, KD, VSP_KD, VSP_BSP};
51 
52        /** Constructor taking the initial and construction samples.
53                @param initialSamples the maximal number of samples used for creating the hierarchy
54                of view cells
55                @param constructionSamples the maximal number of samples used for construction
56        */
57        ViewCellsManager(const int initialSamples, const int constructionSamples);
58
59        ViewCellsManager();
60
61        virtual ~ViewCellsManager();
62
63        /** Constructs view cells container taking a preprocessor
64                @returns the output rays (if not null)
65        */
66        int Construct(Preprocessor *preprocessor, VssRayContainer *outRays = NULL);
67
68        /** Constructs view cell container with a given number of samples.
69        */
70        virtual int ConstructSubdivision(const ObjectContainer &objects,
71                                                  const VssRayContainer &rays) = 0;
72
73        /** Computes sample contributions of the rays to the view cells PVS.
74       
75                @param rays bundle of rays used to find intersections with view cells and
76                adding the contribution
77                @param addRays true if rays should be added to the PVSs of the viewcells they
78                intersect
79                @param storeViewCells true if view cells should be stored in the ray
80        */
81  float ComputeSampleContributions(const VssRayContainer &rays,
82                                                                   const bool addContributions,
83                                                                   const bool storeViewCells);
84
85  /** Add sample contributions to the viewcells they intersect */
86  void AddSampleContributions(const VssRayContainer &rays);
87 
88
89        /** Computes sample contribution of a simgle ray to the view cells PVS.
90                @param ray finds intersections with view cells and holds the contribution
91                @param castRay true if ray should be cast to gain the information, false if ray
92                is already holding the information and need not be recast.
93         
94                @returns number of sample contributions
95        */
96        virtual float ComputeSampleContributions(VssRay &ray,
97                                                                                         const bool addRays,
98                                                                                         const bool storeViewCells);
99
100        virtual void AddSampleContributions(VssRay &ray);
101
102        /** Prints out statistics of the view cells.
103        */
104        virtual void PrintStatistics(ostream &s) const;
105
106        /** Post processes view cells givemŽa number of rays.
107        */
108        virtual int PostProcess(const ObjectContainer &objects,
109                                                        const VssRayContainer &rays) = 0;
110
111        /** Show visualization of the view cells.
112        */
113        virtual void Visualize(const ObjectContainer &objects,
114                                                   const VssRayContainer &sampleRays) = 0;
115
116        /** type of the view cell container.
117        */
118        virtual int GetType() const = 0;
119
120        /** Load the input viewcells. The input viewcells should be given as a collection
121                of meshes. Each mesh is assume to form a bounded polyhedron defining the interior of
122                the viewcell. The method then builds a BSP tree of these view cells.
123               
124                @param filename file to load
125                @return true on success
126    */
127    virtual bool LoadViewCellsGeometry(const string filename);
128
129       
130        /** Constructs view cell from base triangle. The ViewCell is extruded along the normal vector.
131                @param the base triangle
132                @param the height of the newly created view cell
133        */
134        ViewCell *ExtrudeViewCell(const Triangle3 &baseTri, const float height) const;
135
136        /** Merges two view cells.
137                @note the piercing rays of the front and back will be ordered   
138                @returns new view cell based on the merging.
139        */
140        ViewCellInterior *MergeViewCells(ViewCell *front, ViewCell *back) const;
141
142        /** Merges a container of view cells.
143                @returns new view cell based on the merging.
144        */
145        ViewCellInterior *MergeViewCells(ViewCellContainer &children) const;
146       
147        /** Generates view cell of type specified by this manager
148        */
149        virtual ViewCell *GenerateViewCell(Mesh *mesh = NULL) const = 0;
150
151        /** Adds a new view cell to the list of predefined view cells.
152        */
153        void AddViewCell(ViewCell *viewCell);
154
155        /** Derive view cells from objects.
156        */
157        void DeriveViewCells(const ObjectContainer &objects,
158                                                 ViewCellContainer &viewCells,
159                                                 const int maxViewCells) const;
160
161        /** Sets maximal number of samples used for the
162                construction of the view cells.
163        */
164        void SetVisualizationSamples(const int visSamples);
165
166        /** Sets maximal number of samples used for the construction of the view cells.
167        */
168        void SetConstructionSamples(const int constructionSamples);
169
170        /** Sets maximal number of samples used for the visualization of the view cells.
171        */
172        void SetInitialSamples(const int initialSamples);
173
174        /** Sets maximal number of samples used for the post processing of the view cells.
175        */
176        void SetPostProcessSamples(const int postProcessingSamples);
177
178        /** See set.
179        */
180        int GetVisualizationSamples() const;
181
182        /** See set.
183        */
184        int GetConstructionSamples() const;
185
186        /** See set.
187        */
188        int GetPostProcessSamples() const;
189
190        /** Returns true if view cells wer already constructed.
191        */
192        virtual bool ViewCellsConstructed() const = 0;
193
194        /** cast line segment to get a list of unique viewcells which are intersected
195                by this line segment
196        */
197 
198        virtual int CastLineSegment(const Vector3 &origin,
199                                                          const Vector3 &termination,
200                                                          ViewCellContainer &viewcells
201                                                          ) = 0;
202
203        virtual void GetPvsStatistics(PvsStatistics &stat);
204
205        /** Get a viewcell containing the specified point */
206        virtual ViewCell *GetViewCell(const Vector3 &point) const = 0;
207 
208        virtual void PrintPvsStatistics(ostream &s);
209
210        /** Returns probability that view point lies in one view cell.
211        */
212        virtual float GetProbability(ViewCell *viewCell) = 0;
213
214        /** Returns render cost of a single view cell given the render cost of an object.
215        */
216        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
217
218        /** Returns container of loaded / generated view cells.
219        */
220        ViewCellContainer &GetViewCells();
221
222        /** Helper function used to split ray sets uniformly
223                into one that is currently used and the other that
224                is saved for later processing.
225                @param sourceRays the input ray set
226                @param maxSize the maximal number of rays that will be used
227                @param usedRays returns the used ray set
228                @param savedRays if not null, returns the saved ray set
229        */
230        void GetRaySets(const VssRayContainer &sourceRays,
231                                        const int maxSize,
232                                        VssRayContainer &usedRays,
233                                        VssRayContainer *savedRays = NULL) const;
234       
235        /** Returns accumulated area of all view cells.
236        */
237        float GetAccVcArea();
238
239        /** Returns area of one view cell.
240        */
241        virtual float GetArea(ViewCell *viewCell) const;
242
243        /** Returns volume of view cell.
244        */
245        virtual float GetVolume(ViewCell *viewCell) const;
246
247        /** Sets the current renderer mainly for view cells statistics.
248        */
249        void SetRenderer(Renderer *renderer);
250
251        /** Computes a (random) view point in the valid view space.
252                @returns true if valid view point was found
253        */
254        virtual bool GetViewPoint(Vector3 &viewPoint) const;
255
256        /** Returns true if this view point is in the valid view space.
257        */
258        virtual bool ViewPointValid(const Vector3 &viewPoint) const;
259
260        /** Sets a view space boundary.
261        */
262        void SetViewSpaceBox(const AxisAlignedBox3 &box);
263
264        AxisAlignedBox3 GetViewSpaceBox() const;
265
266        /** Creates mesh for this view cell.
267        */
268        virtual void CreateMesh(ViewCell *vc) = NULL;
269
270        /** Writes view cells to disc.
271        */
272        virtual bool ExportViewCells(const string filename);
273
274        /** Casts beam to collect view cells.
275        */
276        virtual int CastBeam(Beam &beam);
277
278        /** Checks if view cell is considered as valid.
279        */
280        virtual bool CheckValidity(ViewCell *vc,
281                                                           int minPvsSize,
282                                                           int maxPvsSize) const;
283
284       
285        /** Sets validity of view cell
286        */
287        virtual void SetValidity(ViewCell *vc,
288                                                         int minPvsSize,
289                                                         int maxPvsSize) const;
290
291  /** sets validy of all viewcells */
292        virtual void SetValidity(
293                                                         int minPvsSize,
294                                                         int maxPvsSize) const;
295
296
297        /** set valid viewcells in the range of pvs. sorts the viewcells
298          according to the pvs and then pickups those in the ranges */
299
300   
301        void SetValidityPercentage(const float minValid,        const float maxValid);
302
303    int CountValidViewcells() const;
304
305        /** Returns maximal allowed pvs size.
306        */
307        int GetMaxPvsSize() const;
308
309        /** Returns maximal allowed pvs size.
310        */
311        int GetMinPvsSize() const;
312
313        /** Returns maximal ratio. i.e., currentPVs / maxPvs,
314                where pvs is still considered valid.
315        */
316        float GetMaxPvsRatio() const;
317
318        /** Exports view cell geometry.
319        */
320        virtual void ExportViewCellGeometry(Exporter *exporter,
321                                                                                ViewCell *vc,
322                                                                                const Plane3 *clipPlane = NULL) const = 0;
323
324        virtual void FinalizeViewCells(const bool createMesh);
325
326
327        /** Loads view cells from file. The view cells manager is created with
328                respect to the loaded view cells.
329
330                @returns the view cells manager if loading was successful, false otherwise
331        */
332        static ViewCellsManager *LoadViewCells(const string filename,
333                                                                                   ObjectContainer *objects);
334
335        /** Evaluates statistics values on view cells.
336        */
337        void EvaluateRenderStatistics(float &totalRenderCost,
338                                                                  float &expectedRenderCost,
339                                                                  float &deviation,
340                                                                  float &variance,
341                                                                  int &totalPvs,
342                                                                  float &avgRenderCost);
343
344
345        /** Returns hierarchy of the view cells.
346        */
347        ViewCellsTree *GetViewCellsTree();
348
349        virtual void CollectMergeCandidates(const VssRayContainer &rays,
350                                                                                vector<MergeCandidate> &candidates) = 0;
351
352        void CollectViewCells(const int n);
353
354        /** Returns true if this (logical) view cell is equal to a spatial node.
355        */
356        virtual bool EqualToSpatialNode(ViewCell *viewCell) const { return false;}
357
358        /** Sets current view cells set to active, i.e., the sampling is done in this view cell set.
359        */
360        void SetViewCellsActive();
361
362        /** Evaluates worth of current view cell hierarchy.
363        */
364        void EvalViewCellPartition(Preprocessor *preprocessor);
365
366protected:
367
368
369        /**
370                if the view cells tree was already constructed or not.
371        */
372        bool ViewCellsTreeConstructed() const;
373
374        int CastPassSamples(const int samplesPerPass,
375                                                const int sampleType,
376                                                VssRayContainer &vssRays) const;
377
378        void ParseEnvironment();
379
380        /** Creates unique view cell ids.
381        */
382        void CreateUniqueViewCellIds();
383
384        /** Finalizes, i.e., creates mesh, volume, area etc. for the view cell.
385        */
386        virtual void Finalize(ViewCell *viewCell, const bool createMesh);
387
388        /** Recollects view cells and resets statistics.
389        */
390        void ResetViewCells();
391       
392        /** Collects the view cells in the view cell container.
393        */
394        virtual void CollectViewCells() = 0;
395       
396        /** Evaluates view cells statistics and stores it in
397                mViewCellsStatistics.
398        */
399        void EvaluateViewCellsStats();
400
401        //-- helper functions for view cell visualization
402
403        /** Exports the view cell partition.
404        */
405        void ExportViewCellsForViz(Exporter *exporter) const;
406
407        /** Sets exporter color.
408        */
409        virtual void ExportColor(Exporter *exporter, ViewCell *vc) const = 0;
410
411
412        virtual float GetViewSpaceVolume();
413       
414        /** Creates meshes from the view cells.
415        */
416        void CreateViewCellMeshes();
417
418        /** Takes different measures to prepares the view cells after loading them from disc.
419        */
420        virtual void PrepareLoadedViewCells() {};
421
422        /** Creates clip plane for visualization.
423        */
424        void CreateClipPlane();
425
426        Plane3 mClipPlane;
427        bool mUseClipPlaneForViz;
428
429
430        /// Renders the view cells.
431        Renderer *mRenderer;
432
433        /// Loaded view cells
434        ViewCellContainer mViewCells;
435
436        ViewCellsTree *mViewCellsTree;
437
438        /// maximum number of samples taken for construction of the view cells
439        int mConstructionSamples;
440        int mSamplesPerPass;
441        int mInitialSamples;
442        int mPostProcessSamples;
443        int mVisualizationSamples;
444
445        float mTotalAreaValid;
446        float mTotalArea;
447
448        int mMaxPvsSize;
449        int mMinPvsSize;
450        float mMaxPvsRatio;
451
452        int mSamplingType;
453        int mNumActiveViewCells;
454        bool mCompressViewCells;
455
456        ViewCellsStatistics mCurrentViewCellsStats;
457        /// the scene bounding box
458        AxisAlignedBox3 mViewSpaceBox;
459        /// holds the view cell meshes
460        MeshContainer mMeshContainer;
461        /// if view cells should be exported
462        bool mExportViewCells;
463
464        //bool mMarchTree);
465        bool mOnlyValidViewCells;
466
467        /// if rays should be used to collect merge candidates
468        bool mUseRaysForMerge;
469       
470        bool mMergeViewCells;
471       
472        //-- visualization options
473       
474        /// color code for view cells
475        int mColorCode;
476        bool mExportGeometry;
477        bool mExportRays;
478
479        bool mViewCellsFinished;
480
481        bool mEvaluateViewCells;
482};
483
484
485
486/**
487        Manages different higher order operations on the view cells.
488*/
489class BspViewCellsManager: public ViewCellsManager
490{
491
492public:
493        /** Constructor taking the bsp tree and the number of samples
494                used to construct the bsp tree.
495        */
496        BspViewCellsManager(BspTree *tree);
497
498        ~BspViewCellsManager();
499
500        int ConstructSubdivision(const ObjectContainer &objects,
501                                  const VssRayContainer &rays);
502
503        int PostProcess(const ObjectContainer &objects,
504                                        const VssRayContainer &rays);
505
506        void Visualize(const ObjectContainer &objects,
507                                   const VssRayContainer &sampleRays);
508
509        int GetType() const;
510       
511        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
512
513        bool ViewCellsConstructed() const;
514
515        //void PrintStatistics(ostream &s) const;
516
517        int CastLineSegment(const Vector3 &origin,
518                                                const Vector3 &termination,
519                                                ViewCellContainer &viewcells);
520       
521        float GetProbability(ViewCell *viewCell);
522       
523
524        /** Get a viewcell containing the specified point */
525        ViewCell *GetViewCell(const Vector3 &point) const;
526
527        void CreateMesh(ViewCell *vc);
528
529        void ExportViewCellGeometry(Exporter *exporter,
530                                                                ViewCell *vc,
531                                                                const Plane3 *clipPlane = NULL) const;
532       
533        void CollectMergeCandidates(const VssRayContainer &rays,
534                                                                vector<MergeCandidate> &candidates);
535
536        void Finalize(ViewCell *viewCell, const bool createMesh);
537
538        bool ExportViewCells(const string filename);
539
540        ViewCell *ConstructSpatialMergeTree(BspNode *root);
541
542
543protected:
544
545
546        /** HACK
547        */
548        void AddCurrentViewCellsToHierarchy();
549
550        void CollectViewCells();
551
552        void ExportColor(Exporter *exporter, ViewCell *vc) const;
553       
554
555
556        /// the BSP tree.
557        BspTree *mBspTree;
558       
559        vector<BspRay *> mBspRays;
560
561private:
562
563        /** Exports visualization of the BSP splits.
564        */
565        void ExportSplits(const ObjectContainer &objects);
566
567        /** Exports visualization of the BSP PVS.
568        */
569        void ExportBspPvs(const ObjectContainer &objects);
570
571};
572
573/**
574        Manages different higher order operations on the KD type view cells.
575*/
576class KdViewCellsManager: public ViewCellsManager
577{
578
579public:
580
581        KdViewCellsManager(KdTree *tree);
582
583        int ConstructSubdivision(const ObjectContainer &objects,
584                                  const VssRayContainer &rays);
585
586        int CastLineSegment(const Vector3 &origin,
587                                                const Vector3 &termination,
588                                                ViewCellContainer &viewcells);
589
590        int PostProcess(const ObjectContainer &objects,
591                                        const VssRayContainer &rays);
592
593        void Visualize(const ObjectContainer &objects,
594                                   const VssRayContainer &sampleRays);
595
596        int GetType() const;
597
598        bool ViewCellsConstructed() const;
599
600        ViewCell *GenerateViewCell(Mesh *mesh) const;
601
602        /** Prints out statistics of this approach.
603        */
604        //  virtual void PrintStatistics(ostream &s) const;
605        ViewCell *GetViewCell(const Vector3 &point) const { return NULL; }
606
607        float GetProbability(ViewCell *viewCell);
608       
609
610        void CreateMesh(ViewCell *vc);
611
612        void ExportViewCellGeometry(Exporter *exporter,
613                                                                ViewCell *vc,
614                                                                const Plane3 *clipPlane = NULL) const;
615
616        void CollectMergeCandidates(const VssRayContainer &rays,
617                                                                vector<MergeCandidate> &candidates);
618
619protected:
620
621        /** Collects view cells from a hierarchy.
622        */
623        void CollectViewCells();
624
625        KdNode *GetNodeForPvs(KdLeaf *leaf);
626
627        void ExportColor(Exporter *exporter, ViewCell *vc) const;
628
629
630        /// the BSP tree.
631        KdTree *mKdTree;
632
633        /// depth of the KD tree nodes with represent the view cells
634        int mKdPvsDepth;
635};
636
637/**
638        Manages different higher order operations on the view cells
639        for vsp kd tree view cells.
640*/
641class VspKdViewCellsManager: public ViewCellsManager
642{
643
644public:
645
646        VspKdViewCellsManager(VspKdTree *vspKdTree);
647
648        int ConstructSubdivision(const ObjectContainer &objects,
649                                  const VssRayContainer &rays);
650
651
652        int PostProcess(const ObjectContainer &objects,
653                                        const VssRayContainer &rays);
654
655        void Visualize(const ObjectContainer &objects,
656                                   const VssRayContainer &sampleRays);
657
658        int GetType() const;
659       
660        bool ViewCellsConstructed() const;
661
662        //virtual void PrintStatistics(ostream &s) const;
663
664        ViewCell *GenerateViewCell(Mesh *mesh) const;
665
666
667    int CastLineSegment(const Vector3 &origin,
668                                                const Vector3 &termination,
669                                                ViewCellContainer &viewcells);
670
671        ViewCell *GetViewCell(const Vector3 &point) const { return NULL; }
672
673        float GetProbability(ViewCell *viewCell);
674
675
676        void CreateMesh(ViewCell *vc);
677
678        void ExportViewCellGeometry(Exporter *exporter,
679                                                                ViewCell *vc,
680                                                                const Plane3 *clipPlane = NULL) const;
681
682        void CollectMergeCandidates(const VssRayContainer &rays, vector<MergeCandidate> &candidates);
683
684protected:
685
686        void ExportLeaves(const ObjectContainer &objects,
687                                          const VssRayContainer &sampleRays);
688
689        void CollectViewCells();
690
691        void ExportColor(Exporter *exporter, ViewCell *vc) const;
692
693
694
695        /// the BSP tree.
696        VspKdTree *mVspKdTree;
697};
698
699
700
701/**
702        Manages different higher order operations on the view cells.
703*/
704class VspBspViewCellsManager: public ViewCellsManager
705{
706
707public:
708
709        VspBspViewCellsManager(VspBspTree *tree);
710        ~VspBspViewCellsManager();
711
712        int ConstructSubdivision(const ObjectContainer &objects,
713                                  const VssRayContainer &rays);
714
715        int PostProcess(const ObjectContainer &objects,
716                                        const VssRayContainer &rays);
717
718        void Visualize(const ObjectContainer &objects,
719                                   const VssRayContainer &sampleRays);
720
721        int GetType() const;
722       
723        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
724
725        bool ViewCellsConstructed() const;
726
727       
728        int CastLineSegment(const Vector3 &origin,
729                                                const Vector3 &termination,
730                                                ViewCellContainer &viewcells);
731
732        float GetProbability(ViewCell *viewCell);
733       
734        ViewCell *GetViewCell(const Vector3 &point) const;
735
736        bool GetViewPoint(Vector3 &viewPoint) const;
737
738        bool ViewPointValid(const Vector3 &viewPoint) const;
739
740        void CreateMesh(ViewCell *vc);
741
742        //bool LoadViewCellsGeometry(const string filename, ObjectContainer *objects);
743        bool ExportViewCells(const string filename);
744
745        int CastBeam(Beam &beam);
746
747        void ExportViewCellGeometry(Exporter *exporter,
748                                                                ViewCell *vc,
749                                                                const Plane3 *clipPlane = NULL) const;
750
751        //float GetVolume(ViewCell *viewCell) const;
752
753        void Finalize(ViewCell *viewCell, const bool createMesh);
754
755        void CollectMergeCandidates(const VssRayContainer &rays, vector<MergeCandidate> &candidates);
756
757        bool EqualToSpatialNode(ViewCell *viewCell) const;
758
759protected:
760
761       
762        /** Returns node of the spatial hierarchy corresponding to the view cell
763                if such a node exists.
764        */
765        BspNode *GetSpatialNode(ViewCell *viewCell) const;
766
767        /** HACK
768        */
769        void AddCurrentViewCellsToHierarchy();
770
771        /** Merges the view cells.
772        */
773        void MergeViewCells(const VssRayContainer &rays,
774                                                const ObjectContainer &objects);
775       
776        void RefineViewCells(const VssRayContainer &rays, const ObjectContainer &objects);
777
778        void CollectViewCells();
779
780        /** Returns maximal depth difference of view cell
781                leaves in tree.
782        */
783        int GetMaxTreeDiff(ViewCell *vc) const;
784       
785
786        void ExportColor(Exporter *exporter, ViewCell *vc) const;
787
788        void PrepareLoadedViewCells();
789
790        ViewCell *ConstructSpatialMergeTree(BspNode *root);
791
792        /// the view space partition BSP tree.
793        VspBspTree *mVspBspTree;
794
795
796private:
797
798        /** Exports visualization of the BSP splits.
799        */
800        void ExportSplits(const ObjectContainer &objects,
801                                          const VssRayContainer &rays);
802
803        /** Exports visualization of the BSP PVS.
804        */
805        void ExportBspPvs(const ObjectContainer &objects,
806                                          const VssRayContainer &rays);
807
808};
809
810
811class ViewCellsManagerFactory
812{
813
814public:
815
816        ViewCellsManager *Create(const string mName);
817
818};
819
820#endif
Note: See TracBrowser for help on using the repository browser.