|Publication number||USRE42406 E1|
|Application number||US 11/091,003|
|Publication date||May 31, 2011|
|Priority date||Jun 18, 1998|
|Also published as||EP0965948A2, EP0965948A3, US6421051, US6538652, US20020075263|
|Publication number||091003, 11091003, US RE42406 E1, US RE42406E1, US-E1-RE42406, USRE42406 E1, USRE42406E1|
|Inventors||Saul S. Kato|
|Original Assignee||Sugarloaf Acquisitions, Llc|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (50), Non-Patent Citations (29), Referenced by (1), Classifications (7), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This application is a continuation of U.S. patent application Ser. No. 09/243,099, filed on Feb. 2, 1999, which claims priority under 35 U.S.C. §119(e) from U.S. provisional patent application serial No. 60/089,794, filed on Jun. 18, 1998.
1. Field of the Invention
This invention relates to the field of generating three-dimensional graphics; more specifically, to the field of generating multiple resolutions of an object in a three-dimensional environment.
2. Background of the Invention
Realistic three-dimensional object rendering for use in games and other software applications has been the goal for software and hardware makers in the computer industry for years. However, numerous problems prevent the achievement of realistic three-dimensional object rendering on a typical user's home computer.
Three-dimensional graphics use polygons to create the object to be rendered. These polygons are created and manipulated to portray curvature and details of the object. The more polygons used to create an object, the more detailed and realistic an object will appear. However, the more polygons used to create an object, the more computations required to render the object, thus slowing down the speed at which the object is rendered. Thus, there is a tradeoff from the developer's standpoint between speed and realism.
The resolution of this problem is not easy. As most users do not have the latest, most powerful personal computer, the developer must design the objects for the lowest common denominator if the developer wants to reach the greatest number of potential users for the product. Thus, the developer must assume the user's processor is slow and is therefore capable of only rendering a small number of triangles per second. Therefore, the developer, when making the tradeoff described above, must favor the speed side of the equation, and design objects with fewer triangles than if faster machines were being used by all users. This solution, however, pleases neither the user with a low-end computer nor the user with the high-end computer. The user with the low-end computer will most likely still have images which are slow and choppy, because the developers are unwilling to completely sacrifice realism, and the user with a high-end computer will have images which appear artificial and robotic because the application is not designed to take advantage of the high-end machine's greater processing power. In fact, on some high-end systems, the application will be too fast to play or interact with because the polygon count is too low.
Another problem facing the developer is the fact that the same object requires more detail when closer to the screen than it requires if it is in the background. When an object is closer to the screen, the angles and straight edges of the polygons comprising the object can be seen more clearly. At this point, more polygons are needed to smooth the angles and continue the realistic rendering of the object. However, the most detailed version of the object cannot always be used to render the object because the application will require too much computing power to quickly and smoothly render images on the screen. In order to achieve smooth 3D animation, the processor must render 3D objects at 20 to 60 frames per second. If too many polygons are used for each object, thus providing the necessary realism for the object when it is close to the screen, then the processor will not be able to achieve the above minimum frame rate required for smooth rendering.
One solution to allow realistic rendering of three-dimensional objects while also limiting the number of polygons on the screen is to use Level of Detail mapping. Level of Detail mapping provides different levels of resolutions of an object based upon the distance of the object to the screen. In order to create the different levels of detail, the developer must create different versions of the object for each level required. Typically, only three or four levels are used because storage of multiple versions of each object to be rendered can consume too much of the user's system resources.
There are several drawbacks to the level of detail methodology. First, this method has a large impact on system resources, as described above. Each object now requires three or four times more storage space than previously required to store each version of the object. Each level requires a separate vertex list as well as a separate data structure. Second, when transitioning from one level to another, an effect known as object popping occurs. The higher detailed version of an object is abruptly rendered as the object moves towards the screen, and “pops” out at the viewer, ruining the 3D immersive qualities of the application. The level of detail method also requires extra authoring of each version of the object, requiring more time from the developer. Level of Detail also does not address the lowest common denominator problem described above. The highest level of detail of each object must be created in consideration of the user with an inefficient computer who will be using the application. Thus, the highest level of detail cannot contain too many polygons or the image will appear slow and choppy on the low-end user's computer. Again, this image will also appear angular and robotic on the high-end user's computer, as it does not take advantage of the high-end computer's greater processing power.
In accordance with the present invention, an apparatus, system, and method is disclosed for producing realistic rendering of a 3D object while minimizing the use of user system resources and maximizing fidelity without sacrificing speed. The invention produces a continuous level of detail of an object using vertex merging responsive to the location of the object on the screen and other factors, thus eliminating the object popping effect. As the object moves towards the background, and therefore requires less polygons in order to provide a realistic rendering, vertices of the object are merged together in a manner designed to cause the least visual distortion. As the vertices are merged, polygons within the object are eliminated, thus lowering the polygon count of the object continuously as it moves farther and farther away from the screen. As an object moves towards the screen, vertices are added to the object, adding polygons to the object and thus providing a more realistic representation of the object as it grows close to the user and fine details become necessary. Thus, at any given moment, every object on the screen only has as many polygons as is required to provide a realistic rendering of the object. No polygons are being unnecessarily drawn, and thus optimum use is being made of the user's system. No object-popping effects are created as polygons are added or removed from the object on a continual basis based on the object's movement in the 3D environment.
Additionally, the invention requires only one version of the object to be authored and stored on the user's system, thus minimizing the impact on system resources. One vertex list is used which preferably specifies the highest level of detail, and the system in accordance with the present invention is able to then generate the continuous level of detail of the object for display on the screen. Also, the system advantageously increases and decreases the resolution of the objects on the fly. Thus, as only the current level of detail being displayed is stored, minimal use of memory is required. By storing certain minimum information which is determined prior to run-time to guide the resolution changes, the resolution changing is performed at run time at optimal speed. Another benefit of the present invention is its ability to allow a developer to tweak the vertex merging in accordance with the developer's own preferences. Finally, the invention automatically adjusts the amount of polygons in a screen responsive to the capabilities of a user's system, providing an optimal image for every user. In one embodiment, the invention monitors the system to determine the frame rate at which the frames are being rendered, and adjusts the total amount of polygons allowable on the screen at one time accordingly.
Additionally, a target frame rate may be set, which allows the user to specify the speed at which the scenes should be rendered. The present invention then dynamically adjusts the total amount of polygons to ensure the frame rate is maintained. Alternatively, the invention allows a polygon count to be specified, and then ensures that this amount of polygons is always on the screen, regardless of the frame rate.
In a preferred embodiment, a three-dimensional visual representation of an object having multiple resolutions is created by retrieving a vertex list for the object, determining a collapse order for the vertices identified in the vertex list, reordering the vertices identified in the vertex list responsive to the determined collapse order, and creating a vertex collapse list responsive to the collapse order, where the vertex collapse list specifies, for a target vertex, a neighbor vertex to collapse to. The vertex list may comprise 3D coordinates of vertices without referring to other vertex attributes or, in alternate embodiments, the vertex list may refer to other vertex attributes such as colors or normals.
More specifically, in a preferred embodiment, the collapse order of the object is determined by determining an optimal collapse path from the set of collapse paths, computing visual distortion factors for the selected collapse path, determining a collapse value for the selected collapse path, repeating for each path in the set of collapse paths, comparing the collapse values to determine a collapse path causing a least visual distortion to the object, selecting a next vertex to be collapsed, collapsing the object along the selected path, and repeating until a minimum resolution level is attained.
The data source 196 stores the original vertex list for processing. Data sources include the application requesting the object modeling, or a secondary source which stores objects requiring modeling in accordance with the present invention. In one embodiment, the modules 138, 142, 146, 150 are implemented as a set of Field Programmable Gate Arrays, and are programmed to perform the separate functions described above. By compartmentalizing the separate functions in a distributed architecture, faster and more robust processing is achieved.
The vertex list 158 may specify a maximum set of vertices used in the object, or a maximum and a minimum set of vertices in the object. The minimum set of vertices is specified by the developer 166 to define a minimum quality level the object may not be collapsed beyond. As more vertices are collapsed in an object, the less realistic the object appears if examined closely. Therefore, for some objects the developer 166 may decide that there is a point beyond which the object is no longer recognizable as its true shape, even though the object at that point is very small on the screen and therefore does not require many polygons to specify sufficient detail. For these objects, the developer 166 specifies a minimum set of vertices to which the object may be collapsed. The system identifies these vertices during its processing, and does not collapse those vertices in the object. The vertex list 158 may also specify a nested set of vertex sets that represent progressively lower resolutions of the object. In this case the system generates a collapse list that interpolates between the nested vertex sets.
After the vertex list has been retrieved, the system proceeds to determine 204 a collapse order. The collapse order of an object is specifies the order in which individual vertices are merged into other vertices. Vertices are collapsed along collapse paths, with the goal of causing the least visual distortion possible for the object. For example, as shown in
After determining a collapse order for the object, the vertex list 158 is reordered 208 into the order specified by the collapse order. The vertex to be collapsed first is identified and the other vertices are sequenced accordingly based on their collapse priority. The system advantageously minimizes its footprint in memory by using the existing vertex list 158, instead of using another construct to store this information. Next, the system creates 212 a vertex collapse list 154. This list specifies the vertex to which the target vertex is to be collapsed; alternatively, the list specifies the vertices to which to connect an added vertex. When collapsing vertices in an object to achieve a lower resolution, the system may simply eliminate vertices as ordered in the vertex list until the desired resolution is obtained. However, in order to increase the resolution of the object by adding vertices, more information is needed. In each case, a correct triangle list must be generated by the system at the desired resolution. The triangle list specifies connectivity information regarding all of the triangles which must be rendered to achieve a given resolution.
For example, as shown in
Next, a collapse path from the set of collapse paths is selected 304. Visual distortion factors are computed 308 for the selected collapse path. Visual distortion factors are measurements of the effect of a given collapse on the object. Some collapse paths will have a much greater visual effect on the user than others. For example, if V1 is collapsed to V2, the object will appear to shrink noticeably in width. However, if V8 is collapsed to V11, the object will not appear as distorted to the user. The system preferably captures these distinctions by computing several visual distortion factors, including area change, angular deviation, and local volume change, described in greater detail below.
Each collapse path is given 312 a collapse value as a function of the computed visual distortion factors for that path. The collapse value is preferably a weighted combination of the visual distortion factors for the path. Weighting the different factors allows the developer 166 to specify the importance of the factors as applied in the particular application being developed.
The system determines 316 whether there are more collapse paths. If there are more collapse paths, a next path is selected 304 and the process described above is repeated. If there are no more collapse paths, the system compares the collapse values of the collapse paths to determine 220 a collapse path which causes the least visual distortion to the object.
The vertex to be collapsed is identified 324 responsive to the determined collapse path, and a collapse priority is assigned 326 to the vertex to be used upon reordering the vertex list. The object is collapsed 328 along the collapse path. The system determines 332 if there are more than one vertex not in the minimum point set remaining. If there are not, the system then moves to reordering the vertex list 158. If there are more than.one vertex remaining, the system repeats the above process, treating the collapsed object as a new object to be processed. The system processes the object until a set of collapse paths are determined which cause the least visual distortion to the object, and reduce the object from a maximum resolution to a minimum resolution. For each collapse path stored, the vertices to which the target vertex is connected, and the change in connectivity as expressed by the triangle list are stored. When the vertex is added to the object, this allows the system to know which other vertices are connected to the added vertex by which triangles. This information is stored in the vertex collapse list 154, as described above.
Next, a neighbor vertex is identified 408. A neighbor vertex is a vertex connected along an edge to the target vertex. A neighbor vertex would include any vertex directly connected to the target vertex, as well as any vertex which is connected to the target vertex through another vertex or vertices. As can be imagined, this list may grow very large if every vertex is processed. However, as described above, a maximum number of neighbor vertices may be specified to minimize processing.
After identifying a neighbor vertex, a collapse path is determined 412 between the target vertex and the neighbor vertex. The system determines 416 whether the maximum number of collapse paths have been reached. If it has, the system determines 420 whether there are more vertices. If there are more vertices, the collapse paths for the other vertices are computed as described above. If there are no more vertices, the system selects 304 a collapse path from the set of collapse paths.
For example, in
Thus, as shown in
In one embodiment, collapse values are calculated for each path and the paths are prioritized as described above. The path designated to be collapsed first is chosen as the first path to be collapsed and displayed to the developer 166. If the developer 166 selects this path, the path retains its priority. A new set of collapse paths is generated and the highest prioritized path from the new set selected for display to the developer 166. If the developer 166 does not select the path, the next highest prioritized path is selected and displayed to the developer 166. Of course, the developer 166 may specify at any time a particular path the developer 166 sees in the object the developer 166 wants collapsed. Such a selection by the developer 166 overrides any previous prioritization by the system.
In another embodiment, texture maps are indexed by the vertices. Texture maps provide texture for the mapped area, giving an object a realistic appearance. Textures for different triangles may be quite different. Therefore, when a triangle is collapsed, the system must determine the affect of the loss of the texture of the triangle on the appearance of the object. Vertices which are on the edges of texture discontinuities are not collapsed, because of the affect the collapse will have on the appearance of the object. Thus, when collapse paths are selected, the vertices in the path are examined to determine if they are located on the edge of a texture discontinuity. If they are, the collapse path is not selected.
In one embodiment, the extended tables for each object are already created in the development stage, and the tables are simply loaded into data memory for easy access when the application is initiated. The runtime manager awaits a request from the application for a collapse level from an object. The original appearances of each object are represented in a default resolution. When the application or the graphics program requests 1008 an increased or decreased resolution from the runtime manager, the runtime manager determines 1012 whether the requested resolution requires a collapse level greater than the current collapse level of the object. The current collapse level is known because the current collapse level of the object is the only version of the object which is stored in memory. If the requested resolution requires a greater collapse level for the object, vertices are added to the object in accordance with the vertex collapse information in the table until the requested collapse level is met. This continuous addition of vertices provides for a smooth rendering of the object, and eliminates the object-popping problem discussed above. Similarly, if the requested resolution requires a collapse level which is less than the current collapse level, vertices are collapsed 1016 until the proper resolution of the object is achieved. The table allows for instantaneous addition and subtraction of polygons to the object upon request. The table also allows for a minimal memory footprint by the present invention as entire versions of the objects are not required to be stored. The continual addition or subtraction of polygons to an object eliminates the object-popping artifacts. Thus, in accordance with the present invention, an efficient, high-speed object modeling process is disclosed which provides multiple levels of resolution while minimizing resource use.
The projected area of an object is another factor which is used by the runtime manager to determine an optimal collapse level for an object. The projected area of an object is the area which the object will occupy as rendered on the display. The greater the projected area of an object, the higher the resolution that is required. The system determines 1208 the current projected area of the object, and compares 1212 the projected area to a table which correlates projected area and collapse levels. The polygon count is then adjusted 1232 accordingly.
The present invention also provides for global polygon count management. In this embodiment, the user selects a target polygon count for each frame. In this embodiment, the system determines 1216 the number of polygons currently being displayed in a frame. The total number of polygons displayed in a frame may be calculated by determining which objects are on screen and totaling the number of polygons in each object, or by having the renderer keep an internal tally of how many triangles it drew on screen in one frame. This number is compared 1220 to the predefined target polygon count. If the runtime manager determines 1232 that the current polygon count is less than the target polygon count, more polygons are added 1236. If the current polygon count is greater than the target polygon count, polygons are subtracted 1240 away. The determination of which objects to add and subtract polygons to and from may be made in a number of ways. Polygons may be added and removed uniformly to and from all polygons. Alternatively, objects may be individually analyzed and polygons added and subtracted on an individual basis.
Alternatively, the user 170 is able to select a target frame rate. The manager determines 1224 a current frame rate by monitoring the processor clock and determining how long it is taking to render frames. The current frame rate is then compared 1228 to the target frame rate. If runtime manager determines 1232 that the current frame rate is faster than the target frame rate, polygons are added 1236 to the frame to slow the frame rate down. If the current frame rate is slower than the target frame rate, polygons are subtracted 1240 from the frame to speed the frame rate up. Thus, the runtime manager allows for dynamic global polygon management requiring minimal input from the user 170. This management process allows the present invention to be platform universal, as if the invention is used on a system with a slower processor, the target frame rate or polygon count may be set lower, and the benefits described above are still provided. However, a system with a faster processor can be set to have a higher frame rate or polygon count, and the higher processing power of the system is maximized by the present invention.
The present invention may also be used to transmit data through remote connections, as illustrated in
As shown in
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5428717 *||Dec 30, 1991||Jun 27, 1995||Xerox Corporation||Methods for converting concave polyhedra to their convex hulls|
|US5715384 *||Feb 1, 1995||Feb 3, 1998||Canon Kabushiki Kaisha||Real-time image display method and apparatus displaying two different visual resolutions|
|US5870307 *||Jun 7, 1995||Feb 9, 1999||3D Systems, Inc.||Method and apparatus for production of high resolution three-dimensional objects by stereolithography|
|US5886702 *||Oct 16, 1996||Mar 23, 1999||Real-Time Geometry Corporation||System and method for computer modeling of 3D objects or surfaces by mesh constructions having optimal quality characteristics and dynamic resolution capabilities|
|US5903272||Aug 14, 1996||May 11, 1999||Canon Kabushiki Kaisha||Apparatus and method for determining a rendering order between first and second object surface primitives|
|US5929860 *||Feb 7, 1997||Jul 27, 1999||Microsoft Corporation||Mesh simplification and construction of progressive meshes|
|US5963209 *||Jan 11, 1996||Oct 5, 1999||Microsoft Corporation||Encoding and progressive transmission of progressive meshes|
|US5966133||Feb 7, 1997||Oct 12, 1999||Microsoft Corporation||Geomorphs and variable resolution control of progressive meshes|
|US5966140 *||Jun 20, 1997||Oct 12, 1999||Microsoft Corporation||Method for creating progressive simplicial complexes|
|US6009435||Nov 21, 1997||Dec 28, 1999||International Business Machines Corporation||Progressive compression of clustered multi-resolution polygonal models|
|US6018347||Apr 10, 1997||Jan 25, 2000||Multigen Paradigm, Inc.||Methods and apparatus for rendering three-dimensional images|
|US6031548||Feb 13, 1998||Feb 29, 2000||International Business Machines Corporation||Progressive multi-level transmission and display of triangular meshes|
|US6046744 *||Feb 7, 1997||Apr 4, 2000||Microsoft Corporation||Selective refinement of progressive meshes|
|US6108006 *||Apr 3, 1997||Aug 22, 2000||Microsoft Corporation||Method and system for view-dependent refinement of progressive meshes|
|US6130673||Apr 18, 1997||Oct 10, 2000||Silicon Graphics, Inc.||Editing a surface|
|US6137492||Apr 3, 1997||Oct 24, 2000||Microsoft Corporation||Method and system for adaptive refinement of progressive meshes|
|US6139433 *||Jun 5, 1997||Oct 31, 2000||Nintendo Co., Ltd.||Video game system and method with enhanced three-dimensional character and background control due to environmental conditions|
|US6169549||Jan 7, 1998||Jan 2, 2001||Iengineer.Com, Inc.||Method and apparatus for providing continuous level of detail|
|US6175365 *||Jan 4, 1999||Jan 16, 2001||International Business Machines Corporation||Surface simplification preserving error tolerances|
|US6184897 *||Jan 14, 1998||Feb 6, 2001||International Business Machines Corporation||Compressed representation of changing meshes and method to decompress|
|US6198486||Sep 23, 1998||Mar 6, 2001||Intel Corporation||Method of using a hybrid error metric for multi-resolution mesh generation|
|US6256041||Jun 11, 1998||Jul 3, 2001||Sun Microsystems, Inc.||Decompression of three-dimensional geometry data representing a regularly tiled surface portion of a graphical object|
|US6262737 *||Jul 31, 1998||Jul 17, 2001||University Of Southern California||3D mesh compression and coding|
|US6285372||May 8, 1998||Sep 4, 2001||Lawrence C. Cowsar||Multiresolution adaptive parameterization of surfaces|
|US6307551 *||Jan 14, 1998||Oct 23, 2001||International Business Machines Corporation||Method for generating and applying changes in the level of detail of a polygonal surface|
|US6362833||Apr 8, 1998||Mar 26, 2002||Intel Corporation||Method and apparatus for progressively constructing a series of morphs between two-dimensional or three-dimensional models|
|US6396490 *||Dec 4, 1998||May 28, 2002||Intel Corporation||Efficient representation of connectivity information in progressive mesh update record|
|US6414683 *||Jan 4, 1999||Jul 2, 2002||International Business Machines Corporation||Surface simplification preserving a solid volume|
|US6421051||Feb 2, 1999||Jul 16, 2002||Spatial Corporation||Multi-resolution geometry|
|US6426750 *||Jul 14, 1998||Jul 30, 2002||Microsoft Corporation||Run-time geomorphs|
|US6529207||May 31, 2000||Mar 4, 2003||Webtv Networks, Inc.||Identifying silhouette edges of objects to apply anti-aliasing|
|US6538652||Feb 15, 2002||Mar 25, 2003||Saul S. Kato||Multi-resolution geometry|
|US6611267||May 14, 2002||Aug 26, 2003||Viewpoint Corporation||System and method for computer modeling of 3D objects or surfaces by mesh constructions having optimal quality characteristics and dynamic resolution capabilities|
|US6750864||Nov 15, 2000||Jun 15, 2004||Polyvista, Inc.||Programs and methods for the display, analysis and manipulation of multi-dimensional data implemented on a computer|
|US6771261||Aug 30, 2001||Aug 3, 2004||Intel Corporation||Error metric for mesh simplification processing|
|US6825839||Feb 27, 2001||Nov 30, 2004||The National University Of Singapore||Method and apparatus for generating atomic parts of graphic representation through skeletonization for interactive visualization applications|
|US6879324 *||Jul 14, 1998||Apr 12, 2005||Microsoft Corporation||Regional progressive meshes|
|US6940505||May 20, 2002||Sep 6, 2005||Matrox Electronic Systems Ltd.||Dynamic tessellation of a base mesh|
|US6982715||Jul 26, 2002||Jan 3, 2006||Intel Corporation||Mesh compression process|
|US20020130867||Aug 1, 2001||Sep 19, 2002||Kai-Shu Yang||Method of constructing progressive mesh|
|US20040012587||Jul 19, 2002||Jan 22, 2004||Silicon Graphics, Inc.||Method and system for forming an object proxy|
|US20040249617||Jun 3, 2003||Dec 9, 2004||Pccw-Hkt Datacom Services Limited||Selective, pregressive transmission of 3D geometry models with the pre-ordered hierarchical meshes|
|EP0784295A2||Jan 7, 1997||Jul 16, 1997||Microsoft Corporation||Mesh simplification and construction of meshes|
|EP0965948A2||Jun 17, 1999||Dec 22, 1999||Sven Technologies, Inc.||Multi-resolution geometry|
|JPH1186032A||Title not available|
|JPH05290145A||Title not available|
|JPH09231401A||Title not available|
|JPH10198823A||Title not available|
|JPH11144089A||Title not available|
|JPH11209685A||Title not available|
|1||Bremer, P.-T et al., "A Multi-resolution Data Structure for Two-dimensional Morse-Smale Functions", U.S. Department of Energy, University of California, Lawrence Livermore National Laboratory, Aug. 1, 2003, 11 pages.|
|2||Erikson, Carl, "Polygonal Simplification: An Overview," Department of Computer Science, CB#3175, Sitterson Hall, UNC-Chapel Hill, Chapel Hill, NC 27599-3175, pp. 1-22, 1996.|
|3||European Search Report, dated Jan. 21, 2002, from European Patent Appln. No. 99111741.7-2218, 2 pages.|
|4||European Search Report, Jan. 21, 2002, 2 pages.|
|5||*||Funkhouser et al. Adaptive Display Algorithm for Interactive Frame Rates During Visualization of Complex Virtual Environments. Proceedings of the 20th Annual Conference on Computer Graphics and Interactive Techniques. 1993. pp. 247-254.|
|6||G. Turk, "Re-Tiling Polygonal Surfaces," Computer Graphics, Jul. 26-31, 1992, pp. 55-64.|
|7||G. Turk, "Re—Tiling Polygonal Surfaces," Computer Graphics, Jul. 26-31, 1992, pp. 55-64.|
|8||*||Garland et al. Surface Simplification Using Quadric Error Metrics. Computer Graphics Proceedings. Annual Conference Series. Aug. 1997. pp. 209-216.|
|9||H. Hoppe, "Progressive Meshes", (printed from http://www.research.microsoft.com/research/graphics/hoppe).|
|10||H. Hoppe, T. DeRose, T. Duchamp, J. McDonald, W. Stuetzle, "Mesh Optimization", Computer Graphics Proceedings, Annual Conference Series, 1993, Aug. 1-6, 1993, pp. 19-26.|
|11||*||Hoppe et al. Mesh Optimization. Proceedings of the 20th Annual Conference on Computer Graphics and Interactive Techniques. 1993. pp. 19-26.|
|12||*||Hoppe et al. Surface Reconstruction from Unorganized Points. Proceedings of the 19th Annual Conference on Computer Graphics and Interactive Techniques. 1992. pp. 71-78.|
|13||*||Hoppe. Progressive Meshes. Proceedings of the 23rd Annual Conference on Computer Graphics and Interactive Techniques. 1996. pp. 99-108.|
|14||Japanese Office Action, dated Jun. 23, 2009, from Japanese Patent Appln. No. 11-209685, 3 pages.|
|15||Kato, Saul S., U.S. Appl. No. 60/089,794, filed Jun. 18, 1998.|
|16||Klein, Reinhard, "Multiresolution representations for surfaces meshes," Wilhelm-Schickard-Institut, GRIS, Universität Tübingen, Germany, http://www.gris.uni-tuebingen.de, document generated Sep. 30, 1998, translation initiated Jul. 23, 1997, 21 pages.|
|17||Kwang Man Oh and Kyu Ho Park, "A Vertex Merging Algorithm for Extracting a Variable-Resolution Isosurface from Volume Data," 1995 IEEE International Conference on Systems, Man and Cybernetics, US, New York, Oct. 22, 1995, pp. 3543-3548.|
|18||*||Lindstrom et al. Real-Time, Continuous Level of Detail Rendering of Height Fields. Computer Graphics Proceedings. Annual Conference Series. Aug. 4, 1996. pp. 109-118.|
|19||M. Garland, P. Heckbert, "Surface Simplification Using Quadratic Error Metrics", Computer Graphics Proceedings, Annual Conference Series, 1997, Aug. 3-8, 1997, pp. 209-216.|
|20||M. Garland, P. Heckbert, "Surface Simplification Using Quadratic Error Metrics", Computer Graphics Proceedings, Annual Conference Series, 1997, Aug. 3-8, 1997, pp. 209-216.|
|21||Paulo Cignoni, Claudio Montani, Enrico Puppo, and Roberto Scopigno, "Multiresolution Representation and Visualization of Volume Data," IEEE Transactions on Visualization and Computer Graphics, vol. 3, No. 4, Oct.-Dec. 1997, pp. 352-369.|
|22||Peter Lindstrom, David Koller, William Ribarsky, Larry F. Hodges, Nick Faust, and Gregory A. Turner, "Real-Time, Continuous Level of Detail Rendering of Height Fields," Computer Graphics Proceedings, Annual Conference Series, 1996, Aug. 4, 1996, pp. 109-118.|
|23||S. Wang, R. Takamatsu, M. Sato, H. Kawarada, "Shape Simplification of Free-Form Surface Objects for Multi-Scale Representation," Oct. 14, 1996, pp. 1623-1628.|
|24||Schmalstieg, Dieter et al., "Smooth Levels of Detail," vrais, 1997 Virtual Reality Annual International Symposium (VRAIS '97), 1997. http://doi.ieeecomputersociety.org/10.1109/VRAIS.1997.583039, pp. 12-19.|
|25||*||Schroeder et al. Decimation of Triangle Meshes. Computer Graphics. 1992. pp. 65-70.|
|26||*||Turk. Re-Tiling Polygonal Surfaces. Computer Graphics. Jul. 1992. pp. 55-64.|
|27||*||Turk. Re—Tiling Polygonal Surfaces. Computer Graphics. Jul. 1992. pp. 55-64.|
|28||W. Schroeder, J. Zarge, W. Lorensen, "Decimation of To angle Meshes," Computer Graphics, Jul. 26-31, 1992, pp. 65-70.|
|29||*||Wang et al. Shape Simplification of Free-Form Surface Objects for Multi-Scale Representation. Oct. 1996. pp. 1623-1628.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US20150187135 *||Dec 31, 2013||Jul 2, 2015||Nvidia Corporation||Generating indirection maps for texture space effects|
|U.S. Classification||345/423, 345/428|
|International Classification||G06T17/20, G06T17/00|
|Cooperative Classification||G06T2210/36, G06T17/20|
|Mar 25, 2008||AS||Assignment|
Owner name: SUGARLOAF ACQUISITIONS, LLC, CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:SPATIAL CORPORATION;REEL/FRAME:020695/0390
Effective date: 20030922
Owner name: SVEN TECHNOLOGIES, INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:KATO, SAUL S.;REEL/FRAME:020695/0372
Effective date: 19990420
Owner name: SPATIAL CORPORATION, COLORADO
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:SVEN TECHNOLOGIES, INC.;REEL/FRAME:020695/0380
Effective date: 20011024
|Oct 11, 2011||CC||Certificate of correction|
|Aug 25, 2014||FPAY||Fee payment|
Year of fee payment: 12
|Dec 9, 2015||AS||Assignment|
Owner name: RATEZE REMOTE MGMT. L.L.C., DELAWARE
Free format text: MERGER;ASSIGNOR:SUGARLOAF ACQUISITIONS LLC;REEL/FRAME:037249/0122
Effective date: 20150826