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

Revision 666, 20.5 KB checked in by mattausch, 18 years ago (diff)

debug version for testing subdivision quality

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        bool mShowVisualization;
484};
485
486
487
488/**
489        Manages different higher order operations on the view cells.
490*/
491class BspViewCellsManager: public ViewCellsManager
492{
493
494public:
495        /** Constructor taking the bsp tree and the number of samples
496                used to construct the bsp tree.
497        */
498        BspViewCellsManager(BspTree *tree);
499
500        ~BspViewCellsManager();
501
502        int ConstructSubdivision(const ObjectContainer &objects,
503                                  const VssRayContainer &rays);
504
505        int PostProcess(const ObjectContainer &objects,
506                                        const VssRayContainer &rays);
507
508        void Visualize(const ObjectContainer &objects,
509                                   const VssRayContainer &sampleRays);
510
511        int GetType() const;
512       
513        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
514
515        bool ViewCellsConstructed() const;
516
517        //void PrintStatistics(ostream &s) const;
518
519        int CastLineSegment(const Vector3 &origin,
520                                                const Vector3 &termination,
521                                                ViewCellContainer &viewcells);
522       
523        float GetProbability(ViewCell *viewCell);
524       
525
526        /** Get a viewcell containing the specified point */
527        ViewCell *GetViewCell(const Vector3 &point) const;
528
529        void CreateMesh(ViewCell *vc);
530
531        void ExportViewCellGeometry(Exporter *exporter,
532                                                                ViewCell *vc,
533                                                                const Plane3 *clipPlane = NULL) const;
534       
535        void CollectMergeCandidates(const VssRayContainer &rays,
536                                                                vector<MergeCandidate> &candidates);
537
538        void Finalize(ViewCell *viewCell, const bool createMesh);
539
540        bool ExportViewCells(const string filename);
541
542        ViewCell *ConstructSpatialMergeTree(BspNode *root);
543
544
545protected:
546
547
548        /** HACK
549        */
550        void AddCurrentViewCellsToHierarchy();
551
552        void CollectViewCells();
553
554        void ExportColor(Exporter *exporter, ViewCell *vc) const;
555       
556
557
558        /// the BSP tree.
559        BspTree *mBspTree;
560       
561        vector<BspRay *> mBspRays;
562
563private:
564
565        /** Exports visualization of the BSP splits.
566        */
567        void ExportSplits(const ObjectContainer &objects);
568
569        /** Exports visualization of the BSP PVS.
570        */
571        void ExportBspPvs(const ObjectContainer &objects);
572
573};
574
575/**
576        Manages different higher order operations on the KD type view cells.
577*/
578class KdViewCellsManager: public ViewCellsManager
579{
580
581public:
582
583        KdViewCellsManager(KdTree *tree);
584
585        int ConstructSubdivision(const ObjectContainer &objects,
586                                  const VssRayContainer &rays);
587
588        int CastLineSegment(const Vector3 &origin,
589                                                const Vector3 &termination,
590                                                ViewCellContainer &viewcells);
591
592        int PostProcess(const ObjectContainer &objects,
593                                        const VssRayContainer &rays);
594
595        void Visualize(const ObjectContainer &objects,
596                                   const VssRayContainer &sampleRays);
597
598        int GetType() const;
599
600        bool ViewCellsConstructed() const;
601
602        ViewCell *GenerateViewCell(Mesh *mesh) const;
603
604        /** Prints out statistics of this approach.
605        */
606        //  virtual void PrintStatistics(ostream &s) const;
607        ViewCell *GetViewCell(const Vector3 &point) const { return NULL; }
608
609        float GetProbability(ViewCell *viewCell);
610       
611
612        void CreateMesh(ViewCell *vc);
613
614        void ExportViewCellGeometry(Exporter *exporter,
615                                                                ViewCell *vc,
616                                                                const Plane3 *clipPlane = NULL) const;
617
618        void CollectMergeCandidates(const VssRayContainer &rays,
619                                                                vector<MergeCandidate> &candidates);
620
621protected:
622
623        /** Collects view cells from a hierarchy.
624        */
625        void CollectViewCells();
626
627        KdNode *GetNodeForPvs(KdLeaf *leaf);
628
629        void ExportColor(Exporter *exporter, ViewCell *vc) const;
630
631
632        /// the BSP tree.
633        KdTree *mKdTree;
634
635        /// depth of the KD tree nodes with represent the view cells
636        int mKdPvsDepth;
637};
638
639/**
640        Manages different higher order operations on the view cells
641        for vsp kd tree view cells.
642*/
643class VspKdViewCellsManager: public ViewCellsManager
644{
645
646public:
647
648        VspKdViewCellsManager(VspKdTree *vspKdTree);
649
650        int ConstructSubdivision(const ObjectContainer &objects,
651                                  const VssRayContainer &rays);
652
653
654        int PostProcess(const ObjectContainer &objects,
655                                        const VssRayContainer &rays);
656
657        void Visualize(const ObjectContainer &objects,
658                                   const VssRayContainer &sampleRays);
659
660        int GetType() const;
661       
662        bool ViewCellsConstructed() const;
663
664        //virtual void PrintStatistics(ostream &s) const;
665
666        ViewCell *GenerateViewCell(Mesh *mesh) const;
667
668
669    int CastLineSegment(const Vector3 &origin,
670                                                const Vector3 &termination,
671                                                ViewCellContainer &viewcells);
672
673        ViewCell *GetViewCell(const Vector3 &point) const { return NULL; }
674
675        float GetProbability(ViewCell *viewCell);
676
677
678        void CreateMesh(ViewCell *vc);
679
680        void ExportViewCellGeometry(Exporter *exporter,
681                                                                ViewCell *vc,
682                                                                const Plane3 *clipPlane = NULL) const;
683
684        void CollectMergeCandidates(const VssRayContainer &rays, vector<MergeCandidate> &candidates);
685
686protected:
687
688        void ExportLeaves(const ObjectContainer &objects,
689                                          const VssRayContainer &sampleRays);
690
691        void CollectViewCells();
692
693        void ExportColor(Exporter *exporter, ViewCell *vc) const;
694
695
696
697        /// the BSP tree.
698        VspKdTree *mVspKdTree;
699};
700
701
702
703/**
704        Manages different higher order operations on the view cells.
705*/
706class VspBspViewCellsManager: public ViewCellsManager
707{
708
709public:
710
711        VspBspViewCellsManager(VspBspTree *tree);
712        ~VspBspViewCellsManager();
713
714        int ConstructSubdivision(const ObjectContainer &objects,
715                                  const VssRayContainer &rays);
716
717        int PostProcess(const ObjectContainer &objects,
718                                        const VssRayContainer &rays);
719
720        void Visualize(const ObjectContainer &objects,
721                                   const VssRayContainer &sampleRays);
722
723        int GetType() const;
724       
725        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
726
727        bool ViewCellsConstructed() const;
728
729       
730        int CastLineSegment(const Vector3 &origin,
731                                                const Vector3 &termination,
732                                                ViewCellContainer &viewcells);
733
734        float GetProbability(ViewCell *viewCell);
735       
736        ViewCell *GetViewCell(const Vector3 &point) const;
737
738        bool GetViewPoint(Vector3 &viewPoint) const;
739
740        bool ViewPointValid(const Vector3 &viewPoint) const;
741
742        void CreateMesh(ViewCell *vc);
743
744        //bool LoadViewCellsGeometry(const string filename, ObjectContainer *objects);
745        bool ExportViewCells(const string filename);
746
747        int CastBeam(Beam &beam);
748
749        void ExportViewCellGeometry(Exporter *exporter,
750                                                                ViewCell *vc,
751                                                                const Plane3 *clipPlane = NULL) const;
752
753        //float GetVolume(ViewCell *viewCell) const;
754
755        void Finalize(ViewCell *viewCell, const bool createMesh);
756
757        void CollectMergeCandidates(const VssRayContainer &rays, vector<MergeCandidate> &candidates);
758
759        bool EqualToSpatialNode(ViewCell *viewCell) const;
760
761protected:
762
763       
764        /** Returns node of the spatial hierarchy corresponding to the view cell
765                if such a node exists.
766        */
767        BspNode *GetSpatialNode(ViewCell *viewCell) const;
768
769        /** HACK
770        */
771        void AddCurrentViewCellsToHierarchy();
772
773        /** Merges the view cells.
774        */
775        void MergeViewCells(const VssRayContainer &rays,
776                                                const ObjectContainer &objects);
777       
778        void RefineViewCells(const VssRayContainer &rays, const ObjectContainer &objects);
779
780        void CollectViewCells();
781
782        /** Returns maximal depth difference of view cell
783                leaves in tree.
784        */
785        int GetMaxTreeDiff(ViewCell *vc) const;
786       
787
788        void ExportColor(Exporter *exporter, ViewCell *vc) const;
789
790        void PrepareLoadedViewCells();
791
792        ViewCell *ConstructSpatialMergeTree(BspNode *root);
793
794        /// the view space partition BSP tree.
795        VspBspTree *mVspBspTree;
796
797
798private:
799
800        /** Exports visualization of the BSP splits.
801        */
802        void ExportSplits(const ObjectContainer &objects,
803                                          const VssRayContainer &rays);
804
805        /** Exports visualization of the BSP PVS.
806        */
807        void ExportBspPvs(const ObjectContainer &objects,
808                                          const VssRayContainer &rays);
809
810};
811
812
813class ViewCellsManagerFactory
814{
815
816public:
817
818        ViewCellsManager *Create(const string mName);
819
820};
821
822#endif
Note: See TracBrowser for help on using the repository browser.