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

Revision 660, 20.4 KB checked in by mattausch, 19 years ago (diff)

adding function for testing purpose

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