US 20020000986 A1 Abstract A system for determining nearest leaf bounds per leaf cone of a cone hierarchy based on a dual-tree search of the cone hierarchy and a bound hierarchy. A processor, performing the dual-tree search, maintains for each leaf cone a collection of nearest leaf bounds. The collection evolves as the dual-tree search progresses. The processor may maintain the N closest leaf bounds for each leaf cone. The processor may classify leaf bounds as occluders or non-occluders, and store any non-occluder closer than the N
^{th }occluder. Alternatively, the processor may assign an occlusion metric value to each leaf bound, and may maintain closest leaf bounds so that the sum of their occlusion metric values is less than or equal to an occlusion threshold. The dual-tree search may be followed by a search of the bound hierarchy with probe cones of the leaf cones. Claims(61) 1. A method for displaying graphical objects on a display device, the method comprising:
searching a cone tree structure and a bound tree structure to determine a plurality of nearest graphical objects for a subset of leaf cones of the cone tree structure, wherein, for a first leaf cone of the cone tree structure and a first leaf bound of the bound tree structure, said searching includes:
(a) computing a first cone-hull separation value for the first leaf bound with respect to the first leaf cone;
(b) determining if the first cone-hull separation value satisfies a first inequality condition with respect to a first visibility extent value associated with the first leaf cone;
wherein, if the first cone-hull separation value satisfies the first inequality condition with respect to the first visibility extent value associated with the first leaf cone, said searching further includes:
(c) updating a sequence of nearest object values corresponding to the first leaf cone based on the first cone-hull separation value;
(d) updating a sequence of nearest object pointers corresponding to the first leaf cone with a first pointer associated with the first leaf bound; and
transmitting the sequence of nearest object pointers for the subset of leaf cones for use in selecting which of said graphical objects to render for display. 2. The method of determining if the first leaf bound is an occluder; performing (c) and (d) in response to the first leaf bound being an occluder, and the first cone-hull separation value satisfying the first inequality condition with respect to the first visibility extent value associated with the first leaf cone. 3. The method of 4. The method of 5. The method of determining a sequence position for the first cone-hull separation value in the sequence of nearest object values; wherein (c) comprises injecting the first cone-hull separation value into the sequence of nearest object values based on the sequence position; wherein (d) comprises injecting the first pointer into the sequence of nearest object pointers based on the sequence position. 6. The method of 7. The method of 8. The method of setting the first visibility extent value equal to a last object value of the sequence of nearest object values. 9. The method of flushing (i) nearest object values greater than a last object value of the sequence of nearest object values and (ii) corresponding object pointers from a non-occluder buffer associated with the first leaf cone. 10. The method of 11. The method of 12. The method of determining a sequence position for the first cone-hull separation value in the sequence of nearest object values; wherein (c) comprises injecting the first cone-hull separation value into the sequence of nearest object values based on the sequence position; wherein (d) comprises injecting the first pointer into the sequence of nearest object pointers based on the sequence position; wherein (e) comprises injecting the occlusion metric value into the sequence of occlusion values based on the sequence position. 13. The method of determining an updated cumulative sum by adding the cumulative sum and the occlusion metric value of the first leaf bound; determining if the updated cumulative sum exceeds an occlusion threshold. 14. The method of flushing (i) nearest object values beyond a critical index from the sequence of nearest object values, (ii) nearest object pointers beyond the critical index from the sequence of nearest object pointers, and (iii) occlusion values beyond the critical index from the sequence of occlusion values, if the updated cumulative sum of occlusion values exceeds the occlusion threshold. 15. The method of 16. The method of 17. The method of receiving a cone pointer which points to the cone tree structure stored in a memory;
receiving a bound pointer which points to the bound tree structure stored in the memory, wherein leaf bounds of the bound tree structure approximate a collection of graphical objects.
18. The method of 19. The method of 20. The method of flushing (i) nearest object values beyond a critical index from the sequence of nearest object values, (ii) nearest object pointers beyond the critical index from the sequence of nearest object pointers, and (iii) occlusion values beyond the critical index from the sequence of occlusion values, wherein a cumulative sum of the sequence of occlusion values up through the critical index is less than or equal to the occlusion threshold. 21. A computer system for displaying graphical objects on a display device, the computer system comprising:
a memory subsystem configured to store a cone tree structure and a bound tree structure, wherein leaf bounds of the bound tree structure approximate a collection of graphical objects; a processor configured to execute a visibility search algorithm stored in the memory subsystem; wherein, in response to an execution of the visibility search algorithm, the processor is configured to search the cone tree structure and the bound tree structure to determine one or more nearest graphical objects for a subset of leaf cones of the cone tree structure, wherein said processor is configured to (a) compute a first cone-hull separation value for a first leaf bound with respect to a first leaf cone, (b) determine if the first cone-hull separation value satisfies a first inequality condition with respect to a first visibility extent value associated with the first leaf cone, and, in response to the first cone-hull separation value satisfying the first inequality condition with respect to the first visibility extent value, to (c) update a sequence of nearest object values corresponding to the first leaf cone based on the first cone-hull separation value and (d) update a sequence of nearest object pointers corresponding to the first leaf cone with a first pointer associated with the first leaf bound; wherein the processor is further configured to transmit the sequence of nearest object pointers for the subset of leaf cones for use in selecting which of said graphical objects to render for display. 22. The computer system of determine if the first leaf bound is an occluder; and perform (c) and (d) in response to the first leaf bound being an occluder, and the first cone-hull separation value satisfying the first inequality condition with respect to the first visibility extent value associated with the first leaf cone. 23. The computer system of store the first pointer associated with the first leaf bound and the first cone-hull separation value in a non-occluder buffer corresponding to the first leaf cone in response to determining that the first leaf bound is a first non-occluder. 24. The computer system of transmit one or more pointers from the non-occluder buffer corresponding to the first leaf cone for use in selecting which of said graphical objects to render for display, wherein the one or more pointers correspond to one or more second non-occluders.
25. The computer system of wherein said processor is configured perform (c) by injecting the first cone-hull separation value into the sequence of nearest object values based on the sequence position, and (d) by injecting the first pointer into the sequence of nearest object pointers based on the sequence position.
26. The computer system of 27. The computer system of 28. The computer system of 29. The computer system of 30. The computer system of 31. The computer system of 32. The computer system of determine a sequence position for the first cone-hull separation value in the sequence of nearest object values; wherein said processor is further configured to perform (c) by injecting the first cone-hull separation value into the sequence of nearest object values based on the sequence position, (d) by injecting the first pointer into the sequence of nearest object pointers based on the sequence position, and (e) by injecting the occlusion metric value into the sequence of occlusion values based on the sequence position. 33. The computer system of determine an updated cumulative sum by adding the cumulative sum and the occlusion metric value of the first leaf bound; and determine if the updated cumulative sum exceeds an occlusion threshold. 34. The computer system of flush (i) nearest object values beyond a critical index from the sequence of nearest object values, (ii) nearest object pointers beyond the critical index from the sequence of nearest object pointers, and (iii) occlusion values beyond the critical index from the sequence of occlusion values, if the updated cumulative sum of occlusion values exceeds the occlusion threshold. 35. The computer system of set the first visibility extent value equal to a critical object value in the sequence of nearest object values corresponding to the critical index if the updated cumulative sum of occlusion values exceeds the occlusion threshold. 36. The computer system of 37. The computer system of receive a cone pointer which points to the cone tree structure stored in the memory subsystem; receive a bound pointer which points to the bound tree structure stored in the memory subsystem, wherein leaf bounds of the bound tree structure approximate a collection of graphical objects. 38. The computer system of 39. The computer system of 40. The computer system of 41. A method for displaying visible objects on a display device, the method comprising:
(a) searching a cone tree structure and a bound tree structure to determine a first visible object for a plurality of leaf cones of the cone tree structure; (b) searching the bound tree structure with respect to probe cones of a first leaf cone of the cone tree structure to determine one or more additional visible objects for the first leaf cone; and (c) transmitting an indication of the first visible object and the one or more additional visible objects for at least the first leaf cone for rendering and display. 42. The method of 43. The method of 44. The method of 45. The method of 46. The method of computing a first cone-hull separation value between a first subbound of the first bound and the first probe cone;
determining if the first cone-hull separation value satisfies a first inequality condition with respect to a first visibility value associated with the first probe cone;
searching the first subbound with respect to the first probe cone in response to the first cone-hull separation value satisfying the inequality condition with respect to the first visibility value.
47. The method of comparing the first cone-hull separation value to a limiting value associated with the first leaf cone; and
performing said search of the first subbound with respect to the first probe cone if the first cone-hull separation value satisfies a second inequality condition with respect to the limiting value and the first inequality condition with respect to the first visibility value of the first probe cone.
48. The method of 49. The method of computing a first cone-hull separation value between a first leaf bound of the bound tree structure and a first probe cone of the probe cones;
determining if the first cone-hull separation value satisfies an inequality condition with respect to a probe visibility value associated with the first probe cone;
updating a visible object pointer corresponding to the first probe cone with a first pointer associated with the first leaf bound;
updating the probe visibility value based on the first cone-hull separation value.
50. The method of 51. The method of 52. A computer system for displaying visible objects on a display device, the computer system comprising:
a memory configured to store a cone hierarchy and a bound hierarchy, wherein leaf bounds of the bound hierarchy approximate a collection of graphical objects; and a processor configured to execute visibility software stored in the memory; wherein, in response to an execution of the visibility software, the processor is configured to (a) search said cone hierarchy and said bound hierarchy to determine a first visible object for a plurality of leaf cones of the cone hiearchy, (b) search the bound hierarchy using probe cones of a first leaf cone of the cone hierarchy to determine one or more additional visible objects for the first leaf cone, and (c) transmit an indication of the first visible object and the one or more additional visible objects for at least the first leaf cone for rendering and display. 53. The computer system of 54. The computer system of 55. The computer system of 56. The computer system of computing a first cone-hull separation value between a first subbound of the first bound and the first probe cone; determining if the first cone-hull separation value satisfies a first inequality condition with respect to a first visibility value associated with the first probe cone; and searching the first subbound with respect to the first probe cone in response to the first cone-hull separation value satisfying the inequality condition with respect to the first visibility value. 57. The computer system of comparing the first cone-hull separation value to a limiting value associated with the first leaf cone; and performing said search of the first subbound with respect to the first probe cone if the first cone-hull separation value satisfies a second inequality condition with respect to the limiting value and the first inequality condition with respect to the first visibility value of the first probe cone. 58. The computer system of 59. The computer system of computing a first cone-hull separation value between a first leaf bound of the bound tree structure and a first probe cone of the probe cones; determining if the first cone-hull separation value satisfies an inequality condition with respect to a probe visibility value associated with the first probe cone; updating a visible object pointer corresponding to the first probe cone with a first pointer associated with the first leaf bound; updating the probe visibility value based on the first cone-hull separation value. 60. The computer system of 61. The computer system of Description [0001] This application claims the benefit of U.S. Provisional Application No. 60/214,939 filed on Jun. 29, 2000 titled “Mitigating the Effects of Object Approximations”. [0002] This application is a continuation-in-part of U.S. patent application Ser. No. 09/247,466 filed on Feb. 9, 1999 titled “Visible-Object Determination For Interactive Visualization”, which claims the benefit of U.S. Provisional Application No. 60/074,868 filed on Feb. 17, 1998 titled “Visible-Object Determination for Interactive Visualization”. [0003] 1. Field of the Invention [0004] The present invention relates generally to the field of computer graphics, and more particularly, to the problem of determining the set of objects (and portions of objects) visible from a defined viewpoint in a graphics environment. Description of the Related Art Visualization software has proven to be very useful in evaluating three-dimensional designs long before the physical realization of those designs. In addition, visualization software has shown its cost effectiveness by allowing engineering companies to find design problems early in the design cycle, thus saving them significant amounts of money. Unfortunately, the need to view more and more complex scenes has outpaced the ability of graphics hardware systems to display them at reasonable frame rates. As scene complexity grows, visualization software designers need to carefully use the rendering resource provided by graphic hardware pipelines. [0005] A hardware pipeline wastes rendering bandwidth when it discards triangle work. Rendering bandwidth waste can be decreased by not asking the pipeline to draw triangles that it will discard. Various software methods for reducing pipeline waste have evolved over time. Each technique reduces waste at a different point within the pipeline. As an example, software culling of objects falling outside the view frustum can significantly reduce discards in a pipeline's clipping computation. Similarly, software culling of backfacing triangles can reduce discards in a pipeline's lighting computation. [0006] The z-buffer is the final part of the graphics pipeline that discards work. In essence, the z-buffer retains visible surfaces and discards those not visible. As scene complexity increases, especially in walk through and CAD environments, the number of occluded surfaces rises rapidly and as a result the number of surfaces that the z-buffer discards rises as well. A frame's average depth complexity determines roughly how much work (and thus rendering bandwidth) the z-buffer discards. In a frame with a per-pixel depth complexity of d the pipeline's effectiveness is 1/d. As depth complexity rises, the hardware pipeline thus becomes proportionally less and less effective. [0007] Software occlusion culling has been proposed as an additional tool for improving rendering effectiveness. A visualization program which performs occlusion culling effectively increases the overall rendering bandwidth of the graphics hardware by not asking the hardware pipeline to draw. occluded objects. Computing a scene's visible objects is the complementary problem to that of occlusion culling. Rather than removing occluded objects from the set of objects in a scene or even a frustum culled scene, a program instead computes which objects are visible and draws just those. A simple visualization program can compute the set of visible objects and draw those objects from the current viewpoint, allowing the pipeline to remove backfacing polygons and the z-buffer to remove any non-visible surfaces. [0008] One technique for computing the visible object set uses ray casting. RealEyes [Sowizral, H. A., Zikan, K., Esposito, C., Janin, A., Mizell, D., “RealEyes: A System for Visualizing Very Large Physical Structures”, SIGGRAPH '94, Visual Proceedings, 1994, p. 228], a system that implemented the ray casting technique, was demonstrated in SIGGRAPH 1994's BOOM room. At interactive rates, visitors could “walk” around the interior of a Boeing 747 or explore the structures comprising Space Station Freedom's lab module. [0009] The intuition for the use of rays in determining visibility relies on the properties of light. The first object encountered along a ray is visible since it alone can reflect light into the viewer's eye. Also, that object interposes itself between the viewer and all succeeding objects along the ray making them not visible. In the discrete world of computer graphics, it is difficult to propagate a continuum of rays. So a discrete subset of rays is invariably used. Of course, this implies that visible objects or segments of objects smaller than the resolution of the ray sample may be missed and not discovered. This is because rays guarantee correct determination of visible objects only up to the density of the ray-sample. FIG. 1 illustrates the ray-based method of visible object detection. Rays that interact with one or more objects are marked with a dot at the point of their first contact with an object. It is this point of first contact that determines the value of the screen pixel corresponding to the ray. Also observe that the object denoted A is small enough to be entirely missed by the given ray sample. [0010] Visible-object determination has its roots in visible-surface determination. Foley et al. [Foley, J., van Dam, A., Feiner, S. and Hughes, J. Computer Graphics: Principles and Practice, 2nd ed., Addison-Wesley, Chapter 15, pp.649-718, 1996] divide visible-surface determination approaches into two broad groups: image-precision and object-precision algorithms. Image precision algorithms typically operate at the resolution of the display device and tend to have superior performance computationally. Object precision approaches operate in object space—usually performing object to object comparisons. [0011] A prototypical image-precision visible-surface-determination algorithm casts rays from the viewpoint through the center of each display pixel to determine the nearest visible surface along each ray. The list of applications of visible-surface ray casting (or ray tracing) is long and distinguished. Appel [“Some Techniques for Shading Machine Rendering of Solids”, SJCC'68, pp. 37-45, 1968] uses ray casting for shading. Goldstein and Nagel [Mathematical Applications Group, Inc., “3-D Simulated Graphics Offered by Service Bureau,” Datamation, 13(1), February 1968, p. 69.; see also Goldstein, R. A. and Nagel, R., “3-D Visual Simulation”, Simulation, 16(1), pp.25-31, 1971] use ray casting for boolean set operations. Kay et al. [Kay, D. S. and Greenberg, D., “Transparency for Computer Synthesized Images,” SIGGRAPH'79, pp.158-164] and Whitted [“An Improved Illumination Model for Shaded Display”, CACM, 23(6), pp.343-349, 1980] use ray tracing for refraction and specular reflection computations. Airey et al. [Airey, J. M., Rohlf, J. H. and Brooks, Jr. F. P., “Towards Image Realism with Interactive Update Rates in Complex Virtual Building Environments”, ACM SIGGRAPH Symposium on Interactive 3D Graphics, 24, 2(1990), pp. 41-50] uses ray casting for computing the portion of a model visible from a given cell. [0012] Another approach to visible-surface determination relies on sending beams or cones into a database of surfaces [see Dadoun et al., “Hierarchical approachs to hidden surface intersection testing”, Proceeedings of Graphics Interface '82, Toronto, May 1982, 49-56; see also Dadoun et al., “The geometry of beam tracing”, In Joseph O'Rourke, ed., Proceeedings of the Symposium on Computational Geometry, pp.55-61, ACM Press, New York, 1985]. Essentially, beams become a replacement for rays. The approach usually results in compact beams decomposing into a set of possibly non-connected cone(s) after interacting with an object. [0013] A variety of spatial subdivision schemes have been used to impose a spatial structure on the objects in a scene. The following four references pertain to spatial subdivision schemes: (a) Glassner, “Space subdivision for fast ray tracing,” IEEE CG&A, 4(10):15-22, October 1984; (b) Jevans et al., “Adaptive voxel subdivision for ray tracing,” Proceedings Graphics Interface '89, 164-172, June 1989; (c) Kaplan, M. “The use of spatial coherence in ray tracing,” in Techniques for Computer Graphics . . . , Rogers, D. and Earnshaw, R. A. (eds), Springer-Verlag, New York, 1987; and (d) Rubin, S. M. and Whitted, T. “A 3-dimensional representation for fast rendering of complex scenes,” Computer Graphics, 14(3):110-116, July 1980. [0014] Kay et al. [Kay, T. L. and Kajiya, J. T., “Ray Tracing Complex Scenes”, SIGGRAPH 1986, pp. 269-278, 1986], concentrating on the computational aspect of ray casting, employed a hierarchy of spatial bounding volumes in conjunction with rays, to determine the visible objects along each ray. Of course, the spatial hierarchy needs to be precomputed. However, once in place, such a hierarchy facilitates a recursive computation for finding objects. If the environment is stationary, the same data-structure facilitates finding the visible object along any ray from any origin. [0015] Teller et al. [Teller, S. and Sequin, C. H., “Visibility Preprocessing for Interactive Walkthroughs,” SIGGRAPH '91, pp.61-69] use preprocessing to full advantage in visible-object computation by precomputing cell-to-cell visibility. Their approach is essentially an object precision approach and they report over [0016] In a different approach to visibility computation, Greene et al. [Greene, N., Kass, M., and Miller, G., “Hierarchical z-Buffer Visibility,” SIGGRAPH '93, pp.231-238] use a variety of hierarchical data structures to help exploit the spatial structure inherent in object space (an octree of objects), the image structure inherent in pixels (a Z pyramid), and the temporal structure inherent in frame-by-frame rendering (a list of previously visible octree nodes). The Z-pyramid permits the rapid culling of large portions of the model by testing for visibility using a rapid scan conversion of the cubes in the octree. [0017] As used herein, the term “octree” refers to a data structure derived from a hierarchical subdivision of a three-dimensional space based on octants. The three-dimensional space may be divided into octants based on three mutually perpendicular partitioning planes. Each octant may be further partitioned into eight sub-octants based on three more partitioning planes. Each sub-octant may be partitioned into eight sub-suboctants, and so forth. Each octant, sub-octant, etc., may be assigned a node in the data structure. For more information concerning octrees, see pages 550-555, 559-560 and 695-698 of [0018] The depth complexity of graphical environments continues to increase in response to consumer demand for realism and performance. Thus, the efficiency of an algorithm for visible object determination has a direct impact on the marketability of a visualization system. The computational bandwidth required by the visible object determination algorithm determines the class of processor required for the visualization system, and thereby effects overall system cost. Thus, a system and method for improving the efficiency of visible object determination is greatly desired. [0019] Various embodiments of a system and method for performing visible object determination based upon a dual search of a cone hierarchy and a bounding hierarchy are herein disclosed. The system may comprise a processor, a display device, system memory, and optionally a graphics accelerator. The processor executes visualization software which provides for visualization of a collection of objects on the display device. The objects may reside in a three-dimensional space and thus admit the possibility of occluding one another. [0020] The visualization software represents space in terms of a hierarchy of cones emanating from the viewpoint. In one embodiment, the leaf-cones of the cone hierarchy subtend an area which corresponds to a fraction of a pixel in screen area. For example, two cones may conveniently fill the area of a pixel. In other embodiments, a leaf-cone may subtend areas which include one or more pixels. [0021] An initial view frustum or neighborhood of the view frustum may be recursively tessellated (i.e. refined) to generate a cone hierarchy. Alternatively, the entire space around the viewpoint may be recursively tessellated to generate the cone hierarchy. In this case, the cone hierarchy does not need to be recomputed for changes in the viewpoint and view-direction. [0022] The visualization software may also generate a hierarchy of bounds from the collection of objects. In particular, the bounding hierarchy may be generated by: (a) recursively grouping clusters starting with the objects themselves as order-zero clusters, (b) bounding each object and cluster (of all orders) with a corresponding bound, e.g. a polytope hull, (c) allocating a node in the bounding hierarchy for each object and cluster, and (d) organizing the nodes in the bounding hierarchy to reflect cluster membership. For example if node A is the parent of node B, the cluster corresponding to node A contains a subeluster (or object) corresponding to node B. Each node stores parameters which characterize the bound of the corresponding cluster or object. [0023] The visualization software may perform a search of the cone hierarchy and bounding hierarchy starting with the root cone and the root bound respectively. In one embodiment, each leaf-cone may store N object distances and N object pointers corresponding to the N closest known objects as perceived within the leaf cone from the common vertex (i.e. viewpoint) of the cone hierarchy. Each leaf cone may additionally store a visibility distance value which represents the distance to the N [0024] The dual-tree search may be illustrated in terms of a first cone of the cone tree structure and a first bound of the bound tree structure. The processor may compute a cone size for the first cone and a bound size for the first bound, and may compare the cone size and the bound size. If the bound size is larger than the cone size, the processor may conditionally search subbounds of the first bound with respect to the first cone. A subbound of the first bound may be searched against the first cone if the subbound achieves a cone-bound distance with respect to the first cone which is smaller than the visibility distance value associated with the first cone. [0025] If the cone size is larger than the bound size, the processor may conditionally search subcones of the first cone with respect to the first bound. A subcone of the first cone may be searched against the first bound if the subcone achieves a cone-bound distance with respect to the first bound which is smaller than the visibility distance value of the subcone. [0026] Eventually the dual-tree search reaches a leaf cone of the cone hierarchy and a leaf bound of the bounding hierarchy. In response to attaining a leaf cone and a leaf bound, the processor may: [0027] (a) compute a cone-bound distance for the leaf bound with respect to the leaf cone; [0028] (b) determine if the cone-bound distance is smaller than the visibility distance value associated with the leaf cone; [0029] (c) update the sequence of nearest object distances corresponding to the leaf cone based on the cone-bound distance; and [0030] (d) update the sequence of nearest object pointers corresponding to the leaf cone with an object pointer associated with the leaf bound. [0031] Operations (c) and (d) may be performed in response to determining that the cone-bound distance is smaller than the visibility distance value associated with the leaf cone. The sequence of nearest object positions is ordered by magnitude. The processor determines where the cone-hull distance belongs in the sequence of nearest object distances and injects the cone-hull distance in the sequence of nearest object distances at the appropriate sequence position. The processor also injects the object pointer associated with the leaf bound at the same relative position in the sequence of nearest object pointers. Upon completing the dual-tree search, the processor may transmit the nearest object pointers (or a stream of triangles corresponding to the nearest object pointers) for the leaf cone to a rendering agent for rendering and display. The rendering agent may comprise a hardware rendering unit. In an alternative embodiment, the rendering agent may comprise a software renderer also executed by the processor. [0032] After the update operations (c) and (d), the processor may set the visibility distance value for the leaf cone equal to a N [0033] In some embodiments, each leaf bound of the bounding hierarchy may be classified as an occluder or an non-occluder. For example, a leaf bound with volume VLB which contains an object with volume VO may be classified as an occluder or non-occluder based on the magnitude of volume ratio VO/VLB. A variety of methods are contemplated for the occluder/non-occluder classification. In addition to determination (b), the processor may determine if the leaf bound is an occluder. Update operations (c) and (d) may be performed only for occluders, i.e. occluding leaf bounds. In contrast, leaf bounds that are determined to be non-occluders may be stored in a non-occluder buffer associated with the leaf cone, i.e. the cone-bound distance and object pointer associated with the leaf bound may be stored in the non-occluder buffer. Thus, the dual-tree search may identify, for each leaf cone, the N closest occluders and all non-occluders closer than the Nth occluder, subject to storage limits in the non-occluder buffer(s). Upon completing the dual-tree search, the processor may transmit the nearest object pointers (i.e. the occluder pointers) and the non-occluder pointers (from the non-occluder buffer) to the rendering agent. [0034] In other embodiments, each leaf bound may be assigned an occlusion metric value. The occlusion metric value may measure an extent of occlusion of the leaf bound. For example, the occlusion metric value for a leaf bound may be proportional to the cube root of the volume of the leaf bound. In one embodiment, the occlusion metric value may be proportional to the square root of a maximal bounding area for the leaf bound. In another embodiment, the occlusion metric value may be proportional to a diameter (e.g. a maximal diameter) or an average of multiple diameters of the leaf bound. A variety of methods are contemplated for assigning an occlusion metric value to a leaf bound. Each leaf cone may store three lists which describe a collection of nearest leaf bounds (or nearest objects) as perceived within the leaf cone. A leaf cone stores a list of nearest object pointers, a list of corresponding object distances, and a list of corresponding occlusion values. The lists may expand and contract as leaf bounds are discovered during the dual-tree search. [0035] In response to attaining a leaf bound and a leaf cone in the dual-tree search, the processor may: [0036] (a) compute a cone-bound distance for the leaf bound with respect to the leaf cone; [0037] (b) determine if the cone-bound distance is smaller than the visibility distance value associated with the leaf cone; [0038] (c) update the list of object distances corresponding to the leaf cone based on the cone-bound distance; [0039] (d) update the list of nearest object pointers corresponding to the leaf cone with an object pointer associated with the leaf bound; and [0040] (e) update the list of occlusion values with the occlusion metric value of the leaf bound. [0041] Operations (c), (d) and (e) may be performed in response to determining that the cone-bound distance is smaller than the visibility distance value associated with the leaf cone. The processor may continue to add to the three lists for each discovered leaf bound until the sum of the occlusion values reaches an occlusion threshold. When the occlusion threshold is reached, the view of the leaf cone may be assumed to be totally occluded with the currently gathered objects. After the occlusion threshold has been reached, the processor may add a closer leaf bound and flush one or more of the farthest leaf bounds from the three lists so that the sum of the occlusion values remains less than or equal to the occlusion threshold. [0042] In one set of embodiments, each leaf cone of the cone hierarchy may point to (or store) a collection of probe cones. Probe cones may comprise a subset of the cones from one or more levels below the leaf cone level. The probe cones for a given leaf cone may sample (e.g. uniformly sample) the space subtended by the leaf cone. The processor may perform the dual-tree search to determine a first visible object (e.g. a closest object, or a farthest of N closest objects) for a given leaf cone, and subsequently, may perform a search of the bound hierarchy with respect to probe cones of the leaf cone to determine one or more additional visible objects for the leaf cone. Because the probe cones are smaller than the corresponding leaf cone, they may be able to “see” objects beyond (e.g. around the edges of) the first visible object. After the dual-tree search and the subsequent search, the processor may transmit an indication of the first visible object and the one or more additional visible objects for the given leaf cone to the rendering agent for rendering and display. [0043] In one embodiment, the search of a bound hierarchy with respect to a probe cone may be accelerated by searching a candidate bound only if it achieves a cone-bound distance with respect to the probe cone which is greater than or equal to the known distance to the first visible object determined by the dual-tree search. [0044] The foregoing, as well as other objects, features, and advantages of this invention may be more completely understood by reference to the following detailed description when read together with the accompanying drawings in which: [0045]FIG. 1 illustrates the ray-based method of visible object detection according to the prior art; [0046]FIG. 2A illustrates one embodiment of a graphical computing system for performing visible object determination; [0047]FIG. 2B is a block diagram illustrating one embodiment of the graphical computing [0048]FIG. 3 illustrates several main phases of one embodiment of a visualization program; [0049]FIG. 4A illustrates a collection of objects in a graphics environment; [0050]FIG. 4B illustrates a first step in one embodiment of a method of forming a hull hierarchy, i.e. the step of bounding objects with bounding hulls and allocating hull nodes for the bounding hulls; [0051]FIG. 4C illustrates one embodiment of the process of grouping together hulls to form higher order hulls, and allocating nodes in the hull hierarchy which correspond to the higher order hulls; [0052]FIG. 4D illustrates one embodiment of the culmination of the recursive grouping process wherein all objects are contained in a universal bounding hull which corresponds to the root node of the hull hierarchy; [0053]FIG. 5A illustrates the mathematical expressions which describe lines and half-planes in two dimensional space; [0054]FIG. 5B illustrates the description of a rectangular region as the intersection of four half-planes in a two dimensional space; [0055]FIG. 6 illustrates one embodiment of a two-dimensional cone partitioned into a number of subcones which interact with a collection of objects by means of wavefronts propagating within each of the subcones; [0056]FIG. 7 illustrates polyhedral cones with rectangular and triangular cross-section emanating from the origin; [0057]FIG. 8A illustrates mathematical expressions which describe a line through the origin and a corresponding half-plane given a normal vector in two-dimensional space; [0058]FIG. 8B illustrates the specification of a two-dimensional conic region as the intersection of two half-planes; [0059] FIGS. [0060] FIGS. [0061]FIG. 10E illustrates a cone C which has a small normalized size compared to a bound hull H; [0062]FIG. 10F illustrates a hull H which has a small normalized size compared to a cone C; [0063]FIG. 10G illustrates one embodiment of step [0064]FIG. 10H illustrates one embodiment of step [0065]FIG. 11A illustrates another embodiment of step [0066]FIG. 11B illustrates yet another embodiment of step [0067]FIG. 12A illustrates the successive refinement of a leaf cone LC down to a secondary refinement level; [0068]FIG. 12B illustrates that portion of the cone hierarchy (i.e. cone tree structure) which corresponds to the refinements of FIG. 12A; [0069]FIG. 12C illustrates one embodiment where a leaf cone points to several of its descendant cones from the second refinement level without storing (or pointing to) intermediate layers of the cone tree; [0070]FIG. 12D illustrates an object hull HA which is visible to a leaf cone LC, and a more distant object hull HB which is visible to a probe cone P; [0071] FIGS. [0072]FIG. 14 illustrates a second embodiment of the bound search algorithm which may accelerate the search of the bound hierarchy with respect to a probe cone by imposing a minimum distance condition on the search of candidate subhulls; and [0073]FIG. 15 illustrates one embodiment of the process of recursively clustering a collection of objects to form a bounding hierarchy. [0074] While the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that the drawings and detailed description thereto are not intended to limit the invention to the particular forms disclosed, but on the contrary, the intention is to cover all modifications, equivalents and alternatives falling within the spirit and scope of the present invention as defined by the appended claims. Please note that the section headings used herein are for organizational purposes only and are not meant to limit the description or claims. The word “may” is used in this application in a permissive sense (i.e., having the potential to, being able to), not a mandatory sense (i.e., must). Similarly, the word include, and derivations thereof, are used herein to mean “including, but not limited to.” [0075]FIG. 2A presents one embodiment of a graphical computing system [0076]FIG. 2B is a block diagram illustrating one embodiment of graphical computing system [0077] In some embodiments, a 3-D graphics accelerator [0078] 3-D graphics accelerator [0079] The computer system [0080] Visualization Software Architecture [0081]FIG. 3 illustrates one embodiment of the visualization software. In an initial step [0082] In one embodiment of the visualization software, the viewpoint in the graphical environment may be changed in response to user input. For example, by manipulating mouse [0083] In step [0084] In some embodiments, objects may be modeled as convex polytopes. A three-dimensional solid is said to be convex if any two points in the solid (or on the surface of the solid) may be connected with a line segment which resides entirely within the solid. Thus a solid cube is convex, while a donut is not. A polytope is an object with planar sides (e.g. cube, tetrahedron, etc.). Although not all objects are convex, every object can be approximated as a union of convex polytopes. It is helpful to note that the visible-object-set computation does not require an exact computation, but rather a conservative one. In other words, it is permissible to over-estimate the set of visible objects. [0085] Constructing The Object Hierarchy [0086] Initially, the objects in a scene may be organized into a hierarchy that groups objects spatially. An octree is one possibility for generating the object hierarchy. However, in the preferred embodiment, a clustering algorithm is used which groups nearby objects then recursively clusters pairs of groups into larger containing spaces. The clustering algorithm employs a simple distance measure and thresholding operation to achieve the object clustering. FIGS. [0087] Each object may be bounded, i.e. enclosed, by a corresponding bounding surface referred to herein as a bound. In one embodiment, the bound for each object is a polytope hull (i.e. a hull having planar faces) as shown in FIG. 4B. The hulls H [0088] Since a hull has a surface which is comprised of a finite number of planar components, the description of a hull is intimately connected to the description of a plane in three-space. In FIG. 5A, a two dimensional example is given from which the equation of an arbitrary plane may be generalized. A unit vector n [any vector suffices but a vector of length one is convenient for discussion] defines a line L through the origin of the two dimensional space. By taking the dot product v·n of a vector v with the unit vector n, one obtains the length of the projection of vector v in the direction defined by unit vector n. Thus, given a real constant c, it follows that the equation x·n=c, where x is a vector variable, defines a line M perpendicular to line L and situated at a distance c from the origin along line L. In the context of three-dimensional space, this same equation defines a plane perpendicular to the line L, again displaced distance c from the origin along line L. Observe that the constant c may be negative, in which case the line (or plane) M is displaced from the origin at distance |c| along line L in the direction opposite to unit vector n. [0089] The line x·n=c divides the plane into two half-planes. By replacing the equality in the above equation with an inequality, one obtains the description of one of these half-planes. The equality x·n<c defines the half-plane which contains the negative infinity end of line L. [The unit vector n defines the positive direction of line L.] In three dimensions, the plane x·n=c divides the three-dimensional space into two half-spaces. The inequality x·n<c defines the half-space which contains the negative infinity end of line L. [0090]FIG. 5B shows how a rectangular region may be defined as the intersection of four half-planes. Given four normal vectors n [0091] In three-dimensional space, a rectangular box may be analogously defined as the intersection of six half-spaces. Given six normal vectors n [0092] To construct an object hierarchy, object hulls H [0093] The containing-hulls H [0094] In general, a succession of pairing operations is performed. At each stage, a higher-order set of containing-hulls and corresponding nodes for the object hierarchy are generated. Each node contains the describing vector c for the corresponding containing-hull. At the end of the process, the object hierarchy comprises a binary tree with a single root node. The root node corresponds to a total containing-hull which contains all sub-hulls of all orders including all the original object-hulls. The object hierarchy, because it comprises a hierarchy of bounding hulls, will also be referred to as the hull hierarchy. In the preferred embodiment, the pairing operations are based on proximity, i.e. objects (and hulls of the same order) are paired based on proximity. This tree of bounding hulls provides a hierarchical representation of the entire scene. For instance, when a cone completely misses a node's containing-hull, none of the node's descendents need to be examined. [0095] Bounding hulls (i.e. containing hulls) serve the purpose of simplifying and approximating objects. Any hierarchy of bounding hulls works in principle. However, hierarchies of hulls based on a common set of normal vectors are particularly efficient computationally. A collection of hulls based on a common set of normal vectors will be referred to herein as a fixed-direction or commonly-generated collection. As described above, a polytope hull is described by a bounding system of linear inequalities {x: Nx≦c}, where the rows of the matrix N are a set of normal vectors, and the elements of the vector c define the distances to move along each of the normal vectors to obtain a corresponding side of the polytope. In a fixed-direction collection of hulls, the normal matrix N is common to all the hulls in the collection, while the vector c is unique for each hull in the collection. The problem of calculating the coefficient vector c for a bounding hull given a collection of subhulls may be simplified when a common set of normal vectors is used. In addition, the nodes of the hull hierarchy may consume less memory space since the normal matrix N need not be stored in the nodes. In some embodiments, the hull hierarchy comprises a fixed-direction collection of hulls. [0096] In a first embodiment, six normal vectors oriented in the three positive and three negative axial directions are used to generate a fixed-direction hierarchy of hulls shaped like rectangular boxes with sides parallel to the coordinate planes. These axis-aligned bounding hulls provide a simple representation that may have desirable local computational properties. It is easy to transform or compare two axis-aligned hulls. [0097] In a second embodiment, eight normal vectors directed towards the comers of a cube are used to generate a hierarchy of eight-sided hulls. For example, the eight vectors (±1,±1,±1) may be used to generate the eight-sided hulls. The octahedron is a special case of this hull family. [0098] In a third embodiment, fourteen normal vectors, i.e. the six normals which generate the rectangular boxes plus the eight normals which generate the eight-sided boxes, are used to generate a hull hierarchy with fourteen-sided hulls. These fourteen-sided hulls may be described as rectangular boxes with comers shaved off. It is noted that as the number of normal vectors and therefore side increases, the accuracy of the hull's approximation to the underlying object increases. [0099] In a fourth embodiment, twelve more normals are added to the fourteen normals just described to obtain a set of twenty-six normal vectors. The twelve additional normals serve to shave off the twelve edges of the rectangular box in addition to the comers which have already been shaved off. This results in twenty-six sided hulls. For example, the twelve normal vectors (±1,±1,0), (±1,0,±1), and (0,±1,±1) may be used as the additional vectors. [0100] In the examples given above, hulls are recursively grouped in pairs to generate a binary tree. However, in other embodiments, hulls are grouped together in groups of size G, where G is larger than two. In one embodiment, the group size varies from group to group. [0101] Although the above discussion has focussed on the use of polytope hulls as bounds for object and clusters, it is noted that any type of bounding surfaces may be used, thereby generating a hierarchy of bounds referred to herein as a bounding hierarchy. Each node of the bounding hierarchy corresponds to an object or cluster and stores parameters which characterize the corresponding bound for that object or cluster. For example, polynomial surfaces such as quadratic surfaces may be used to generate bounds for objects and/or clusters. Spheres and ellipsoids are examples of quadratic surfaces. [0102] Cones in Visible Object Determination [0103] In addition to the bounding hierarchy (e.g. hull hierarchy) discussed above, the visualization software makes use of a hierarchy of spatial cones. An initial cone which may represent the view frustum may be recursively subdivided into a hierarchy of sub-cones. Then a simultaneous double recursion may be performed through the pair of trees (the object tree and cone tree) to rapidly determine the set of visible objects. This cone-based method provides a substantial computational gain over the prior art method based on ray-casting. [0104]FIG. 6 illustrates a two-dimensional cone C in a two-dimensional environment. Cone C is defined by the region interior to the rays R [0105] Polyhedral Cones [0106] The spatial cones used in the preferred embodiment are polyhedral cones. The generic polyhedral cone has a polygonal cross-section. FIG. 7 gives two examples of polyhedral cones. The first polyhedral cone PHC [0107] A polyhedral cone is constructed by intersection of multiple half-spaces. For example, solid cone PHC [0108] Thus, a polyhedral cone emanating from the origin is defined as the set of points satisfying a system of linear inequalities Sx≦0. [There is no loss of generality in assuming the origin to be the viewpoint.] According to this definition, half-spaces, planes, rays, and the origin itself may be considered as polyhedral cones. In addition, the entire space may be considered to be a polyhedral cone, i.e. that cone which is defined by an empty matrix S. [0109] Distance Measurement [0110] The distance of an object, hull, or bound from a particular viewpoint is defined to be the minimum distance to the object, hull, or bound from the viewpoint. So, assuming a viewpoint at the origin, the distance of the object, hull, or bound X from the viewpoint is defined as
[0111] where ∥x∥ is the norm of vector x. [0112] Any vector norm may be chosen for the measurement of distance. In one embodiment, the Euclidean norm is chosen for distance measurements. The Euclidean norm results in a spherically shaped wavefront. Any wavefront shape may be used as long as it satisfies a mild “star-shape” criterion, i.e. the entire boundary of the wavefront is unobstructed when viewed from the origin. All convex wavefronts satisfy this condition, and many non-convex ones do as well. In general, the level curves of a norm are recommended as the wavefront shapes. From a computational standpoint, the spherical wavefront shape given by the L [0113] Cones and Visibility [0114] Consider an arbitrary cone K emanating from the origin as a viewpoint. Define the distance of an object, hull, or bound X relative to the cone K as
[0115] where the symbol ∩ denotes set intersection. If the distance ƒ [0116] As discussed above, the ray-based methods of the prior art are able to detect objects only up the resolution of the ray sample. Small visible objects or small portions of larger objects may be missed entirely due to insufficient ray density. In contrast, cones can completely fill space. Thus, the cone-based method disclosed herein may advantageously detect small visible objects or portions of objects that would be missed by a ray-based method with equal angular resolution. [0117] Generalized Separation Measurement [0118] For the purposes of performing a visibility search procedure, it is necessary to have a method for measuring the extent of separation (or conversely proximity) of objects, bounds, or hulls with respect to cones. There exists a great variety of such methods in addition to those based on minimizing vector norms defined above. [0119] In some embodiments, the separation between a set X and a cone K may be computed based on the model of wavefront propagation. A wavefront propagating internal to the cone from the vertex of the cone and has a radius of first interaction with the set X. This radius of first interaction may provide a measurement value of the separation between the set X and the cone K. The wavefront may satisfy a mild “star shape” condition, i.e. the entire boundary of the wavefront is visible from the vertex of the cone. [0120] In one embodiment, the measurement value is obtained by computing a penalty of separation between the set X and the cone K. The penalty of separation may be evaluated by minimizing an increasing finction of separation distance between the vertex of the cone K and points in the intersection of the cone K and set X. For example, any positive power of a vector norm gives such an increasing function. [0121] In another embodiment, the measurement value is obtained by computing a merit of proximity between the set X and the cone K. The merit of proximity may be evaluated by maximizing a decreasing function of separation distance between the vertex of the cone K and points in the intersection of the cone K and set X. For example, any negative power of a vector norm gives such a decreasing function of separation. [0122] A Cone Hierarchy [0123] In some embodiments, the visibility determination method uses a hierarchy of cones in addition to the hierarchy of hulls described above. The class of polyhedral cones is especially well suited for generating a cone hierarchy. Polyhedral cones naturally decompose into polyhedral subcones by the insertion of one or more separating planes. The ability to nest cones into a hierarchical structure may allow a rapid examination of object visibility. As an example, consider two neighboring cones that share a common face. By taking the union of these two cones, a new composite cone is generated. The composite cone neatly contains its children, and is thus capable of being used in querying exactly the same space as its two children. In other words, the children cones share no interior points with each other and they completely fill the parent without leaving any empty space. [0124] A typical display and its associated view frustum has a rectangular cross-section. Vast array of possibilities are contemplated for tessellating this rectangular cross-section to generate a system of sub-cones. For example, the rectangle naturally decomposes into four rectangular cross-sections, or two triangular cross-sections. Although these examples illustrate decompositions using regular components, irregular components may be used as well. [0125] FIGS. [0126] The triangular hierarchical decomposition shown in FIGS. [0127] It is noted that any cone decomposition strategy may be employed to generate a cone hierarchy. In a second embodiment, the view frustum is decomposed into four similar rectangular cones; each of these subcones is decomposed into four more rectangular subcones, and so on. This results in a cone tree with four-fold branches. [0128] As used herein, a cone K is said to be descendent of cone C when cone C is contains cone K. Thus, all the cones beneath cone C in the cone hierarchy are said to be descendents of cone C. [0129] Discovering the Set of Visible Objects [0130] Once the hull hierarchy and the cone hierarchy have been constructed, the set of visible objects may be computed with respect to the current viewpoint. In one embodiment, the visible object set may be repeatedly recomputed for a succession of viewpoints, viewing directions, video frames, etc. The successive viewpoints and/or viewing directions may be specified by a user through an input device such as a mouse, joystick, keyboard, trackball, head-position sensor, eye-orientation sensor, etc., or any combination thereof. The visible object determination method may be organized as a simultaneous search of the hull tree and the cone tree. The search process may involve recursively performing cone-hull queries. Given a cone node K and a hull node H, a cone-hull query on cone K and hull H investigates the visibility of hull H and its descendent hulls with respect to cone K and its descendent cones. The search process has a computational complexity of order log M, where M equals the number of cone nodes times the number of hull nodes. In addition, many cone-hull queries can occur in parallel allowing aggressive use of multiple processors in constructing the visible-object-set. [0131] Viewing the Scene [0132] Independently, and also concurrently, the set of visible objects from the current viewpoint may be rendered on one or more displays. The rendering can occur concurrently because the visible-object-set remains fairly constant between frames in a walkthrough environment. Thus the previous set of visible objects provides an excellent approximation to the current set of visible objects. [0133] Managing the Visible-object-set [0134] The visualization software may manage the visible-object-set. Over time, as an end-user navigates through a model, just inserting objects into the visible object set would result in a visible object set that contains too many objects. Thus, the visualization process may remove objects from the visible object set when those objects no longer belong to the set—or soon thereafter. A variety of solutions to object removal are possible. One solution is based on object aging. The system removes any object from the visible object set that has not been rediscovered by the cone query within a specified number of redraw cycles. [0135] Computing Visibility Using Cones [0136] Substantial computational leverage may be provided by recursively searching the hierarchical tree of cones in conjunction with the hierarchical tree of hulls. Whole groups of cones may be tested against whole groups of hulls in a single query. For example, if a parent cone does not intersect a parent hull, it is obvious that no child of the parent cone can intersect any child of the parent hull. In such a situation, the parent hull and all of its descendants may be removed from further visibility considerations with respect to the parent cone. [0137] Visibility Search Algorithm [0138] A visibility search algorithm implemented as a visibility search program may perform a recursive search of the two trees (the object tree and the cone tree) to assign visible objects to leaf cones of the cone tree. The visibility search program may be stored in memory [0139] The recursive search of the two trees provides a number of opportunities for aggressive pruning of the search space. Central to the search is the object-cone distance measure defined above, i.e. given a cone K and an object (or hull) X, the object-cone distance is defined as
[0140] It is noted that this minimization is in general a nonlinear programming problem since the cones and object hulls are defined by constraint equations, e.g. planes in three-space. If the vector norm ∥x∥ is the L [0141] The recursive search starts with the root H of the hull tree and the root cone C of the cone tree (see FIGS. 4 and 9). Each node of the hull tree may specify a bounding hull which contains the hulls of all its descendant nodes. Initially the distance between the root cone and the root hull is computed. If that distance is infinite, indicating an empty intersection between the root cone and the root hull, then no cone in the cone hierarchy intersects any hull in the hull hierarchy and there are no visible objects. If the distance is finite, then further searching may be performed. Either tree may be refined at this point. [0142] The pruning mechanism is built upon several basic elements. A distance measurement function computes the distance ƒ [0143] To facilitate the search process, a leaf cone node in the cone tree may store up to N object pointers OBJ [0144] These N distance values may be initialized to positive infinity. The largest distance value D [0145] The distances D [0146] In addition, each non-leaf cone, i.e. each cone at a non-final refinement level, is assigned a visibility distance value which equals the maximum of the visibility distance values of its sub-cones. Or equivalently, the visibility distance value for a non-leaf cone equals the maximum of the visibility distance values of its leaf-cone descendents. The visibility distance values for all non-leaf cones may be initialized to positive infinity (consistent with initialization of the leaf-cones). Suppose a given non-leaf cone K and a hull X achieve a cone-hull distance ƒ [0147] The following code fragment illustrates the beginning of the search process according to one embodiment of the visibility search algorithm. The variables hullTree and coneTree point to the root nodes of the hull tree and cone tree respectively.
[0148] The function Dist is used to evaluate the distance between the root hull and the root cone. If this distance is less than positive infinity, the function findVisible is called with the root hull, root cone, and their hull-cone distance as arguments. The function findVisible performs the recursive search of the two trees. [0149] FIGS. findVisible(H, C, d [0150] where H is a hull node to be explored against the cone node C. The value dH,c represents the cone-hull distance between cone C and hull H. [0151] In step D [0152] Any of various methods may be used to perform this determination. The output of step [0153] In step D D D . . . , D D [0154] In particular, the object pointer OBJ [0155] If, in step [0156] In step [0157] In step [0158] If, in step [0159] In step [0160] In step [0161] Since the visibility distance values for subcones C [0162] If, in step [0163] In step [0164] In step [0165] In step [0166] In step [0167] If, in step [0168] In step [0169] In step [0170] As explained above, the visibility distance value assigned to each cone in the cone tree is set equal the maximum of the visibility distance values assigned to its subcone children. Thus, if a given hull achieves a distance to a cone which is larger than the cone's current visibility distance value, all of the cone's leaf-cone descendents have already “discovered” objects closer than the given hull and any of its leaf-hull descendents. The given hull node may not be searched with respect to this cone. [0171] A cone's visibility distance value decreases as the recursion tests more and more object-cone leaf pairs. As nearby objects are discovered, a cone's visibility distance value decreases and the probability of skipping unpromising hull nodes increases. A leaf in the hull tree bounds the volume of an associated object. Thus, cone visibility distance values, set during recursion, are usually not the real distances to objects but a conservative approximation of those distances. If the conservative approximation is inadequate for use in an application, then that application can invoke a higher precision computation of object-cone distance to determine the visibility distance values. [0172] Throughout the above discussion of the visibility search algorithm it has been assumed that the function Dist used to compute the cone-hull separation distance is based on minimizing an increasing function of separation distance between the vertex of the given cone and points in the intersection of the given cone and the given hull. However, it is noted that the function Dist may be programmed to compute a merit of proximity between a given cone and given hull. The resulting merit value increases with increasing proximity and decreases with increasing separation, converse to the typical behavior of a distance function. In this case, the visibility search algorithm performs a search of hull H against cone K only if the merit value of separation between cone K and hull H is greater than the current merit value associated with cone K. Furthermore, after a search of subcones of cone K is completed, the merit value associated with the cone K is updated to equal the minimum of the merit values of its subcone children. [0173] In general, the function Dist determines a cone-hull measurement value of separation by computing the extremum (i.e. minimum or maximum) of some monotonic (increasing or decreasing) function of separation between the vertex of the cone K and points in the intersection of cone K and hull H. The search of cone K against a hull H is conditioned on the hull H achieving a cone-hull measurement value with respect to cone K which satisfies an inequality condition with respect to measurement value assigned to cone K. The sense of the inequality, i.e. less than or greater than, depends on the whether the function Dist uses an increasing or decreasing function of separation. [0174] While the search of the hull and cone hierarchies described above assumes a recursive form, it is noted that any search strategy may be employed. In one alternate embodiment, the hull and/or cone hierarchies are searched iteratively. Such a brute force solution may be advantageous when a large array of processors is available to implement the iterative search. In another embodiment, a level-order search is performed on the hull and/or cone hierarchies. [0175] After completing the search on the hull and cone hierarchies, the visibility search algorithm may transmit the set of N object pointers (or the subset of the N object pointers which correspond to actual discovered objects as opposed to object pointers which retain their initialization value corresponding to infinity distance) for each leaf cone of the cone hierarchy to a rendering agent (e.g. graphics accelerator [0176] If the cone hierarchy is refined so that the leaf cones each cover the area of approximately one pixel or less, there is a high probability that the closest object in a leaf cone is the only visible object in the leaf cone. Thus, N=l may be used in embodiments where the cone hierarchy is refined to pixel resolution. In other words, it may be necessary only to identify the single closest object in each leaf cone. It is noted, however, that the visibility search of such a “fully resolved” cone hierarchy may be computationally expensive. The computational expense may be decreased by having fewer levels of refinement in the cone hierarchy. But fewer levels of refinement implies that the size of the leaf cones is larger. As the size of the leaf cones increases, there is an increasing probability that two or more objects will be visible to a single leaf cone, i.e. that the nearest object is not the only object visible to the cone. Therefore, N may take larger values when the leaf cones of the cone hierarchy subtend larger solid angles, or equivalently, when fewer levels of cone refinement are used in the cone hierarchy. [0177] In some embodiments, a search may be performed which penetrates several levels below the leaf cone level to estimate the true number N [0178] In some embodiments, computational efficiency may be maximized along the axis of high-cone-resolution/low-N-value on the one hand and low-cone-resolution/high-N-value on the other. [0179] Size Conditioned Tree Search [0180] As described above in connection with step [0181] If the hull size Size_H is larger than the cone size Size_C as suggested by FIG. 10E, on average, the probability of at least one subhull of hull H having an empty intersection with cone C is larger than the probability of at least one subcone of cone C having an empty intersection with hull H. Thus, in this case, it may be more advantageous to explore the subhulls H [0182] If the hull size Size_H is smaller than the cone size Size_C as suggested by FIG. 10F, on average, the probability of at least one subhull of hull H having an empty intersection with cone C is smaller than the probability of at least one subcone of cone C having an empty intersection with hull H. Thus, in this case, it may be more advantageous to explore the subcones C [0183] By selecting the larger entity (hull or cone) for refinement, the findVisible function may more effectively prune the combined hull-cone tree, and determine the set of visible objects with increased efficiency. [0184] Searching Subhulls in order of Proximity to a Hull [0185] In step [0186] In step [0187] In steps [0188] The fixed-order subhull search shown in steps [0189] Occluders and Non-occluders [0190] In some embodiments, object hulls may be classified as occluders or non-occluders prior to the visibility search. An object hull may be an occluder if the object it contains is opaque and fills a substantial portion of the volume of the object hull. An object hull may be a non-occluder if the object it contains is transparent or semi-transparent, or if the contained object is opaque and fills an insubstantial portion of the volume of the object hull. For example, object hulls containing windows, bubbles or plastic film may represent non-occluders. Also, object hulls which use only a few normals may not be able to efficiently contain certain long thin objects in certain orientations. For example, a rectangular box with sides parallel to the coordinate axes are not able to efficiently contain a long thin object such as a pen oriented in the direction (1,1,1). Various methods and criteria are contemplated for classifying object hulls as occluders or non-occluders. The object hull classification may be performed any time after the object hulls are generated. [0191] As discussed above, step [0192] In step [0193] If the hull H is an occluder, the visibility search algorithm may update the object pointers and object distances as has already been described in connection with steps [0194] In step [0195] Thus, in the embodiment of step [0196] After completing the search on the hull and cone hierarchies, the visibility search algorithm may transmit the occluder pointers and non-occluder pointers for each leaf cone of the cone hierarchy to a rendering agent. Because, neighboring leaf cone may share many of the same nearest objects, the set of objects pointers associated with the leaf cones may be processed to remove redundancies before transmission to the rendering agent. [0197] Occlusion Metric [0198] In some embodiments, an occlusion metric may be used to assign an occlusion metric value to each object hull in the hull hierarchy. A leaf cone C may gather object hulls until the sum of the corresponding occlusion metric values exceeds some threshold. In one embodiment, the occlusion metric value for an object hull may be the maximum diameter of the object hull. The maximum diameter is the maximum distance between any two points on the surface of the object hull. This maximum diameter may be computed from the xyz coordinates of the vertices of the object hull. [0199] In a second embodiment, the occlusion metric value for an object hull may be determined based on an estimate of the maximal framing area of the object hull. A frame (e.g. a rectangular frame) perpendicular to a fixed direction and fitting efficiently around an object hull has a well-defined area. The frame area may be maximized over all possible directions giving the maximal framing area for the object hull. The occlusion metric value may be the square root of the maximal framing area. [0200] In a third embodiment, the occlusion metric value for an object hull may be the cube root of the volume of the object hull. [0201] In a fourth embodiment, the occlusion metric value for an object hull is determined by the ratio of the volume of the object contained within the object hull to the volume of the object hull. [0202] In a fifth embodiment, the above volume ratio may be scaled with respect to the inverse of the cone-hull distance dH,c according to the relation: metric( [0203] In a sixth embodiment, the occlusion metric for an object hull may be computed by estimating an opaque object volume. for the contained object, and dividing the opaque object volume by the volume of the object hull. The opaque object volume of an object is that portion of the object's volume which is opaque. [0204] In a seventh embodiment, the ratio of opaque object volume to object hull volume is scaled by the inverse of the cone-hull distance d metric( [0205] A variety of methods are contemplated for determining the occlusion metric value of object hulls. [0206] Each leaf cone C may store a collection of object pointers OBJ [0207] The nearest object corresponds to object pointer OBJ [0208] As discussed above, step [0209] In step [0210] Any of various methods may be used to perform this determination. The output of step [0211] In step D D D . . . , D D [0212] where the notation A←B indicates that the value of variable B is assigned to the variable A. The distance values starting with index J are shifted upward in index position. Similarly, the objection pointers and occlusion values are shifted upward in index position. After the injection of the new data associated with object hull H, each list may contain one more entry than before the injection. The cone-hull distance d [0213] In step [0214] In step [0215] In step [0216] If the sum of the cumulative occlusion sum S [0217]FIG. 11B illustrates another embodiment of step [0218] If the cumulative occlusion sum S [0219] If the cumulative occlusion sum S [0220] Thus, the visibility search algorithm steps back from the end of each data list (one each for object pointers, object distance and occlusion values) until the cumulative occlusion sum is less than or equal to the occlusion threshold. [0221] Refining Cone Tree Resolution with Probe Cones [0222] A cone tree data structure comprises a hierarchy of nested cones. Each succeeding level of the cone tree provides a fmer resolution of the space contained by the root cone. In the embodiments discussed above, the visibility search algorithm performs a simultaneous dual tree search on the cone tree and hull tree. The visibility search algorithm searches the cone tree down to a primary refinement level. This search is referred to herein as the primary search. The cones at the primary refinement level are referred to as leaf cones. The primary search identifies a primary set of visible objects for the leaf cones. For the sake of the following discussion, imagine that the cone tree is refined for several levels beyond the primary refinement level, i.e. down to a secondary refinement level. For example, FIGS. 12A and 12B illustrate a leaf cone LC and four levels of refinement below the leaf cone. FIG. 12A illustrates the successive refinement of leaf cone LC in space. Only cross sections of cones are illustrated for the sake of simplicity. FIG. 12B illustrates the subtree of cone nodes below the leaf cone node LC down to the secondary refinement level which is four levels down. [0223] If the visibility search algorithm were allowed to search down to the secondary refinement level, there would be an increased probability of detecting all objects visible within the root cone because the cones at the second refinement level partition space more finely. However, the extended visibility search down to the secondary refinement level may be significantly more expensive than the search down to the primary refinement level. [0224] In some embodiments, the leaf cones of the cone tree may store a subset of cones (or pointers to cones) from the secondary refinement level without storing any nodes corresponding to the intervening refinement levels. For example, FIG. 12C illustrates leaf cone LC pointing directly to selected cones, i.e. cone 0000, 0100, 1000 and 1100, from a secondary refinement level which is four levels down from the primary (i.e. leaf cone) refinement level. The selected cones are referred to herein as probe cones. The probe cones for a leaf cone may not fill the space of the leaf cone. However, the probe cones may be “spread out” so as to uniformly sample the space of the corresponding leaf cone. [0225] The probe cones may be used in a second visibility search operation which may be performed after the primary search is complete. The second visibility search operation may explore the hull tree with each of the probe cones of each leaf cone to determine a secondary set of visible objects. The union of the primary set and secondary set of visible objects comprises an augmented set of visible objects which may more closely approximate the true set of visible objects than the primary set alone. FIG. 12D illustrates a leaf cone LC and one of its probe cones denoted P. The primary search may identify object hull H [0226] The following code fragment illustrates one embodiment of the search of a probe cone P against the hull tree. The variable hullTree points to the root node of the hull tree.
[0227] The function Dist is used to evaluate the distance between the root hull and the probe cone P. If this distance is less than positive infinity, the function HullSearch is called with the root hull, probe cone, and their hull-cone distance as arguments. The function HullSearch performs the recursive search of the hull tree with respect to the probe cone P. [0228]FIGS. 13A and 13B illustrate one embodiment of the HullSearch function (also referred to by the contraction HS). The HullSearch function receives several input variables from a calling routine as illustrated by the following function prototype: HullSearch (H, P, d [0229] where H is a hull node to be explored against the probe cone P. The value d [0230] In step [0231] If hull H is not a leaf of the hull tree, step [0232] In step [0233] In step [0234] In some embodiments, step [0235] The embodiment discussed in FIGS. 13A and 13B stores only one visible object per probe cone. However, other embodiments are contemplated where multiple visible objects may be stored per probe cone. [0236] The number of levels between the second refinement level and the primary refinement level may be programmable, and may take any desired value. The number of probe cones per leaf cone may take any desired value. The probe cones serve to increase the effective resolution of the cone tree. [0237] After the primary search of the hull tree and cone tree is complete, the hull tree may be explored with each probe cone of each leaf cone as described above in connection with FIGS. 13A and 13B above. The object OBJ [0238] In some embodiments, the second visibility search operation may use a different set of probe cones in successive frames. For example, referring to FIG. 12A, the second visibility search operation may use probe cones denoted 0000, 0100, 1000 and 1100 for a first frame, and probe cones 0001, 0101, 1001 and 1101 for a second frame. The use of different sets of probe cones in successive frames may increase the probability of detecting small objects within a leaf cone. [0239] Hot Starting the Probe Cone Query [0240] It is noted that the primary search performed by any of the embodiments of the visibility search algorithm described above may identify the closest object in each leaf cone. If the closest object achieves a distance D [0241] As described above, in some embodiments the visibility search algorithm identifies the N closest objects in each leaf cone. In this case, the secondary visibility search may concentrate on identifying objects in leaf cone LC which are beyond the N [0242] In other embodiments, the visibility search algorithm identifies closest objects in a leaf cone until the sum of their occlusion metrics reaches an occlusion threshold. In this case, the distance of the L [0243] In one embodiment, the HullSearch function explores a subhull of a hull H with respect to probe cone P only if the subhull achieves a cone-hull distance from the probe cone P which is greater than or equal to the minimum distance limit Dmin [0244] In step [0245] In step [0246] Prior to execution of the HullSearch function on a probe cone P of leaf cone LC, the minimum distance Dmin [0247] Method for Constructing a Bounding Hierarchy [0248]FIG. 15 illustrates the construction of a bounding hierarchy (i.e. a bounding tree structure) from a collection of objects. The collection of objects may be accessed from memory [0249] In step [0250] Although the construction of the cone hierarchy above has been described in terms of recursive clustering, it is noted alternative embodiments are contemplated which use other forms of clustering such as iterative clustering. [0251] Computing the Cone Restricted Distance Function [0252] Recall that evaluation of the cone-hull distance ƒ [0253] It is also noted that cone-hull separation may be measured by maximizing an decreasing function separation such as ∥x∥ [0254] The use of a hierarchy of cones instead of a collection of rays is motivated by the desire for computational efficiency. Thanks to early candidate pruning that results from the double recursion illustrated earlier, fewer geometric queries are performed. These queries however are more expensive than the queries used in the ray casting method. Therefore, the cone query calculation may be designed meticulously. A sloppy algorithm could end up wasting most of the computational advantage provided by improvements in the dual tree search. For the linear programming case, a method for achieving a computationally tight query will now be outlined. [0255] A piecewise-linear formulation of distance ƒ min (ν subject to Ax≦b, Sx≦0. [0256] The vector v is some member of the cone that is polar to the cone C. For instance, v=−S max(b subject to [0257] The dual objective value, b [0258] In the preferred embodiment, the bounding hulls have sides normal to a fixed set of normal vectors. Thus, the matrix A {( [0259] is associated with the cone. (In one embodiment, this polyhedron has seventeen dimensions. Fourteen of those dimensions come from the type of the fixed-direction bounding hull and an three additional dimensions come from the cone.) Since the polyhedron depends only on the cone matrix S, it is feasible to completely precompute the extremal structure of the polygon for each cone in the cone hierarchy. By complementary slackness, the vertices of the polyhedron will have at most three elements. The edges and extremal rays will have at most four non-zero elements. An abbreviated, simplex-based, hill-climbing technique can be used to quickly solve the query in this setting. [0260] In one embodiment, the entire space is tessellated with cones, and visible objects are detected within the entire space. After this entire-space visibility computation, the set of visible objects may be culled to conform to the current view frustum, and the visible objects which survive the frustum culling may be rendered and displayed. [0261] In an alternative embodiment, a less aggressive approach may be pursued. In particular, by determining beforehand a collection of the cones in the cone hierarchy which correspond to the view frustum in its current orientation, only this collection may be included in the visible-object-set computation. [0262] Memory Media [0263] As described above, the visibility software may be stored in memory [0264] In one embodiment, the visibility software may be implemented as part of an operating system. In a second embodiment, the visibility software may be implemented as a dynamic link library. In a third embodiment, the visibility software may be implemented as part of a device driver (e.g. a device driver for graphics accelerator [0265] In a fourth embodiment, the visibility software may be implemented as part of a JAVA 3D virtual machine which executes on processor [0266] Adaptive Refinement of the Cone Hierarchy [0267] In the foregoing discussion, the cone hierarchy is described as being constructed prior to initiation of the search for visible objects by the visibility search algorithm, and remains static during the search. Another alternative is to adaptively refine the cone hierarchy during the search procedure. In this fashion, the cone hierarchy may not waste storage for cones which will never interact with any objects. The cone hierarchy may be refined in response to user inputs. For example, cones which correspond to the user's current direction of gaze may warrant additional refinement. A given cone may remain unrefined until the search procedure discovers a bound which interacts with the given cone, at which time the cone may be refined. The refinement of a given cone may be further refined as additional interacting objects/bounds are discovered in order to more adequately distinguish the objects. In the context where objects are in motion, the movement of an object into a given cone's field of view may induce increased refinement of the given cone. If the user in a virtual environment stops to look at a given object, the cones defining that object may be increasingly refined. [0268] Refinement of the cone hierarchy may be subject to the availability of computational cycles. According to the paradigm of successive warming, the initial cone tree may have only one or a few cones allowing a crude initial estimate of visible object set to be immediately displayed. As computational cycles become available the cone hierarchy may be successively refined and searched in order to provide an increasingly accurate display of the visible object set. [0269] In general the cones of the cone hierarchy may be at differing levels of refinement. Cone refinement may be permitted only if the cone interacts with an object or bound (e.g. hull). Adaptive refinement of a cone may be terminated when the cone resolution equals that of a pixel or when no object occurs in the cone. [0270] In one embodiment, a combination of fixed refinement and adaptive refinement of the cone hierarchy may be used. [0271] In some embodiments, the visibility search algorithm may combine adaptive refinement of the cone hierarchy and identification of the K nearest objects/bound for each cone, where K changes as the refinement level changes. Referenced by
Classifications
Legal Events
Rotate |