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

Revision 1608, 30.6 KB checked in by bittner, 18 years ago (diff)

vsp osp tests

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