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

Revision 2570, 38.7 KB checked in by mattausch, 17 years ago (diff)
Line 
1#ifndef _ViewCellsManager_H__
2#define _ViewCellsManager_H__
3
4#include "Ray.h"
5#include "SimpleRay.h"
6#include "VssRay.h"
7#include "Containers.h"
8#include "ViewCell.h"
9
10#define TEST_PACKETS 0
11
12namespace GtpVisibilityPreprocessor {
13
14class ViewCell;
15class Intersectable;
16class RenderSimulator;
17class Renderer;
18class Mesh;
19struct Triangle3;
20class SimulationStatistics;
21class BspTree;
22class KdTree;
23class VspOspTree;
24class VspBspTree;
25class KdNode;
26class KdLeaf;
27class AxisAlignedBox3;
28class BspLeaf;
29class ViewCellsStatistics;
30class Exporter;
31class Beam;
32class Preprocessor;
33class ViewCellsTree;
34class MergeCandidate;
35class BoundingBoxConverter;
36class VspTree;
37class OspTree;
38class VspNode;
39class HierarchyManager;
40class BvHierarchy;
41class ViewCellsTree;
42class ViewCell;
43class MixtureDistribution;
44struct AxisAlignedPlane;
45struct BspRay;
46class BspTree;
47
48
49
50struct PvsFilterStatistics
51{
52        PvsFilterStatistics():
53        mAvgFilterRadius(0.0f), mLocalFilterCount(0), mGlobalFilterCount(0) {}
54       
55        float mAvgFilterRadius;
56        int mLocalFilterCount;
57        int mGlobalFilterCount;
58};
59
60/** Probably Visible Set
61*/
62class PrVs
63{
64public:
65        /// root of view cells tree
66        ViewCell *mViewCell;
67        // input parameter is the render budget for the PrVs
68        float mRenderBudget;
69};
70
71
72class LocalMergeNode
73{
74public:
75        virtual ~LocalMergeNode() {};
76        virtual bool IsLeaf() const = 0;
77};
78
79typedef pair<ViewCell *, SimpleRayContainer> ViewCellPoints;
80
81/**     Manages different higher order operations on the view cells.
82*/
83class ViewCellsManager
84{
85public:
86
87        struct PerViewCellStat
88        {
89                float pvsSize;
90                float relPvsIncrease;
91        };
92
93        struct SamplesStatistics
94        {
95                int mRays;
96                int mViewCells;
97                int mContributingRays;
98                int mPvsContributions;
99                void Reset()
100                {
101                        mRays = 0;
102                        mViewCells = 0;
103                        mContributingRays = 0;
104                        mPvsContributions = 0;
105                };
106        };
107
108        struct PvsStatistics
109        {
110                float minPvs;
111                float maxPvs;
112                float avgPvs;
113                float renderCost;
114                float avgPvsEntries;
115
116                float avgFilteredPvs;
117                float avgFilteredPvsEntries;
118
119                float avgFilterContribution;
120                float avgFilterRadius;
121                float avgFilterRatio;
122                float avgRelPvsIncrease;
123                float devRelPvsIncrease;
124                int viewcells;
125
126                float mem;
127                float renderCostRatio;
128        };
129 
130        /// view cell container types
131        enum {BSP, KD, VSP_KD, VSP_BSP, VSP_OSP};
132 
133        /// render cost evaluation type
134        enum {PER_OBJECT, PER_TRIANGLE};
135
136        friend class X3dViewCellsParseHandlers;
137
138        /** Default constructor.
139        */
140        ViewCellsManager(ViewCellsTree *viewCellsTree);
141        /** Destructor.
142        */
143        virtual ~ViewCellsManager();
144        /** Constructs view cells container taking a preprocessor
145                @returns the output rays (if not null)
146        */
147        int Construct(Preprocessor *preprocessor, VssRayContainer *outRays = NULL);
148
149        /** Constructs view cell container with a given number of samples.
150        */
151        virtual int ConstructSubdivision(const ObjectContainer &objects,
152                                                                         const VssRayContainer &rays) = 0;
153
154        /** Computes sample contributions of the rays to the view cells PVS.
155       
156                @param rays bundle of rays used to find intersections with view cells and
157                adding the contribution
158                @param addRays true if rays should be added to the PVSs of the viewcells they
159                intersect
160                @param storeViewCells true if view cells should be stored in the ray
161        */
162        virtual float ComputeSampleContributions(const VssRayContainer &rays,
163                                                     const bool addContributions,
164                                                                                         const bool storeViewCells,
165                                                                                         const bool useHitObject = false);
166
167        /** Computes sample contribution of a simgle ray to the view cells PVS.
168                @param ray finds intersections with view cells and holds the contribution
169                @param addSample if sample should be added to the pvs
170                 
171                @returns number of sample contributions
172        */
173        virtual float ComputeSampleContribution(VssRay &ray,
174                                                                                        const bool addContributions,
175                                                                                        const bool storeViewCells,
176                                                                                        const bool useHitObject = false);
177        /** Compute sample contribution only for current view cell.
178        */
179        virtual float ComputeSampleContribution(VssRay &ray,
180                                                                                        const bool addContributions,
181                                                                                        ViewCell *currentViewCell,
182                                                                                        const bool useHitObject = false);
183        /** Prints out statistics of the view cells.
184        */
185        virtual void PrintStatistics(std::ostream &s) const;
186        /** Post processes view cells givemŽa number of rays.
187        */
188        virtual int PostProcess(const ObjectContainer &objects,
189                                                        const VssRayContainer &rays) = 0;
190        /** Show visualization of the view cells.
191        */
192        virtual void Visualize(const ObjectContainer &objects,
193                                                   const VssRayContainer &sampleRays) = 0;
194        /** collect objects intersecting a given spatial box.
195        */
196        virtual void CollectObjects(const AxisAlignedBox3 &box, ObjectContainer &objects);
197        /** type of the view cell container.
198        */
199        virtual int GetType() const = 0;
200        /** Load the input viewcells. The input viewcells should be given as a collection
201                of meshes. Each mesh is assume to form a bounded polyhedron
202                defining the interior of the viewcell. The view cells manager
203                is responsible for building a hierarchy over these view cells.
204               
205                @param filename file to load
206                @return true on success
207        */
208        virtual bool LoadViewCellsGeometry(const string filename, const bool extrudeBaseTriangle);
209        /** Merges two view cells.
210                @note the piercing rays of the front and back will be ordered   
211                @returns new view cell based on the merging.
212        */
213        ViewCellInterior *MergeViewCells(ViewCell *front, ViewCell *back) const;
214        /** Merges a container of view cells.
215                @returns new view cell based on the merging.
216        */
217        ViewCellInterior *MergeViewCells(ViewCellContainer &children) const;
218        /** Generates view cell of the type specified by this manager
219        */
220        virtual ViewCell *GenerateViewCell(Mesh *mesh = NULL) const = 0;
221        /** Constructs view cell from base triangle.
222                The view cell is extruded along the normal vector.
223                @param the base triangle
224                @param the height of the newly created view cell
225        */
226        ViewCell *ExtrudeViewCell(const Triangle3 &baseTri, const float height) const;
227        /** Returns the intersectable that was hit by the ray.
228        */
229        virtual Intersectable *GetIntersectable(const VssRay &ray, const bool isTermination) const;
230        /** Sets maximal number of samples used for the
231                construction of the view cells.
232        */
233        void SetVisualizationSamples(const int visSamples);
234        /** Sets maximal number of samples used for the construction of the view cells.
235        */
236        void SetConstructionSamples(const int constructionSamples);
237        /** Sets maximal number of samples used for the visualization of the view cells.
238        */
239        void SetInitialSamples(const int initialSamples);
240        /** Sets maximal number of samples used for the post processing of the view cells.
241        */
242        void SetPostProcessSamples(const int postProcessingSamples);
243        /** See set.
244        */
245        int GetVisualizationSamples() const;
246        /** See set.
247        */
248        int GetConstructionSamples() const;
249        /** See set.
250        */
251        int GetPostProcessSamples() const;
252        /** Returns true if view cells are already constructed.
253        */
254        virtual bool ViewCellsConstructed() const = 0;
255        /** cast line segment to get a list of unique viewcells which are intersected
256                by this line segment
257        */
258        virtual int CastLineSegment(const Vector3 &origin,
259                                                            const Vector3 &termination,
260                                                            ViewCellContainer &viewcells) = 0;
261        /** Tests if this line segment intersects a particular view cell.
262        */
263        virtual bool LineSegmentIntersects(const Vector3 &origin,
264                                                                           const Vector3 &termination,
265                                                                           ViewCell *viewCell) = 0;
266        /** Returns a stats about the global pvs.
267        */
268        virtual void GetPvsStatistics(PvsStatistics &stat);
269        /** Returns the probably visible set of the view space filtered pvs.
270        */
271        virtual void GetPrVS(const Vector3 &viewPoint, PrVs &prvs, const float filterWidth);
272        /** Get a viewcell containing the specified view point.
273                @param active if the active or elementary view cell should be returned.
274        */
275        virtual ViewCell *GetViewCell(const Vector3 &point, const bool active = false) const = 0;
276        /** Returns the view cell with the given index (different from the id).
277        */
278        ViewCell *GetViewCell(const int idx) const {return mViewCells[idx];}
279        /** Prints the statistics over the view cell pvss.
280        */
281        virtual void PrintPvsStatistics(std::ostream &s);
282        /** Updates pvs of the view cell hierarchy if necessary.
283        */
284        void UpdatePvs();
285        /** Returns probability that view point lies in one view cell.
286        */
287        virtual float GetProbability(ViewCell *viewCell) = 0;
288        /** Returns render cost of a single view cell given the render cost of an object.
289        */
290        float GetRendercost(ViewCell *viewCell) const;
291        /** Returns reference to container of loaded / generated view cells.
292        */
293        ViewCellContainer &GetViewCells();
294        /** Helper function used to split ray sets uniformly
295                into one that is currently used and the other that
296                is saved for later processing.
297                @param sourceRays the input ray set
298                @param maxSize the maximal number of rays that will be used
299                @param usedRays returns the used ray set
300                @param savedRays if not null, returns the saved ray set
301        */
302        void GetRaySets(const VssRayContainer &sourceRays,
303                                        const int maxSize,
304                                        VssRayContainer &usedRays,
305                                        VssRayContainer *savedRays = NULL) const;
306        /** Returns accumulated area of all view cells.
307        */
308        float GetAccVcArea();
309        /** Returns area of one view cell.
310        */
311        virtual float GetArea(ViewCell *viewCell) const;
312        /** Returns volume of view cell.
313        */
314        virtual float GetVolume(ViewCell *viewCell) const;
315        /** Sets the current renderer mainly for view cells statistics.
316        */
317        void SetRenderer(Renderer *renderer);
318        /** Computes a (random) view point in the valid view space.
319                @returns true if valid view point was found
320        */
321        virtual bool GetViewPoint(Vector3 &viewPoint) const;
322        /** Returns the current view point given a vector for activating the halton sequence.
323        */
324        virtual bool GetViewPoint(Vector3 &viewPoint, const Vector3 &params) const;
325        /** Returns true if this view point is in the valid view space.
326        */
327        virtual bool ViewPointValid(const Vector3 &viewPoint) const;
328        /** Sets a view space boundary.
329        */
330        void SetViewSpaceBox(const AxisAlignedBox3 &box);
331        /** Returns the boundaries of the view space.
332        */
333        AxisAlignedBox3 GetViewSpaceBox() const;
334        /** Creates mesh for this view cell.
335        */
336        virtual void CreateMesh(ViewCell *vc) = NULL;
337        /** Writes view cells to disc.
338        */
339        virtual bool ExportViewCells(const string filename,
340                                                                 const bool exportPvs,
341                                                                 const ObjectContainer &objects);
342        /** Casts beam to collect view cells.
343        */
344        virtual int CastBeam(Beam &beam);
345        /** Checks if view cell is considered as valid.
346        */
347        virtual bool CheckValidity(ViewCell *vc,
348                                                           int minPvsSize,
349                                                           int maxPvsSize) const;
350        /** Resort pvss after a pass of the algorithm.
351        */
352        void  SortViewCellPvs();
353        /** Map the ray intersection objects from triangles to high level objects.
354        */
355        void DeterminePvsObjects(VssRayContainer &rays,
356                                                         const bool useHitObjects = false);
357        /** Sets validity of view cell
358        */
359        virtual void SetValidity(ViewCell *vc,
360                                                         int minPvsSize,
361                                                         int maxPvsSize) const;
362        /** sets validy of all viewcells
363        */
364        virtual void SetValidity(int minPvsSize, int maxPvsSize) const;
365        /** Set valid viewcells in the range of pvs. sorts the viewcells
366                according to the pvs and then pickups those in the ranges
367        */
368        void SetValidityPercentage(const float minValid, const float maxValid);
369        /** Returns number of valid view cells.
370        */
371    int CountValidViewcells() const;
372        /** Returns maximal allowed pvs size.
373        */
374        int GetMaxPvsSize() const;
375        /** Returns maximal allowed pvs size.
376        */
377        int GetMinPvsSize() const;
378        /** Returns maximal ratio. i.e., currentPVs / maxPvs,
379                where pvs is still considered valid.
380        */
381        float GetMaxPvsRatio() const;
382        /** Exports view cell geometry.
383        */
384        virtual void ExportViewCellGeometry(Exporter *exporter,
385                                                                                ViewCell *vc,
386                                                                                const AxisAlignedBox3 *box,
387                                                                                const AxisAlignedPlane *clipPlane = NULL
388                                                                                ) const = 0;
389        /** Brings the view cells into their final state, computes meshes and volume.
390        */
391        virtual void FinalizeViewCells(const bool createMesh);
392        /** Evaluates statistics values on view cells.
393        */
394        void EvaluateRenderStatistics(float &totalRenderCost,
395                                                                  float &expectedRenderCost,
396                                                                  float &deviation,
397                                                                  float &variance,
398                                                                  float &totalPvs,
399                                                                  float &avgRenderCost);
400        /** Returns hierarchy of the view cells.
401        */
402        ViewCellsTree *GetViewCellsTree();
403        /** Collect candidates for the view cell merge.
404        */
405        virtual void CollectMergeCandidates(const VssRayContainer &rays,
406                                                                                vector<MergeCandidate> &candidates);
407        /** Collects n view cells and stores it as the active view cells.
408        */
409        void CollectViewCells(const int n);
410        /** Sets current view cells set to active,
411                i.e., the sampling is done in this view cell set.
412        */
413        void SetViewCellsActive();
414        /** Evaluates render cost statistics of current view cell hierarchy.
415        */
416        virtual void EvalViewCellPartition();
417        /** Sets maximal size of a view cell filter.
418        */
419        void SetMaxFilterSize(const int size);
420        /** Returns maximal filter size.
421        */
422        int GetMaxFilterSize() const;
423        /** Deletes interior nodes from the tree which have negative
424                merge cost set (local merge).
425        */ 
426        void DeleteLocalMergeTree(ViewCell *vc) const;
427        /** Evaluautes histogram for a given number of view cells.
428        */
429        void EvalViewCellHistogram(const string filename, const int nViewCells);
430        /** Evaluautes histogram for a given number of view cells.
431        */
432        void EvalViewCellHistogramForPvsSize(const string filename,
433                                                                                 const int nViewCells);
434        /** Evaluautes histogram for a given vector of view cells.
435        */
436        void EvalViewCellHistogramForPvsSize(const string filename,
437                                                                                 ViewCellContainer &viewCells);
438        float ComputeRenderCost(const int tri, const int obj); //const
439        /** Sets pvs size of a view cell as a scalar. Used when storing pvs only in the leaves
440                of the hierarchy.
441        */
442        void UpdateScalarPvsSize(ViewCell *vc,
443                                                         const float pvsCost,
444                                                         const int entriesInPvs) const;
445        /** Sets render cost of a view cell as a scalar.
446        */
447        void UpdateScalarPvsCost(ViewCell *vc, const float pvsCost) const;
448
449        /** Returns bounding box of a view cell.
450        */
451        AxisAlignedBox3 GetViewCellBox(ViewCell *vc);
452        /** Exports bounding boxes of objects to file.
453        */
454        bool ExportBoundingBoxes(const string filename,
455                                                         const ObjectContainer &objects) const;
456        /** Load the bounding boxes into the container.
457        */
458        bool LoadBoundingBoxes(const string filename,
459                                                  IndexedBoundingBoxContainer &boxes) const;
460        /** Returns true if pvs should be exported together with the view cells.
461        */
462        bool GetExportPvs() const;
463        /** Efficiently merges the view cells in the container.
464        */
465        void MergeViewCellsRecursivly(ObjectPvs &pvs,
466                                                                  const ViewCellContainer &viewCells) const;
467        /** Compresses the view cells.
468        */
469        virtual void CompressViewCells();
470        /** Returns view cell with the given id.
471        */
472        ViewCell *GetViewCellById(const int id);
473        /** Returns number of view cells.
474        */
475        int GetNumViewCells() const;
476
477        bool GenerateRandomViewCells(ViewCellContainer &viewCells,
478                                                                 const int numViewCells);
479
480        bool GenerateRandomViewCells(vector<ViewCellPoints *> &viewCells,
481                                                                 const int nViewCells,
482                                                                 const int nViewPoints);
483
484
485        bool GenerateViewPoints(ViewCell *viewCell,
486                                                        const int numViewPoints,
487                                                        SimpleRayContainer &viewPoints);
488
489        bool ImportRandomViewCells(const string &filename,
490                                                           vector<ViewCellPoints *> &viewCells);
491
492        bool ImportRandomViewCells(const string &filename);
493
494        bool ExportRandomViewCells(const string &filename,
495                                                           const vector<ViewCellPoints *> &viewCells);
496
497        bool ExportRandomViewCells(const string &filename);
498
499        bool GenerateViewPoint(ViewCell *viewCell, SimpleRay &ray);
500
501        bool IsValidViewSpace(ViewCell *vc);
502
503
504        //////////////
505        // static members
506       
507        /** Loads view cells from file. The view cells manager is created with
508                respect to the loaded view cells.
509
510                @param filename the filename of the view cells
511                @param objects the scene objects
512                @param finalizeViewCells if the view cells should be post processed, i.e.,
513                           a mesh is created representing the geometry
514                @param bconverter a conversion routine working with the similarities of bounding
515                           boxes: if there is a certain similarity of overlap between
516                           bounding boxes, two tested candidate objects are considered
517                           to be the same objects
518                @returns the view cells manager if loading was successful, false otherwise
519        */
520        static ViewCellsManager *LoadViewCells(const string &filename,
521                                                                                   ObjectContainer &pvsObjects,
522                                                                                   ObjectContainer &preprocessorObjects,
523                                                                                   bool finalizeViewCells = false,
524                                                                                   BoundingBoxConverter *bconverter = NULL);
525
526        /** Convenience function assuming that there are no preprocessor objects.
527        */
528        static ViewCellsManager *LoadViewCells(const string &filename,
529                                                                                   ObjectContainer &pvsObjects,
530                                                                                   bool finalizeViewCells = false,
531                                                                                   BoundingBoxConverter *bconverter = NULL);
532
533
534        ///////////////////////
535        //-- visiblity filter options
536
537        // TODO: write own visibiltiy filter class
538        void ApplyFilter(KdTree *kdTree,
539                                         const float viewSpaceFilterSize,
540                                         const float spatialFilterSize);
541
542        // new adaptive version of the filter
543        PvsFilterStatistics ApplyFilter2(ViewCell *viewCell,
544                                                                         const bool useViewSpaceFilter,
545                                                                         const float filterSize,
546                                                                         ObjectPvs &pvs,
547                                                                         vector<AxisAlignedBox3> *filteredBoxes = NULL);
548
549        void ApplySpatialFilter(KdTree *kdTree,
550                                                        const float spatialFilterSize,
551                                                        ObjectPvs &pvs);
552
553         void ApplyFilter(ViewCell *viewCell,
554                                          KdTree *kdTree,
555                                          const float viewSpaceFilterSize,
556                                          const float spatialFilterSize,
557                                          ObjectPvs &pvs);
558
559        float GetFilterWidth();
560
561        float GetAbsFilterWidth();
562        /** Returns the bounding box of filter width.
563        */
564        AxisAlignedBox3 GetFilterBBox(const Vector3 &viewPoint,
565                                                                  const float width) const;
566
567
568
569        //////////////////////////////////////////////////////////////////
570
571
572        /** If true, the kd nodes are stored instead of the object pvs.
573        */
574        void SetStoreKdPvs(const bool storeKdPvs);
575
576        /** Returns true if the kd nodes are stored instead of the object pvs.
577        **/
578        bool GetStoreKdPVs() const;
579
580        /** Exports single view cells for visualization.
581                @param objects the scene objects
582                @param limit the maximal number of output view cells
583                @param sortViewCells if the view cells should be sorted by pvs size
584                @param exportPvs if the pvs should also be exported
585                @param exportRays if sample rays should be exported as well
586                @param maxRays maximum number of rays to export
587                @param prefix the prefix for the output file
588                @param visRays additional rays
589        */
590        virtual void ExportSingleViewCells(const ObjectContainer &objects,
591                                                                           const int maxViewCells,
592                                                                           const bool sortViewCells,
593                                                                           const bool exportPvs,
594                                                                           const bool exportRays,
595                                                                           const int maxRays,
596                                                                           const string &prefix,
597                                                                           VssRayContainer *visRays = NULL) = NULL;
598
599
600        void ResetPvs();
601
602        Preprocessor *GetPreprocessor() const {
603                return mPreprocessor;
604        }
605
606        void SetPreprocessor(Preprocessor *p) {
607                mPreprocessor = p;
608        }
609
610        vector<ViewCellPoints *> *GetViewCellPoints()
611        {
612                return &mViewCellPoints;
613        }
614
615        void UpdatePvsForEvaluation();
616
617protected:
618
619        void ComputeViewCellContribution(ViewCell *viewCell,
620                                                                         VssRay &ray,
621                                                                         Intersectable *obj,
622                                                                         const Vector3 &pt,
623                                                                         const bool addRays);
624
625        void MergeViewCellsRecursivly(ObjectPvs &pvs,
626                                                                  const ViewCellContainer &viewCells,
627                                                                  const int leftIdx,
628                                                                  const int rightIdx) const;
629        /** Intersects box with the tree and returns the number of intersected boxes.
630                @returns number of view cells found
631        */
632        virtual int ComputeBoxIntersections(const AxisAlignedBox3 &box,
633                                                                                ViewCellContainer &viewCells) const;
634        /** Tests the visibility filter functionality.
635        */
636        virtual void TestFilter(const ObjectContainer &objects) {};
637        /** If the view cells tree was already constructed or not.
638        */
639        bool ViewCellsTreeConstructed() const;
640        /** Requests preprocessor to cast samplesPerPass samples of a specific type.
641        */
642        int CastPassSamples(const int samplesPerPass,
643                                                const vector<int> &strategies,
644                                                VssRayContainer &vssRays) const;
645        /** cast samples for the purpose of evaluating the view cells solution
646        */
647        int CastEvaluationSamples(const int samplesPerPass,
648                                                          VssRayContainer &passSamples);// const;
649        /** Parse the options from the environment file.
650        */
651        void ParseEnvironment();
652        /** Creates unique view cell ids.
653        */
654        void CreateUniqueViewCellIds();
655        /** Finalizes, i.e., creates mesh, volume, area etc. for the view cell.
656        */
657        virtual void Finalize(ViewCell *viewCell, const bool createMesh);
658        /** Recollects view cells and resets statistics.
659        */
660        void ResetViewCells();
661        /** Sets this view cell to active.
662        */
663        void SetViewCellActive(ViewCell *vc) const;
664        /** Collects the view cells in the view cell container.
665        */
666        virtual void CollectViewCells() = 0;
667        /** Evaluates view cells statistics and stores it in mViewCellsStatistics.
668        */
669        void EvaluateViewCellsStats();
670       
671
672        void UpdateStatsForViewCell(ViewCell *viewCell, Intersectable *obj);
673
674
675        ///////////////////////
676        //-- helper functions for view cell visualization
677
678        /** Exports the view cell partition.
679        */
680        void ExportViewCellsForViz(Exporter *exporter,
681                                                           const AxisAlignedBox3 *box,
682                                                           const bool colorCode,
683                                                           const AxisAlignedPlane *clipPlane) const;
684        /** Sets exporter color.
685        */
686        virtual void ExportColor(Exporter *exporter,
687                                                         ViewCell *vc,
688                                                         const int colorCode) const;
689        /** Creates meshes from the view cells.
690        */
691        void CreateViewCellMeshes();
692        /** Creates clip plane for visualization.
693        */
694        void CreateClipPlane();
695
696        AxisAlignedPlane *GetClipPlane();
697
698        void ExportMergedViewCells(const ObjectContainer &objects);
699
700
701        ///////////////////////
702
703        /** Returns volume of the view space.
704        */
705        virtual float GetViewSpaceVolume();
706        /** Prepares the view cells for sampling after loading them from disc.
707        */
708        virtual void PrepareLoadedViewCells() {};
709        /** Constructs local view cell merge hierarchy.
710        */
711        ViewCell *ConstructLocalMergeTree(ViewCell *currentViewCell,
712                                          const ViewCellContainer &viewCells);
713        /** Constructs local view cell merge hierarchy based solely on similarity with the
714                current viewcell
715        */
716        ViewCell *ConstructLocalMergeTree2(ViewCell *currentViewCell,
717                                                                           const ViewCellContainer &viewCells);
718        /** Updates pvs of all view cells for statistical evaluation after some more sampling
719        */
720        void UpdatePvsForEvaluation(ViewCell *root, ObjectPvs &pvs);
721        /** Export statistics of the view cells tree.
722        */
723        virtual void ExportStats(const string &mergeStats);
724        /** Loads view cells in binary mode.
725        */
726        static ViewCellsManager *LoadViewCellsBinary(const string &filename,
727                                                                                                 ObjectContainer &pvsObjects,
728                                                                                                 bool finalizeViewCells,
729                                                 BoundingBoxConverter *bconverter);
730        /** This helper function loads the bounding boxes for a binary solution.
731        */
732        static void LoadIndexedBoundingBoxesBinary(IN_STREAM &stream,
733                                                       IndexedBoundingBoxContainer &iboxes);
734
735
736
737        ///////////
738        //-- members
739
740        ofstream mStats;
741        Preprocessor *mPreprocessor;
742        /// if bounding boxes should be exported together with the view cells
743        bool mExportBboxesForPvs;
744        /// the clip plane for visualization
745        AxisAlignedPlane mClipPlaneForViz;
746        /// if the visualization is using the clip plane
747        bool mUseClipPlaneForViz;
748        /// Renders the view cells.
749        Renderer *mRenderer;
750        /// Loaded view cells
751        ViewCellContainer mViewCells;
752        /// the view cell hierarchy (i.e., the logical description of view cells)
753        ViewCellsTree *mViewCellsTree;
754       
755        std::vector<int> mStrategies;
756
757        /** if the values in the view cell leaves and the interiors are up to date
758                this is meant for lazy storing of the pvs, where only a scalar indicating
759                pvs size is stored in interiors and not the pvs itself.
760        */
761        bool mViewCellPvsIsUpdated;
762
763        /// maximum number of samples for the view cell construction
764        int mConstructionSamples;
765        int mSamplesPerPass;
766        int mInitialSamples;
767        int mPostProcessSamples;
768        int mVisualizationSamples;
769
770        int mEvaluationSamples;
771
772        float mTotalAreaValid;
773        float mTotalArea;
774
775        int mMaxPvsSize;
776        int mMinPvsSize;
777        float mMaxPvsRatio;
778
779        int mSamplingType;
780        int mEvaluationSamplingType;
781        int mNumActiveViewCells;
782        bool mCompressViewCells;
783
784        vector<ViewCellPoints *> mViewCellPoints;
785
786        /// holds the current view cell statistics
787        ViewCellsStatistics mCurrentViewCellsStats;
788
789        /// the scene bounding box
790        AxisAlignedBox3 mViewSpaceBox;
791       
792        /// if view cells should be exported
793        bool mExportViewCells;
794        // if only valid view cells should be considered for processing
795        bool mOnlyValidViewCells;
796        /// if rays should be used to collect merge candidates
797        bool mUseRaysForMerge;
798        /// if there should be an additional merge step after the subdivision
799        bool mMergeViewCells;
800        /// the width of the box filter
801        float mFilterWidth;
802        /// Maximal size of the filter in terms of contributing view cells
803        int mMaxFilterSize;
804        /// only for debugging: stores some rays used during view cell construction
805        VssRayContainer storedRays;
806        /// if kd node based pvs is used for preprocessing
807        bool mUseKdPvs;
808        /// types of distributions used for sampling
809        MixtureDistribution *mMixtureDistribution;
810
811
812        //////////////////
813        //-- visualization options
814       
815        /// color code for view cells visualization
816        bool mShowVisualization;
817        int mColorCode;
818        bool mExportGeometry;
819        bool mExportRays;
820        bool mViewCellsFinished;
821        bool mEvaluateViewCells;
822
823        /// if pvs should be exported with view cells
824        bool mExportPvs;
825
826        /// if view cells geometry should be used from other sources
827        bool mUsePredefinedViewCells;
828        /// the weight for one triangle in the heuristics
829        float mTriangleWeight;
830        /// the weight for one object (= one entity issued with one draw call) in the heuristics
831        float mObjectWeight;
832
833        vector<PerViewCellStat> mPerViewCellStat;
834        SamplesStatistics mSamplesStat;
835};
836
837
838/** Manages different higher order operations on the view cells.
839*/
840class BspViewCellsManager: public ViewCellsManager
841{
842
843public:
844        /** Constructor taking the bsp tree and the number of samples
845                used to construct the bsp tree.
846        */
847        BspViewCellsManager(ViewCellsTree *viewCellsTree, BspTree *tree);
848
849        ~BspViewCellsManager();
850
851        int ConstructSubdivision(const ObjectContainer &objects,
852                                  const VssRayContainer &rays);
853
854        int PostProcess(const ObjectContainer &objects,
855                                        const VssRayContainer &rays);
856
857        void Visualize(const ObjectContainer &objects,
858                                   const VssRayContainer &sampleRays);
859
860        int GetType() const;
861       
862        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
863
864        bool ViewCellsConstructed() const;
865
866        //void PrintStatistics(ostream &s) const;
867
868        int CastLineSegment(const Vector3 &origin,
869                                                const Vector3 &termination,
870                                                ViewCellContainer &viewcells);
871       
872        /** Returns the probability that the view point lies
873                in this view cells.
874        */
875        float GetProbability(ViewCell *viewCell);
876
877        /** Get a viewcell containing the specified point.
878        */
879        ViewCell *GetViewCell(const Vector3 &point, const bool active = false) const;
880
881        /** Creates mesh for this view cell.
882        */
883        void CreateMesh(ViewCell *vc);
884
885        void ExportViewCellGeometry(Exporter *exporter,
886                                                                ViewCell *vc,
887                                                                const AxisAlignedBox3 *box,
888                                                                const AxisAlignedPlane *clipPlane = NULL
889                                                                ) const;
890       
891        void CollectMergeCandidates(const VssRayContainer &rays,
892                                                                vector<MergeCandidate> &candidates);
893
894        void Finalize(ViewCell *viewCell, const bool createMesh);
895
896        bool ExportViewCells(const string filename,
897                                                 const bool exportPvs,
898                                                 const ObjectContainer &objects);
899
900        /** Constructs merge hierarchy which corresponds to the spatial hierarchy.
901        */
902        ViewCell *ConstructSpatialMergeTree(BspNode *root);
903
904        void ExportSingleViewCells(const ObjectContainer &objects,
905                                                           const int maxViewCells,
906                                                           const bool sortViewCells,
907                                                           const bool exportPvs,
908                                                           const bool exportRays,
909                                                           const int maxRays,
910                                                           const string &prefix,
911                                                           VssRayContainer *visRays = NULL);
912
913        bool LineSegmentIntersects(const Vector3 &origin,
914                                                           const Vector3 &termination,
915                                                           ViewCell *viewCell);
916
917protected:
918
919        void CollectViewCells();
920       
921        /// the BSP tree.
922        BspTree *mBspTree;
923        vector<BspRay *> mBspRays;
924
925private:
926
927        /** Constructs a spatial merge tree only 2 levels deep.
928        */
929        ViewCell *ConstructDummyMergeTree(BspNode *root);
930        /** Exports visualization of the BSP splits.
931        */
932        void ExportSplits(const ObjectContainer &objects);
933        /** test if subdivision is valid in terms of volume / area.
934        */
935        void TestSubdivision();
936};
937
938
939/**
940        Manages different higher order operations on the KD type view cells.
941*/
942class KdViewCellsManager: public ViewCellsManager
943{
944
945public:
946
947        KdViewCellsManager(ViewCellsTree *viewCellsTree, KdTree *tree);
948
949        int ConstructSubdivision(const ObjectContainer &objects,
950                                                         const VssRayContainer &rays);
951
952        int CastLineSegment(const Vector3 &origin,
953                                                const Vector3 &termination,
954                                                ViewCellContainer &viewcells);
955
956        int PostProcess(const ObjectContainer &objects,
957                                        const VssRayContainer &rays);
958
959        void Visualize(const ObjectContainer &objects,
960                                   const VssRayContainer &sampleRays);
961
962        int GetType() const;
963
964        bool ViewCellsConstructed() const;
965
966        ViewCell *GenerateViewCell(Mesh *mesh) const;
967
968        /** Prints out statistics of this approach.
969        */
970        //  virtual void PrintStatistics(ostream &s) const;
971        ViewCell *GetViewCell(const Vector3 &point, const bool active = false) const
972        { return NULL; }
973
974        float GetProbability(ViewCell *viewCell);
975       
976        void CreateMesh(ViewCell *vc);
977
978        void ExportViewCellGeometry(Exporter *exporter,
979                                                                ViewCell *vc,
980                                                                const AxisAlignedBox3 *box,
981                                                                const AxisAlignedPlane *clipPlane = NULL) const;
982
983
984        void CollectMergeCandidates(const VssRayContainer &rays,
985                                                                vector<MergeCandidate> &candidates);
986
987        void ExportSingleViewCells(const ObjectContainer &objects,
988                                                           const int maxViewCells,
989                                                           const bool sortViewCells,
990                                                           const bool exportPvs,
991                                                           const bool exportRays,
992                                                           const int maxRays,
993                                                           const string &prefix,
994                                                           VssRayContainer *visRays = NULL);
995
996        bool LineSegmentIntersects(const Vector3 &origin,
997                                                           const Vector3 &termination,
998                                                           ViewCell *viewCell);
999
1000protected:
1001
1002        /** Collects view cells from a hierarchy.
1003        */
1004        void CollectViewCells();
1005
1006        KdNode *GetNodeForPvs(KdLeaf *leaf);
1007
1008        ////////////////////////////////////////
1009
1010        /// the BSP tree.
1011        KdTree *mKdTree;
1012
1013        /// depth of the KD tree nodes with represent the view cells
1014        int mKdPvsDepth;
1015
1016
1017};
1018
1019
1020/** Manages different higher order operations on the view cells.
1021*/
1022class VspBspViewCellsManager: public ViewCellsManager
1023{
1024
1025public:
1026
1027        VspBspViewCellsManager(ViewCellsTree *viewCellsTree, VspBspTree *tree);
1028        ~VspBspViewCellsManager();
1029
1030        int ConstructSubdivision(const ObjectContainer &objects,
1031                                                         const VssRayContainer &rays);
1032
1033        int PostProcess(const ObjectContainer &objects,
1034                                        const VssRayContainer &rays);
1035
1036        void Visualize(const ObjectContainer &objects,
1037                                   const VssRayContainer &sampleRays);
1038
1039        int GetType() const;
1040       
1041        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
1042
1043        bool ViewCellsConstructed() const;
1044       
1045        int CastLineSegment(const Vector3 &origin,
1046                                                const Vector3 &termination,
1047                                                ViewCellContainer &viewcells);
1048
1049        float GetProbability(ViewCell *viewCell);
1050       
1051        ViewCell *GetViewCell(const Vector3 &point, const bool active = false) const;
1052
1053        bool GetViewPoint(Vector3 &viewPoint) const;
1054
1055        bool ViewPointValid(const Vector3 &viewPoint) const;
1056
1057        void CreateMesh(ViewCell *vc);
1058
1059        bool ExportViewCells(const string filename,
1060                                                 const bool exportPvs,
1061                                                 const ObjectContainer &objects);
1062
1063        int CastBeam(Beam &beam);
1064       
1065        void ExportViewCellGeometry(Exporter *exporter,
1066                                                                ViewCell *vc,
1067                                                                const AxisAlignedBox3 *box,
1068                                                                const AxisAlignedPlane *clipPlane = NULL) const;
1069
1070
1071        void Finalize(ViewCell *viewCell, const bool createMesh);
1072
1073        void CollectMergeCandidates(const VssRayContainer &rays,
1074                                                                vector<MergeCandidate> &candidates);
1075
1076        void ExportSingleViewCells(const ObjectContainer &objects,
1077                                                           const int maxViewCells,
1078                                                           const bool sortViewCells,
1079                                                           const bool exportPvs,
1080                                                           const bool exportRays,               
1081                                                           const int maxRays,
1082                                                           const string &prefix,
1083                                                           VssRayContainer *visRays = NULL);
1084
1085       
1086        bool LineSegmentIntersects(const Vector3 &origin,
1087                                                           const Vector3 &termination,
1088                                                           ViewCell *viewCell);
1089
1090protected:
1091
1092        int ComputeBoxIntersections(const AxisAlignedBox3 &box,
1093                                                                ViewCellContainer &viewCells) const;
1094       
1095        /** Merges view cells according to some criteria
1096        */
1097        void MergeViewCells(const VssRayContainer &rays,
1098                                                const ObjectContainer &objects);
1099       
1100        void RefineViewCells(const VssRayContainer &rays, const ObjectContainer &objects);
1101
1102        void CollectViewCells();
1103
1104        /** Returns maximal depth difference of view cell
1105                leaves in tree.
1106        */
1107        int GetMaxTreeDiff(ViewCell *vc) const;
1108
1109        /** Prepare view cells for use after loading them from disc.
1110        */
1111        void PrepareLoadedViewCells();
1112
1113        /** Constructs merge hierarchy which corresponds to the spatial hierarchy.
1114        */
1115        ViewCell *ConstructSpatialMergeTree(BspNode *root);
1116
1117        /// HACK for testing visibility filter functionality
1118        void TestFilter(const ObjectContainer &objects);
1119
1120        /** Visualization of the pvs difference to exact visubility using
1121                from point queries.
1122        */
1123        void VisualizeWithFromPointQueries();
1124
1125        /** Evaluate from point queries for the current scene.
1126        */
1127        void EvalFromPointQueries();
1128
1129        /** Exports visualization of the BSP splits.
1130        */
1131        void ExportSplits(const ObjectContainer &objects,
1132                                          const VssRayContainer &rays);
1133
1134
1135        /////////////////////////
1136
1137        /// the view space partition BSP tree.
1138        VspBspTree *mVspBspTree;
1139
1140
1141private:
1142
1143        /** test if subdivision is valid in terms of volume / area.
1144        */
1145        void TestSubdivision();
1146};
1147
1148
1149
1150/**     Manages different higher order operations on the view cells.
1151*/
1152class VspOspViewCellsManager: public ViewCellsManager
1153{
1154        friend class ViewCellsParseHandlers;
1155        friend class ViewCellsManager;
1156
1157public:
1158
1159        /** This version takes a view cells tree and a hierarchy
1160                as input.
1161        */
1162        VspOspViewCellsManager(ViewCellsTree *vcTree,
1163                                                   const string &hierarchyType);
1164       
1165        ~VspOspViewCellsManager();
1166
1167        int ConstructSubdivision(const ObjectContainer &objects,
1168                                                         const VssRayContainer &rays);
1169
1170        int PostProcess(const ObjectContainer &objects,
1171                                        const VssRayContainer &rays);
1172
1173        void Visualize(const ObjectContainer &objects,
1174                                   const VssRayContainer &sampleRays);
1175
1176        int GetType() const;
1177       
1178        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
1179
1180        virtual Intersectable *GetIntersectable(const VssRay &ray,
1181                                                                                        const bool isTermination) const;
1182
1183        bool ViewCellsConstructed() const;
1184
1185        int CastLineSegment(const Vector3 &origin,
1186                                                const Vector3 &termination,
1187                                                ViewCellContainer &viewcells);
1188
1189        bool LineSegmentIntersects(const Vector3 &origin,
1190                                                           const Vector3 &termination,
1191                                                           ViewCell *viewCell);
1192
1193        float GetProbability(ViewCell *viewCell);
1194       
1195        ViewCell *GetViewCell(const Vector3 &point,
1196                                                  const bool active = false) const;
1197
1198        bool GetViewPoint(Vector3 &viewPoint) const;
1199
1200        bool ViewPointValid(const Vector3 &viewPoint) const;
1201
1202        void CreateMesh(ViewCell *vc);
1203
1204        bool ExportViewCells(const string filename,
1205                                                 const bool exportPvs,
1206                                                 const ObjectContainer &objects);
1207
1208        int CastBeam(Beam &beam);
1209
1210        void Finalize(ViewCell *viewCell, const bool createMesh);
1211
1212        void ExportSingleViewCells(const ObjectContainer &objects,
1213                                                           const int maxViewCells,
1214                                                           const bool sortViewCells,
1215                                                           const bool exportPvs,
1216                                                           const bool exportRays,
1217                                                           const int maxRays,
1218                                                           const string &prefix,
1219                                                           VssRayContainer *visRays = NULL);
1220        /** See parent class.
1221        */
1222        virtual void FinalizeViewCells(const bool createMesh);
1223
1224        bool ExportViewCellsBinary(const string filename,
1225                                                           const bool exportPvs,
1226                                                           const ObjectContainer &objects);
1227
1228#if TEST_PACKETS
1229
1230        float ComputeSampleContributions(const VssRayContainer &rays,
1231                                             const bool addContributions,
1232                                                                         const bool storeViewCells,
1233                                                                         const bool useHitObjects = false);
1234#endif
1235
1236
1237protected:
1238
1239        /** View cells manager taking a view cells tree and a hierarchy as input.
1240        */
1241        VspOspViewCellsManager(ViewCellsTree *vcTree, HierarchyManager *hm);
1242       
1243        virtual void EvalViewCellPartition();
1244        /** Exports view cell geometry.
1245        */
1246        void ExportViewCellGeometry(Exporter *exporter,
1247                                                                ViewCell *vc,
1248                                                                const AxisAlignedBox3 *box,
1249                                                                const AxisAlignedPlane *clipPlane = NULL) const;
1250
1251        int ComputeBoxIntersections(const AxisAlignedBox3 &box,
1252                                                                ViewCellContainer &viewCells) const;
1253       
1254        void CollectViewCells();
1255
1256        virtual void CompressViewCells();
1257        /** Prepare view cells for use after loading them from disc.
1258        */
1259        void PrepareLoadedViewCells();
1260        /** Constructs merge hierarchy which corresponds to the spatial hierarchy.
1261        */
1262        ViewCell *ConstructSpatialMergeTree(VspNode *root);
1263        /** Exports visualization of the PVS.
1264        */
1265        void ExportPvs(const ObjectContainer &objects, const VssRayContainer &rays);
1266        /** Returns a hierarchy manager of the given name.
1267        */
1268        static HierarchyManager *CreateHierarchyManager(const string &name);
1269        /** collect objects intersecting a given spatial box
1270        */
1271        virtual void CollectObjects(const AxisAlignedBox3 &box, ObjectContainer &objects);
1272        /** Update the cost of pvss for hierarchy objects.
1273        */
1274        float UpdateObjectCosts();
1275
1276
1277        ////////////////
1278
1279        /** Fast view cell loader in binary mode.
1280        */
1281        friend ViewCellsManager *ViewCellsManager::
1282                LoadViewCellsBinary(const std::string &filename,
1283                                    ObjectContainer &pvsObjects,
1284                                                        bool finalizeViewCells,
1285                                                        BoundingBoxConverter *bconverter);
1286
1287
1288        /** Print statistics about the view cells compression.
1289        */
1290        static void PrintCompressionStats(HierarchyManager *hm, const int pvsEntries);
1291
1292
1293        ////////////////////
1294
1295        /// if we the objects are compressed after evaluation
1296        /// this makes only sense for testing purpose
1297        bool mCompressObjects;
1298        /// hierarchy manager managing view space / object subdivision.
1299        HierarchyManager *mHierarchyManager;
1300};
1301
1302
1303}
1304
1305#endif
Note: See TracBrowser for help on using the repository browser.