JP4972642B2 - High-precision real-time ray tracing - Google Patents

Description

Citation of Related Applications This application claims priority from US Provisional Application No. 60 / 693,231, filed June 23, 2005, which is hereby incorporated by reference in its entirety.

Reference to Computer Program Appendix The source code listing is submitted with this specification, which is incorporated herein by reference in its entirety. This source code listing is referred to herein as an “annex” and is organized into paragraphs identified by a three-digit reference number in the form “1.1.1.”.

  The present invention relates generally to a method and system for rendering images of movies and other applications that are performed by the system in a digital computer system, and in particular, a method, system for real-time precision ray tracing, The present invention relates to an apparatus and computer software.

2. Description of the Prior Art The term “ray tracing” relates to a technique for synthesizing a realistic image by identifying all light paths connecting a light source and a camera and summing their contributions. This simulation tracks the rays from the light source to track the rays along the line of sight to determine visibility and to measure illuminance.

  Ray tracing has become mainstream in movies and other application areas. However, current ray-tracing technology has many well-known limitations such as numerical problems, limited capability to handle dynamic scenes, slow setup of acceleration data structures, and the need for large amounts of memory. And there are weaknesses. Therefore, current ray tracing technology lacks the ability to efficiently handle scenes that are completely animated, such as wind blowing through forests and human hair. Overcoming the limitations of current ray-tracing systems will allow higher-quality motion blur to be drawn, for example, in movie productions.

Several attempts have been made to improve the performance of ray tracing systems to date, but these have not yielded satisfactory results for several reasons. For example, current ray-tracing systems generally have a binary space partition parallel to the coordinate axis (original: binary)
Use 3D tree as an acceleration structure based on space partition). These systems are primarily focused on static scene rendering, so the problem is that the setup time required to build the necessary data structures in relation to a fully animated scene is generally much longer. It has not been dealt with. In view of these, some manufacturers have improved real-time ray tracing by developing algorithms that can create efficient 3D trees and reduce the time required to traverse the tree. However, the expected memory requirement in this system increases quadratically as the number of objects subject to ray tracing increases.

  Another manufacturer has designed a ray tracing integrated circuit that uses a bounding volume hierarchy to improve system performance. However, if too many incoherent secondary rays are tracked, the performance of this architecture degrades.

  In addition, attempts have been made to improve system performance by implementing a three-dimensional tree scanning algorithm using a rewritable gate array (FPGA). The increase in processing speed in these systems is primarily due to tracking coherent beam bundles and taking advantage of the capabilities of FPGAs to perform fast hardwired calculations. The construction of the acceleration structure is not yet implemented in hardware. Such FPGA implementations typically use floating point techniques with reduced precision.

SUMMARY OF THE INVENTION The present invention, in its several aspects, addresses high-performance, high-performance techniques that address the above-mentioned problems and can be easily adapted to current ray-tracing devices, as well as methods, systems, and systems that implement such techniques. And providing computer software. In the techniques described herein, memory usage increases linearly with increasing number of objects that are subject to ray tracing. In the run-in analysis, the described technique outperforms the current real-time ray tracing technology.

  The first aspect of the present invention relates to a technology that uses a bounding volume hierarchy in a manner that is highly adapted to real-time ray tracing.

  Another aspect of the present invention addresses the problem of self-intersection in ray tracing. After calculating the intersection of the ray with the surface, the calculated point is used with the direction of the ray to recalculate the intersection of the ray with the surface, thereby realizing an iteration that improves accuracy.

  Another aspect of the present invention enables high performance 3D tree construction by optimization in split plane selection, minimal storage configuration, and tree pruning with approximate left balance.

  Another aspect of the present invention involves the use of a high performance bounding volume hierarchy, where instead of explicitly expressing the bounding box parallel to the coordinate axis, the system implicitly displays the bounding box parallel to the coordinate axis by the interval hierarchy. To express. In one implementation, given a list of objects and a bounding box parallel to the coordinate axes, the system determines the L and R planes and partitions the set of objects accordingly. The system then iteratively processes the left and right objects until some termination criterion is met. Since the number of internal nodes is constrained, it is safe to rely on termination when only one object remains.

  Another aspect of the present invention is to efficiently determine the splitting plane M via the 3D tree construction technique described herein, and then obtain the resulting L and the new bounding box parallel to the coordinate axes and This includes classifying the object so that the overlap between the overlapping portion of the R plane and the proposed division plane M is minimized.

  The present invention provides improved techniques for performing ray tracing and improved techniques for efficient construction of acceleration data structures required for fast ray tracing. The methods, structures and systems according to these techniques are described below.

  Those skilled in the art will understand that the methods and systems described herein are personal computers that operate or emulate in accordance with conventional operating systems such as Microsoft Windows, Linux, or Unix. It should be understood that conventional computer devices such as (PC) or equivalent devices can be implemented as software, hardware, or a combination of software and hardware using a stand-alone configuration or over a network. Accordingly, these various processing means or computing means described below and in the claims can be implemented by software and / or hardware elements of a suitably configured digital processing device or network of devices. Processing can be performed sequentially or in parallel, and can be implemented using special purpose hardware or reconfigurable hardware.

  The method, apparatus, or software product according to the present invention can operate on any of a wide range of conventional computers and systems (eg, network system 100) such as those illustrated in FIG. 1, including standalone, network, It can be either portable or stationary, or includes a conventional personal computer 102, laptop 104, handheld or mobile computer 106 via the Internet or other network 108. The Internet or other network 108 can also include a server 110 and a storage device 112.

  As is done with conventional computer software and hardware, a software application configured in accordance with the present invention can operate within a personal computer 102 as shown, for example, in FIG. In computer 102, program instructions can be read from CD-ROM 116, magnetic disk or other storage device 120 and loaded into RAM 114 for execution by CPU 118. Data can be entered into the system via any known device or means including a conventional keyboard, scanner, mouse, or other element 103.

  FIG. 3 is a flow diagram illustrating a generic method 200 according to one aspect of the present invention. This method is implemented in the context of a computer graphics system where a pixel value is generated for each pixel of the image. Each generated pixel value represents a point in the scene recorded in the image plane of the pseudo camera. The computer graphics system is configured to generate image pixel values using a selected ray tracing method. The selected ray tracing method includes the use of a ray tree that includes at least one ray emitted along the selected direction from this pixel into the scene, and the ray and object (and / or the surface of the object) in the scene, Includes the calculation of the intersection of

  In the method 200 of FIG. 3, the intersection of rays and surfaces in the scene is calculated using the bounding volume hierarchy. In step 201, the bounding box of the scene is calculated. In step 202, it is determined whether or not a predetermined end criterion is satisfied. If not, this process of refining this bounding box parallel to the coordinate axes in step 203 continues iteratively until the termination criteria are met. According to one aspect of the invention, this termination criterion is defined as the state in which the bounding box coordinates differ only by one unit of resolution from the floating point representation of the intersection of the ray and the surface. However, the scope of the present invention extends to other termination criteria.

  The use of the bounding volume hierarchy as an acceleration structure is advantageous for a number of reasons. The memory requirements of the bounding volume hierarchy can be linearly constrained in the number of objects that are subject to ray tracing. Also, as will be described later, the bounding volume hierarchy can be constructed much more efficiently than a 3D tree, as required by a fully animated scene, and is therefore very suitable for leveling analysis. Yes.

  Next, some problems in ray tracing technology and aspects of the present invention that address these problems will be described in more detail. FIG. 4 illustrates the “self-intersection” problem. FIG. 4 shows a ray tracing procedure 300 that includes an image surface 302, an observation point 304, and a light source 306. To synthesize an image of the surface, a series of calculations are performed to locate the ray that extends between the observation point 304 and the surface 302. FIG. 4 shows one such ray 308. Ideally, the exact intersection 310 of the ray 308 and the surface 302 is then calculated.

  However, due to floating point calculations in the computer, the calculated ray-surface intersection 312 may differ from the actual intersection 310. Further, as shown in FIG. 4, the calculated point 312 may be located on the “wrong” side of the surface 302. In that case, when performing calculations to determine the position of the second ray 314 extending from the calculated ray-surface intersection 312 to the light source 306, these calculations do not cause the second ray 314 to extend directly to the light source 306, but rather to the second intersection. 316 indicates hitting the surface, thus resulting in an imaging error.

  One known solution to this self-intersection problem is to start each ray 308 from a safe distance from the surface 302. This safety distance is typically expressed as a general purpose floating point ε. However, the determination of the general-purpose floating point ε largely depends on the scene and the position in the scene where the image is synthesized.

  One aspect of the present invention provides a more accurate alternative. When the intersection 312 between the calculated ray and the surface is obtained, the intersection closer to the actual intersection 310 is recalculated using the calculated point 312 and the direction of the ray 308. This intersection recalculation is incorporated into this ray tracing technique as an iteration to improve accuracy. If this iteratively calculated intersection is located on the “wrong” side of the surface 302, it is moved to the “correct” side of the surface 302. This iteratively calculated intersection can be moved along the surface normal or along an axis determined by the longest component of the normal. Instead of using the general floating point ε, the point is moved by the integer ε to the last bit of the floating point mantissa.

  The above procedure has the advantage of avoiding double precision calculations and implicitly adapting to the scale of floating point numbers determined by the exponent. Thus, in this implementation, all secondary rays start directly from these correction points, eliminating the need for an ε offset. Therefore, when calculating the intersection point, it can be estimated that a valid ray section starts with 0 instead of an offset value.

  Modifying the integer representation of the mantissa also avoids numerical problems when intersecting triangles and planes to identify which point is on which side.

  In order to find the intersection between the ray and the free-form surface using the convex hull characteristic of the convex combination, it is only necessary to refine the bounding box parallel to the coordinate axis including the intersection closest to the origin of the ray. This refinement can continue until the resolution of the floating point number is reached, i.e., the bounding box coordinates differ from the floating point representation by only one unit of resolution. The self-intersection problem can then be avoided by selecting the corner of the bounding box that is closest to the surface normal at the center of the bounding box. The second ray is then started using this corner point. This “light ray / object intersection test” is very efficient and has the advantage of avoiding the self-intersection problem.

  After building the acceleration data structure, the triangles are transformed in place. The new representation encodes degenerate triangles so that the intersection test can handle them without extra effort. Of course, it is possible to simply prevent the degenerate triangle from entering the graphics pipeline. Paragraphs 2.2.1 and 2.2.2 of the annex provide a listing of source code according to this aspect of the invention.

This test first identifies the intersection of the ray with the triangular plane, followed by a reasonable interval along the ray} 0,
Exclude intersections outside result.tfar}. This is accomplished with a single integer test. Note that +0 is excluded from the valid interval. This is important if denormalized floating point numbers are not supported. If this first determination is successful, this test proceeds while calculating the barycentric coordinates of the intersection. To perform a complete inclusion test, only an integer test is required, more specifically, a test with only 2 bits. Therefore, the number of branches is minimal. In order to enable this efficient test, triangle edges and normals are appropriately scaled during the transformation phase (source: scale).

  The accuracy of this test is high enough to avoid false or missed ray intersections. However, during scanning, situations may arise where it is appropriate to extend the triangle for robust intersection testing. This can be done before transforming the triangle. Since the triangle is projected along the axis identified by the longest component of its normal, this projection case needs to be stored. This can be achieved with a leaf node counter in the acceleration data structure. That is, the triangle reference is stored by the projection case, and one leaf contains bytes representing the number of triangles in each class.

  A further aspect of the present invention provides an improved approach to building ray tracing acceleration data structures. Compared to conventional software implementations that follow several different optimizations, the approach described herein forms a fairly flat tree with better ray tracing performance.

  The candidate for the division plane is given by the vertex coordinates of the triangle in the bounding box parallel to the coordinate axis to be classified. This includes vertices that are actually located outside the bounding box, but with at least one coordinate located in one of the three intervals defined by the bounding box. From these candidates, the plane closest to the center of the longest side of the bounding box parallel to the current coordinate axis is selected. Further optimization selects only the coordinates of the triangle that match the normal of the possible split plane with the longest surface normal component. This procedure constitutes a very flat tree because placing the splitting plane through the triangle vertices implicitly reduces the number of triangles split by the splitting plane. Furthermore, the surface is closely approximated and the empty space is maximized. If the number of triangles is higher than the specified threshold and there are no more split plane candidates, the box is split at the center along its longest side. This avoids inefficiencies due to other approaches including the use of long diagonal objects, for example.

  Recursive procedures to determine which triangles belong to the right and left children of a hierarchy node typically required extensive bookkeeping and storage allocation. But there is a much simpler approach that only fails in exceptional cases. Only two arrays of references to objects to be raytraced are assigned. The first array is initialized with an object reference. During the recursive spatial partition, the left element stack grows from the beginning of the array, while the elements classified to the right are maintained in the stack growing from the end of the array toward the center. In order to be able to store elements that intersect the splitting plane (ie, both left and right) at high speed, the second array maintains their stack. Thus, backtracking is efficient and simple.

  Instead of pruning the tree using a surface area heuristic, the tree depth is pruned by approximately left equilibrating the binary space section from the fixed depth. As observed by exhaustive experiments, the global fixed depth parameter can be specified in a very wide variety of scenes. This can be understood from the observation that after a certain degree of binary space segmentation, a spatially relatively flat connected component remains. Paragraph 2.3.1 of the annex provides a listing of source code according to this aspect of the invention.

  By using the bounding volume hierarchy, each object to be ray-traced is referred to only once. As a result, and in contrast to a three-dimensional tree, it does not require a mailbox function to prevent multiple intersections of one object with one ray while traversing the hierarchy. This is a great advantage from a system performance point of view and greatly simplifies implementation in a shared storage system. As a second important result, in the tree of the bounding volume hierarchy, there are no more internal nodes than the total number of objects to be ray-traced. Thus, the memory usage of the acceleration data structure can be linearly constrained in the number of objects before construction. Such a priori constraints cannot be used to build a 3D tree where the complexity of the memory is thought to increase quadratically with the number of objects to be ray-traced.

  Therefore, in this specification, it is a new concept of bounding volume hierarchy that is considerably faster than the current 3D tree ray tracing technology, and as the number of objects subject to ray tracing increases, the memory requirements are quadratic as expected. We describe a new concept that grows linearly rather than growing incrementally. The heart of the concept that bounding volume hierarchies outperform 3D trees is the focus on how the space can be partitioned, not the bounding volume itself.

  In a 3D tree, bounding boxes are partitioned by a single plane. According to this aspect of the invention, two parallel planes are used to define a bounding box that is parallel to the two coordinate axes. FIG. 5 is a diagram showing a basic data structure 400.

FIG. 5 shows a front view of the bounding box 402 parallel to the coordinate axes. The L plane 402 and the R plane 404 are parallel to the coordinate axis and parallel to each other, and are used to divide the bounding box 402 into left and right bounding boxes parallel to the coordinate axis. The left bounding box extends from the left side wall 406 of the original bounding box 402 to the L plane 402. The right bounding box extends from the left side wall 408 of the original bounding box 402 to the R plane 404. Therefore, the left and right bounding boxes may overlap each other. To determine the scan of ray 412, a reasonable interval of ray 410 [N,
Use the intersection position of L] and R planes 402 and 404 for F] 412.

  In the data structure 400 of FIG. 5, the positions of the L and R planes 402 and 404 relative to each other are determined to partition the set of objects contained within the bounding box 402 rather than the space of the original bounding box 402. . In contrast to the 3D tree partition, having two planes gives the possibility of maximizing the empty space between these two planes. As a result, the speed of approximating scene boundaries is significantly improved.

  FIGS. 6-8 are a series of three-dimensional diagrams further illustrating the data structure 400. FIG. 6 shows a diagram of bounding box 402. For illustrative purposes, the virtual object in bounding box 402 is shown as an abstract circle 416. As shown in FIGS. 7 and 8, the bounding box 402 is divided into a left bounding box 402a and a right bounding box 402b using the L plane 404 and the R plane 406. The L and R planes are chosen so that the empty space between them is maximized. Each virtual object 416 enters either the left bounding box 402a or the right bounding box 402b. As shown at the bottom of FIG. 8, the virtual object 416 is divided into a “left” object 416a and a “right” object 416b. Each of the resulting bounding boxes 402a and 402b is also partitioned, and this continues until the termination criteria are met.

  FIG. 9 is a flowchart of the method 500 described above. In step 501, the bounding box of the scene is calculated. In step 502, the bounding box parallel to the coordinate axis using the parallel L and R planes is divided into left and right bounding boxes parallel to the coordinate axis that can be partially overlapped. In step 503, the set of virtual objects contained in the bounding box parallel to the original coordinate axis is divided into a set of left virtual objects and a set of right virtual objects using the left and right bounding boxes. In step 504, processing of the left and right objects continues iteratively until the termination criteria are met.

  Instead of one partition parameter as used in the conventional implementation, two partition parameters are stored in one node. Since the number of nodes is linearly constrained by the number of objects to be ray-traced, an array of all nodes can be assigned at once. Therefore, expensive memory management of the 3D tree at the time of construction becomes unnecessary.

  This construction technique is much simpler than the analog of 3D tree construction and can be easily implemented in a recursive manner or using repetitive versions and stacks. Given a list of objects and bounding boxes parallel to the coordinate axes, the L and R planes are determined and the set of objects is determined accordingly. The left and right objects are then iteratively processed until the end criteria are met. Since the number of internal nodes is constrained, it is safe to rely on termination when only one object remains.

Note that this partition depends only on the sorting of objects along a plane perpendicular to the x, y, and z axes, which is very efficient and numerically stable. In contrast to the three-dimensional tree, it is not necessary here to calculate the exact intersection of the object with the dividing plane, which is expensive and difficult to perform in a numerically robust manner. Missing triangles at vertices and edges (Original: missed
Numerical problems with 3D trees such as triangle) can be avoided by extending the triangles prior to building the bounding volume hierarchy. Also, in 3D trees, partially overlapping objects must be sorted into both left and right bounding boxes parallel to the coordinate axis, causing the expected quadratic growth of the tree.

  A number of techniques are available for determining the L and R planes and thus the actual tree layout. Referring again to FIGS. 6-8, one technique is to determine the plane M418 using the 3D tree construction technique described above, and the resulting L and R plane overlap of the new bounding box parallel to the coordinate axes. Some objects are divided so that the overlap with the proposed division plane M418 is minimized. The resulting tree is very similar to the corresponding 3D tree, but the resulting tree is much flatter because the set of objects is partitioned, not space. Another approach is to select the R and L planes so that child box overlap is minimized and empty space is maximized if possible. It should be noted that the bounding box parallel to the coordinate axis is inefficient for some objects. An example of such a situation is a long cylinder with a short radius located on the diagonal of a bounding box parallel to the coordinate axis.

  FIG. 10 is a flowchart of a method 600 according to this aspect of the invention. In step 601, the bounding box of the scene is calculated. In step 602, a three-dimensional tree construction is executed to determine the division plane M. In step 603, the bounding box parallel to the coordinate axis is divided into left and right bounding boxes parallel to the coordinate axis that minimizes the overlap with the division plane M using the parallel L and R planes. In step 604, the set of virtual objects included in the bounding box parallel to the original coordinate axis is divided into a set of left virtual objects and a set of right virtual objects using the left and right bounding boxes. In step 605, the left and right object processing continues iteratively until the termination criteria are met. Similar to the method 200 shown in FIG. 3, the method 600 shown in FIG. 10 is combined with other methods described herein, including techniques related to 3D tree construction, real-time processing, bucket sorting, self-intersection, etc. Note that they can be combined.

  In the case of a three-dimensional tree, spatial subdivision is continued and the empty space around the object is excised. In the case of the bounding volume hierarchy described above, a similar behavior is obtained if such an object is divided into smaller ones. In order to maintain predictability of memory requirements, a maximum bounding box size is defined. All objects with a range exceeding the bounding box maximum size are divided into smaller parts to meet this requirement. The maximum allowable size can be found by scanning the data set for the minimum range for all objects.

  The data structure described herein allows the principle of high speed 3D tree scanning to be transferred to the bounding volume hierarchy. The case of scanning (source: case) is similar and is as follows. (1) Left child only, (2) Right child only, (3) Left child followed by right child, (4) Right child followed by left child, or (5) Ray splitting plane (Ie empty space). Since one node of the technique described above is divided by two parallel planes, the order of how the multiple boxes are scanned is determined by the direction of the rays. FIG. 6 describes a source code listing that incorporates the techniques described above.

  Previous bounding volume hierarchy techniques have not been able to efficiently determine the additional effort required, such as how to traverse child nodes and updating the heap data structures. Furthermore, while this approach only requires two plane distances, the previous technique required loading the entire bounding volume and testing it against the rays. However, checking the rays against two planes in the software would be expensive. This scanning has become a bottleneck in the 3D tree, where performing further computations better masks memory access latency. Furthermore, the bounding volume hierarchy tree tends to be much smaller than the corresponding 3D tree of the same performance.

Although a new bounding volume hierarchy has been described herein, there is a strong link to traversing the 3D tree. That is, L
Setting = R yields a classical binary space partition and the scanning algorithm is compressed into a 3D tree scanning algorithm.

  By applying the above-described bounding volume hierarchy and subdividing the free-form surface, it is possible to efficiently find the intersection between the ray and the free-form surface. By doing so, depending on the actual floating point calculation, the intersection of the free-form surface and the convex hull characteristic and the subdivision algorithm can be calculated up to the floating point precision. One refinement step is performed, for example, for polynomial surfaces, advantageous surfaces, and approximate refinement surfaces. For each axis in space, the bounding box with potential overlap is determined as described above. For bisection, the intersection of the L box and the intersection of the R box for the new bounding box of the new mesh. Since the spatial order of the boxes is known, the above scan can now be performed efficiently. Instead of pre-calculating the bounding volume hierarchy, this can be calculated in the middle of the process. This approach is efficient for freeform surfaces and saves memory in the acceleration data structure, which is replaced by a small stack bounding volume that must be scanned by backtracking. This subdivision continues and does not end until the intersection of the ray and the surface is located within a bounding volume that is compressed to a point in floating point precision or a small size interval. Paragraph 2.2.1 of the annex provides a listing of codes according to this aspect of the invention.

Using a standard grid as a ray tracing acceleration data structure is simple, but sacrifices efficiency due to lack of spatial adaptability and scanning a large number of empty grid cells. Hierarchical standard grids can improve this situation, but still inferior to bounding volume hierarchies and 3D trees. However, the construction speed of the acceleration data structure can be improved by using the standard grid. The technique for building an acceleration data structure is similar to quicksort, with O (n
log n). Improvements can be obtained by applying a bucket sort that runs in linear time. Therefore, the bounding box parallel to the object coordinate axis is n _x
× n _y × n It is divided into boxes parallel to the _z coordinate axes. Each object is then strictly sorted into one of these boxes by a selected point, such as the center of gravity. Alternatively, the first vertex of each triangle may be used. Then, a bounding box parallel to the actual coordinate axis of the object in each grid cell is specified. These bounding boxes are used instead of the objects contained by the bounding boxes parallel to these coordinate axes, as long as the bounding boxes do not intersect any of the dividing planes. If this happens, the box will unpack and use the objects in the box directly. This procedure eliminates many comparisons and memory accesses, significantly improves the ordering constant of the construction technique, and can be applied iteratively. The technique described above is particularly attractive for hardware implementation because it can be implemented by processing a stream of objects.

  An acceleration data structure can be constructed on demand, ie when a ray scans a bounding box parallel to the coordinate axis with the object. In addition, the acceleration data structure is never refined in a spatial region that is transparent to rays, and the cache is not polluted by untouched data. On the other hand, after refinement, substances that can cross the rays are already in the cache.

  From the above description, it should be understood that the present invention addresses a long known problem in ray tracing and provides a ray tracing technique with improved accuracy, overall speed, and memory usage of acceleration data structures. It is. The improvement in numerical accuracy is transmitted to other number systems, for example, the logarithmic system used in the hardware of the ART ray tracing chip. Implementation of the IEEE floating point standard for processors or dedicated hardware can have a significant impact on performance. For example, in the Pentium® 4 chip, the denormalized number can degrade performance by more than 100 times, as described above, the implementation of the present invention avoids these exceptions. The bounding volume hierarchy views described herein make these hierarchies suitable for real-time ray tracing. In break-in analysis, the techniques described here outperform the prior art in terms of capabilities, and use more precise techniques for motion blur calculations in scenes that are fully animated, such as at the production site. it can. It should be clear from the above description that the bounding volume hierarchy described here has significant advantages over 3D trees and other techniques, especially for larger scenes in hardware implementations. In the run-in analysis, the bounding volume hierarchy described here outperforms the current 3D tree by at least twice. Furthermore, the memory usage can be specified in advance and is linear with the number of objects.

While the above description includes details to enable those skilled in the art to practice the invention, the description is illustrative and many modifications and changes will occur to those skilled in the art who are familiar with the teachings herein. It should be clear that deformation is possible. Accordingly, the invention is defined solely by the appended claims, which are intended to be construed as broadly as possible in view of the prior art.

1 is a schematic diagram of a conventional digital processing system in which the present invention can be introduced. 1 is a schematic diagram of a conventional personal computer or similar computing device into which the present invention can be introduced. 2 is a flowchart illustrating a comprehensive method according to the first aspect of the present invention. FIG. 6 is a ray tracing procedure illustrating the “self-intersection” problem. FIG. 6 is a front view of a segmented bounding box parallel to a coordinate axis used as an acceleration data structure according to another aspect of the present invention. FIG. 6 is a series of isometric views of the bounding box parallel to the coordinate axes of FIG. 5 showing the bounding box sections in the L and R planes. FIG. 6 is a series of isometric views of the bounding box parallel to the coordinate axes of FIG. 5 showing the bounding box sections in the L and R planes. FIG. 6 is a series of isometric views of the bounding box parallel to the coordinate axes of FIG. 5 showing the bounding box sections in the L and R planes. 5 is a flowchart of a ray tracing method according to a further aspect of the present invention. 5 is a flowchart of a ray tracing method according to a further aspect of the present invention.

Claims (19)

A computer graphics system that generates a pixel value for a pixel in the image that represents a point in the scene recorded in the image plane of the pseudo camera, using the selected ray tracing method to generate the pixel value for the image The selected ray tracing method includes the use of a ray tree that includes at least one ray emitted along the selected direction from the pixel into the scene, and the ray and object in the scene. In a computer graphics system, including the calculation of the intersection with a surface,
Calculating an intersection of a ray and an object in the scene using a bounding volume hierarchy, the calculating step comprising:
Defining, using, recursively and adaptively refining a bounding box parallel to the coordinate axis to determine the position of the ray / object intersection closest to the origin of the ray for a given ray;
Recursively refining a bounding box parallel to the coordinate axes until a predetermined termination criterion is met;
Calculating the intersection point of the ray with the object and then using the value of the calculated point together with the direction of the corresponding ray to iteratively recalculate the intersection point closer to the actual intersection point;
Said step of defining, utilizing, recursively and adaptively refining,
(A) By constructing a three-dimensional tree based on triangular coordinates formed by dividing the surface of the scene, a set of virtual objects in one bounding box parallel to the coordinate axis is defined as a set of left objects. Determining a dividing plane M for partitioning into a set of right objects;
(B) An L plane for defining a left bounding box that includes the split plane and that contains the set of left objects, and an R that defines the right bounding box that includes the split plane and that includes the set of right objects. A plane is specified, which is parallel to each other such that the volume of the overlapping portion between the dividing plane M and the L plane and the volume of the overlapping portion between the dividing plane M and the R plane are minimized. Identifying the L plane and the R plane.
Improvement method. The step of performing the 3D tree construction includes:
Identifying split plane candidates based on the vertex coordinates of a triangle in a bounding box parallel to the coordinate axis to be partitioned;
The improvement method according to claim 1 , further comprising: selecting a plane closest to the center of the longest side of the bounding box parallel to the current coordinate axis from the set of candidates. The improved method of claim 2 , wherein the step of selecting further comprises selecting only the coordinates of a triangle whose longest surface normal component matches the normal of the potential split plane. Identifying whether the triangle intersecting the dividing plane is included in the left or right section of the bounding box parallel to the coordinate axis, the identifying step first identifying the intersection of the triangle with the dividing plane. Calculating to generate a “crossing line”; and then identifying how the crossing line is located relative to a rectangle defined by the intersection of the dividing plane and the bounding box; The improvement method of Claim 2 containing these. Further comprising an improved method of claim 4 the step of determining based on the order of scanning of the bounding volume hierarchy beam direction. 6. The improved method of claim 5 , wherein the bounding volume hierarchy is calculated in real time as needed to process the image. Further comprising building a raytracing acceleration data structure based on bucket sorting, the building comprising:
Partitioning a bounding box parallel to the coordinate axes containing the object into boxes parallel to n _x × n _y × n _z coordinate axes;
Sorting each object strictly into one of the boxes by a selected point, the selected point including either the center of gravity or the first vertex of each triangle; and
And a step of identifying the parallel bounding box to the axis including the object in each grid cell, an improved method of claim 6.   The improved method of claim 1, wherein if the calculated intersection is below the surface of the scene, the calculated point is moved to the other side of the surface to provide a modified calculation point. 9. The improved method of claim 8 , wherein the movement is along a surface normal or along an axis determined by the longest component of the surface normal. 9. The method of claim 8 , wherein the movement is performed by moving the last bit of a floating-point mantissa representing an intersection point with an integer epsilon, and a secondary ray is defined to start from the modified calculation point.   Further comprising using a ray / triangle intersection test, wherein the intersection of the ray in the scene and the surface triangulation plane of the surface is identified and the intersection outside the predetermined effective interval in the ray is excluded. The improved method according to claim 1. A computer graphics system that generates a pixel value for a pixel in the image that represents a point in the scene recorded in the image plane of the pseudo camera, using the selected ray tracing method to generate the pixel value for the image The selected ray tracing method includes the use of a ray tree that includes at least one ray emitted along a selected direction from the pixel into the scene, and the ray and object in the scene. In a computer graphics system including the calculation of the intersection of
Including computer-executable software code operable to allow calculation of the intersection of rays and objects in the scene by utilizing a bounding volume hierarchy, the calculation comprising:
Defining, using, recursively and adaptively refining a bounding box parallel to the coordinate axis to determine the position of the ray / object intersection closest to the origin of the ray for a given ray;
Continuing the refinement of the bounding box parallel to the coordinate axis until a predetermined termination criterion is met;
Calculating the intersection point of the ray with the object and then using the value of the calculated point together with the direction of the corresponding ray to iteratively recalculate the intersection point closer to the actual intersection point;
Said step of defining, utilizing, recursively and adaptively refining,
(A) By constructing a three-dimensional tree based on triangular coordinates formed by dividing the surface of the scene, a set of virtual objects in one bounding box parallel to the coordinate axis is defined as a set of left objects. Determining a dividing plane M for partitioning into a set of right objects;
(B) An L plane for defining a left bounding box that includes the split plane and that contains the set of left objects, and an R that defines the right bounding box that includes the split plane and that includes the set of right objects. A plane is specified, which is parallel to each other such that the volume of the overlapping portion between the dividing plane M and the L plane and the volume of the overlapping portion between the dividing plane M and the R plane are minimized. Identifying the L plane and the R plane.
Improvement method. A computer graphics system that generates a pixel value for a pixel of an image that represents a point in a scene recorded in the image plane of a pseudo camera, the computer graphics system using a selected ray tracing method. The selected ray-tracing method includes the use of a ray tree that includes at least one ray emitted along a selected direction from the pixel into the scene. Calculating a point of intersection of a light ray and an object surface in the scene, the computer graphics system comprising:
Means for calculating an intersection of a ray and an object in the scene by utilizing a bounding volume hierarchy, the means for calculating comprising:
Means for defining, utilizing, recursively and adaptively refining a bounding box parallel to the coordinate axis to determine the position of the ray / object intersection closest to the origin of the ray for a given ray;
Means for continuing the refinement of the bounding box parallel to the coordinate axis until a predetermined termination criterion is met;
Means for calculating the intersection point of the ray with the object and then recalculating the intersection point closer to the actual intersection point using the value of the calculated point together with the direction of the corresponding ray;
Said means to define, use, refine recursively and adaptively,
(A) By constructing a three-dimensional tree based on triangular coordinates formed by dividing the surface of the scene, a set of virtual objects in one bounding box parallel to the coordinate axis is defined as a set of left objects. A process of determining a dividing plane M for partitioning into a set of right objects;
(B) An L plane for defining a left bounding box that includes the split plane and that contains the set of left objects, and an R that defines the right bounding box that includes the split plane and that includes the set of right objects. A plane is specified, which is parallel to each other so that the volume of the overlapping portion between the divided plane M and the L plane and the volume of the overlapping portion between the divided plane M and the R plane are minimized. Performing the process of specifying the L plane and the R plane;
Computer graphics system. A computer graphics system that generates a pixel value for a pixel in the image that represents a point in the scene recorded in the image plane of the pseudo camera, using the selected ray tracing method to generate the pixel value for the image The selected ray tracing method includes the use of a ray tree that includes at least one ray emitted along the selected direction from the pixel into the scene, and the ray and object in the scene. Calculating a point of intersection of a ray and an object in the scene, comprising: calculating a point of intersection with a surface, comprising:
Building a bounding volume hierarchy, the building step comprising:
Defining, using, recursively and adaptively refining a bounding box parallel to the coordinate axis to determine the position of the ray / object intersection closest to the origin of the ray for a given ray;
Continuing the refinement of the bounding box parallel to the coordinate axis until a predetermined termination criterion is met;
Calculating the intersection point of the ray with the object and then using the value of the calculated point together with the direction of the corresponding ray to iteratively recalculate the intersection point closer to the actual intersection point;
Said step of defining, utilizing, recursively and adaptively refining,
(A) By constructing a three-dimensional tree based on triangular coordinates formed by dividing the surface of the scene, a set of virtual objects in one bounding box parallel to the coordinate axis is defined as a set of left objects. Determining a dividing plane M for partitioning into a set of right objects;
(B) An L plane for defining a left bounding box that includes the split plane and that contains the set of left objects, and an R that defines the right bounding box that includes the split plane and that includes the set of right objects. A plane is specified, which is parallel to each other such that the volume of the overlapping portion between the dividing plane M and the L plane and the volume of the overlapping portion between the dividing plane M and the R plane are minimized. Identifying the L plane and the R plane.
How to calculate the intersection point. The method of claim 2 , further comprising the step of subdividing the bounding box.   Selecting a point at which to start the secondary ray, wherein the step of selecting selects a corner of the bounding box that is closest to the surface normal at the center of the box, and to the selected corner; The method of claim 1, comprising starting the secondary ray with the corresponding point. The step of constructing a three-dimensional tree further comprises performing tree pruning by left balancing from a selected depth, wherein the tree pruning approximates a binary space partition from the selected depth 3. The improved method of claim 2 , comprising the step of pruning the tree depth by left-balanced.   The improved method of claim 1, further comprising the step of building the bounding volume hierarchy in real time and on demand. A computer graphics system that generates a pixel value for a pixel in the image that represents a point in the scene recorded in the image plane of the pseudo camera, using the selected ray tracing method to generate the pixel value for the image The selected ray tracing method includes the use of a ray tree that includes at least one ray emitted along the selected direction from the pixel into the scene, and the ray and object in the scene. In a computer graphics system, including the calculation of the intersection with a surface,
Calculating an intersection of a ray and an object in the scene using a bounding volume hierarchy, the calculating step comprising:
Defining, using, recursively and adaptively refining a bounding box parallel to the coordinate axis to determine the position of the ray / object intersection closest to the origin of the ray for a given ray;
Continuing the refinement of the bounding box parallel to the coordinate axis until a predetermined termination criterion is met,
Said step of defining, utilizing, recursively and adaptively refining,
Selecting the corner of the bounding box that is closest to the surface normal at the center of the box and starting the secondary ray with the point corresponding to the selected corner;
Utilizing a three-dimensional tree construction, wherein the construction includes performing tree pruning by left balancing from a selected depth, wherein the tree pruning is performed from the selected depth. Pruning the tree depth by approximately left equilibrating the binary space partition,
Said step of defining a bounding box parallel to the coordinate axes,
(A) By constructing a three-dimensional tree based on triangular coordinates formed by dividing the surface of the scene, a set of virtual objects in one bounding box parallel to the coordinate axis is defined as a set of left objects. Determining a dividing plane M for partitioning into a set of right objects;
(B) An L plane for defining a left bounding box that includes the split plane and that contains the set of left objects, and an R that defines the right bounding box that includes the split plane and that includes the set of right objects. A plane is specified, which is parallel to each other such that the volume of the overlapping portion between the dividing plane M and the L plane and the volume of the overlapping portion between the dividing plane M and the R plane are minimized. Identifying the L plane and the R plane,
Further comprising iteratively processing the left and right objects until the termination criteria are met,
In step (a), said step of building a three-dimensional tree comprises:
(A1) identifying a candidate for a split plane based on the vertex coordinates of a triangle in a bounding box parallel to the coordinate axis to be segmented;
(A2) selecting a plane closest to the center of the longest side of the bounding box parallel to the current coordinate axis from the set of candidates, wherein the normal of the split plane where the longest component of the surface normal is possible Further comprising selecting only the coordinates of a triangle that matches
The bounding volume hierarchy is built in real time and on demand,
An improved method of calculating the intersection point of the ray and the object, and then recalculating the intersection point closer to the actual intersection point using the value of the calculated point together with the direction of the corresponding ray.

Images