|Publication number||US5542032 A|
|Application number||US 08/131,357|
|Publication date||Jul 30, 1996|
|Filing date||Oct 4, 1993|
|Priority date||Oct 4, 1993|
|Publication number||08131357, 131357, US 5542032 A, US 5542032A, US-A-5542032, US5542032 A, US5542032A|
|Inventors||Mark D. Pritt|
|Original Assignee||Loral Federal Systems Company|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (11), Non-Patent Citations (9), Referenced by (35), Classifications (5), Legal Events (7)|
|External Links: USPTO, USPTO Assignment, Espacenet|
1. Field of the Invention
The present invention relates to a system and method for the generation of images of three-dimensional surfaces on a computer graphics display. More specifically the present invention relates to generating such images without aliasing effects and without the need for special hardware.
2. Description of the Prior Art
Surface data typically consists of a two-dimensional array of values that represent surface heights. For example, this is the standard form of data in a digital terrain model. There are two main classes of techniques for generating an image of such a surface: polygon-based techniques and ray-tracing techniques. Polygon-based techniques divide the surface into shaded polygons, which are then projected to the display screen. Ray-tracing techniques trace rays from the display screen to their intersections with the surface. Ray-tracing techniques produce highly realistic images but, are very slow due to the computational burden of searching for ray-surface intersections. Polygon techniques, on the other hand, are much faster but, they are still slow due the problem of detecting and removing hidden portions of the surface.
Three techniques for hidden surface removal, which are well-known in the art, are the z-buffer (or depth buffer) method, the scan-line method and the depth-sorting method. The z-buffer method tests the visibility of surfaces one point at a time. For each pixel location on the display screen, the polygon that is closest to the screen and projects to that pixel is visible. Scan-line methods generalize this approach by testing the visibility of polygons for each horizontal or vertical scan line of the display screen. The screen is divided into horizontal or vertical lines, and as each line is processed, all polygons intersecting that line are examined to determine which are nearest to the screen. The depth sorting method, on the other hand, sons the polygons in order of nearness to the display screen. The polygons are then projected to the screen in order, beginning with the farthest polygon. The nearer polygons overwrite the farther ones, thereby obscuring them.
Although faster than ray-tracing techniques, polygon techniques are very slow when the surface has many polygons. A surface defined on a 1000×1000-element grid, for example, has one million square polygons. Fitting a fewer number of polygons to the surface speeds up the image generation process but, causes the loss of surface detail such as roughness and texture. To speed up the image generation process, many polygon techniques require specialized three-dimensional graphics hardware. Many workstations, personal computers, notebook computers, and personal digital assistants (PDA) however, do not have this specialized hardware. Furthermore, these algorithms generally suffer from aliasing effects due to pixel discretization, which results in jagged lines and edges.
To generate images of surfaces more quickly, a prior art technique has been developed that exploits the gridded structure of a surface to remove hidden surfaces more quickly. This technique is described in "Fast Perspective Views of Images Using One-Dimensional Operations" by P. K. Robertson in the February 1987 issue of IEEE Computer Graphics and Applications. This technique first resamples the surface so that the columns of the grid on which it is defined project to the vertical columns of pixels on the display screen. As a result, any surface point can be occluded only by other points in front of it in the same column. The image is then generated by projecting the surface points to the display screen from back to front, so that the nearer points overwrite the farther ones. Although this method is much faster than previous methods, it suffers from aliasing effects that are caused by pixels overwriting other pixels. For example, the boundary of a portion of the surface that occludes another portion of the surface will appear jagged. A tall, narrow peak will also appear jagged. In addition, if detailed image or texture data is overlaid on the surface, the overlaid image or texture will be severely degraded by the pixel overwriting.
There is a long-felt need in the art for a graphics display technique that can create images of three-dimensional surfaces in real time without aliasing effects. There is also a long-felt need to produce images on a workstation, PC, notebook computer, PDA or other computer system without the need for specialized three-dimensional graphics hardware.
The above-mentioned long-felt need has been met in accordance with the present invention by providing means for the quick generation of images of three-dimensional surfaces without aliasing effects. The invention is designed for use by a workstation, PC, notebook computer, PDA or other computer system without special three-dimensional graphics hardware.
It is an object of the invention to generate images in which an arbitrary grey-scale or color image has been overlaid on the surface without degrading the overlaid image due to aliasing effects.
It is a further object to allow a human user to view a digital terrain model with mathematical or textural data overlaid upon it.
It is another object of the invention to require no temporary work arrays other than a one-dimensional array of floating-point variables, the length of which is equal to the height in pixels of the display screen.
It is yet another object of the invention to create images in real time and without preprocessing steps or preliminary passes through the surface data, thus allowing a human user to observe the image as it is created.
In accordance with a preferred embodiment of the present invention, a system for displaying images of three-dimensional surfaces comprises a means for storing surface data in a two-dimensional array. The system also includes a means for retrieving elements of this surface data by specifying grid locations (i, j) and a means for performing floating-point arithmetic and comparison operations on this data. The system also includes means for inputting parameters from the user that define the viewer orientation with respect to the surface. The system also includes a one-dimensional floating-point array and various floating-point variables for storing results of intermediate calculations. Lastly, the system includes means for displaying pixels of specified grey-levels or colors on a rectangular display screen by specifying the grid location (i, j) of a pixel and its grey-level or color. An example of such a preferred embodiment is a graphics workstation such as the IBM RISC System/6000® or a PC, PDA or other computer system with graphics capability.
According to the invention, the foregoing objects are achieved as follows. The point of view of the display screen is specified by an azimuth angle and an elevation angle. The surface is defined as a two-dimensional array of height values, and the grey-level shades (or colors) are either defined in another two-dimensional array or computed as needed. The shade of the surface at an arbitrary point can be computed using a well-known technique in the an called Lambertian shading, which computes the shade as the dot product of the surface normal vector and a fixed vector that points toward the light source. The projection of a point of the surface to the display screen is performed by applying a rotation based on the azimuth and elevation angles, followed by a parallel projection to the display plane. Through resampling of the surface by the azimuth angle, it may be assumed that the azimuth angle is zero. In this case, the columns of the surface project to the columns of the display screen. This projection is monotonic in the sense that as one proceeds along a visible portion of the surface away from the display screen, the projected points proceed in an upward direction on the display screen. Depending on the steepness of the surface relative to the viewing angle, neighboring points of the surface may project to the same pixel, neighboring pixels or widely-separated pixels. The surface points are projected beginning with the nearest points and proceeding to the farthest points. The points are projected in pairs, and the grey-level shading (or color) values are accumulated in a one-dimensional array of floating-point variables that store the intensities of the pixels of a column of the display screen. The intensities are accumulated by weighting the grey-level shades (or colors) by the distance between the projected pair of points and by the fractional offsets from the integer-valued pixel locations. Because the grey-level shade of every grid point of the surface contributes to the pixel intensities, aliasing effects within columns of pixels are avoided. Aliasing effects across columns are avoided by the use of intermediate scan lines between the columns of pixels.
Hidden portions of the surface are detected by keeping track of the current maximum value of the projected points in each column. Hidden surface removal is thus reduced to a simple comparison: if a newly projected point is less than the current maximum value, it is not visible. To avoid aliasing effects at the boundaries of occluding surfaces, the following procedure is performed for each pair of projected points: if one projected point is less than the current maximum while the other is greater, then the former point's projected value is changed to the current maximum value.
The grey-level or color shading of the surface can be computed as needed or pre-computed and stored in a two-dimensional array. Any grey-level or color image can be stored in this array, thereby resulting in the generation of an image of the three-dimensional surface with the given image overlaid upon it. Because of the lack of aliasing effects, the overlaid image will not be degraded.
Because the image of the three-dimensional surface is generated in one-pass without the need for preprocessing steps, and because it is generated by scanlines (vertical columns) which are independent of one another, the image can be displayed line by line as each scanline is completed. This produces a scanning effect during the generation of the image that can be observed by a human user, making this system suitable for interactive use.
The foregoing and other objects, aspects and advantages of the invention will be better understood from the following detailed description with reference to the drawings, in which:
FIG. 1 is an illustration of the azimuth and elevation angles which define the point of view of the display screen or the orientation of the display plane.
FIG. 2 is a graphical representation of the projection of columns of the gridded surface to columns of the display screen.
FIG. 3 is a graphical illustration of the monotonic projection of points from the surface to the display screen.
FIG. 4 is a graphical illustration of neighboring points on the surface which project to the same pixel of the display screen.
FIG. 5 is a graphical illustration of neighboring points in the surface which project to widely-separated pixels on the display screen.
FIGS. 6A to 6C are graphical illustrations of the accumulation of weighted grey-scale values.
FIG. 7 is a graphical illustration of the projection of hidden points of the surface to points on the display screen that are less than the current maximum value of projected points.
FIG. 8 is a graphical illustration of the accumulation of grey-scale shades at occluding boundaries of the surface to avoid aliasing errors.
FIG. 9 is a flow diagram showing one embodiment of the present invention.
FIG. 10 is a block diagram of the preferred embodiment for a system for displaying images of three-dimensional surfaces.
The preferred embodiment of this invention comprises a set of computer programs for the generation of images of three-dimensional surfaces as shown in the architectural block diagram of FIG 10. FIG. 10 includes a processor 20 connected by means of a system bus 22 to a read only memory (ROM) 24 and memory 38. Also included in the computer system in FIG. 10 are a display 28 by which the computer presents information to the user, and a plurality of input devices including a keyboard 26, mouse 34 and other devices that may be attached via input/output port 30. Other input devices such as other pointing devices or a voice sensors or image sensors may also be attached. Other pointing devices include tablets, numeric keypads, touch screen, touch screen overlays, track balls, joy sticks, light pens, thumb wheels etc. The I/O 30 can be connected to communications lines, disk storage, input devices, output devices or other I/O equipment. The memory 38 includes a display buffer 72 that contains pixel intensity values for a display screen. The display 28 periodically reads the pixel values from the display buffer 72 displaying these values onto a display screen. The pixel intensity values may represent grey-levels or colors.
The memory 38 includes a two-dimensional array 80, a one-dimensional floating point array 81, and an image generator (IG) 83. The two-dimensional array 80 contains values that may have been sampled from a two-dimensional function that has been projected onto the two dimensional array. The values in the two-dimensional array may represent surface data, terrain data, heights, meteorological data, data generated from a scanning tunnel microscopy, medical imaging data or other information. The one-dimensional floating point array 81 is an array having an index that represents pixel locations for a column or a portion of a column of the display buffer 72. Thus, the one-dimensional array has integer-valued pixel locations for storing pixel intensity values. The array contains floating point numbers that represent pixel intensity values for the pixel location at which the intensity values is stored. The pixel intensity values can represent grey level shades or colors. Typically the display buffer 72 contains integer-only pixel intensity values so that before writing pixel intensity values from the one-dimensional floating point array 81 to the display buffer 72 a rounding or truncating operation may need to be performed. A mapping or normalization operation may also be performed when the pixel intensity values are written from the one-dimensional floating point array 81 to the display buffer.
The IG 83 application causes an image to be written to the display buffer 72 or a portion of the display buffer 72 (e.g., a window or a viewport). Given an orientation of a display plane with respect to a three-dimensional surface the IG 83 writes an anti-aliased image to the display buffer 72. The IG 83 can write directly to the display buffer 72 or via the operating system 74 or via window management system 58. Examples of operating systems include AIX®, OS/2®, and DOS. Examples of window management systems are the X Window System® for AIX®, Presentation Manager™ for OS/2® and WINDOWS™ for DOS. The IG 83 is a collection of functions. These functions are explained in detail below.
Other elements shown in memory 38 include drivers 76 which interpret the electrical signals generated by devices such as the keyboard and mouse. A working memory area 78 is also shown in memory 38. The working memory area 78 can be utilized by any of the elements shown in memory 38. The working memory area can be utilized by the IG 83, window management system 58, the operating system 74 and other functions. The working memory area 78 may be partitioned amongst the elements and within an element. The working memory area 78 may be utilized for communication, buffering, temporary storage, or storage of data while a program is running.
As stated previously the IG 83 functions to create that creates an anti-aliased image of a three-dimensional surface. The functions of the IG 83 will now be described in detail. The IG 83 creates an image by projecting surface points to the display buffer for display on the display screen. This projection technique will be described with reference to FIGS. 1 to 5. The projection technique used to display a three-dimensional surface is referred to as the parallel (or orthographic) projection. The parallel projection projects points from the surface to the display screen (represented by the display plane) along lines which are parallel to one another and perpendicular to the display plane. This projection can be performed by rotating the surface points according to a specified point of view and projecting to the x-y plane (which represents the display plane) according to the natural projection function p(x, y, z)=(x, y). FIG. 1 illustrates how the point of view 91 is specified by an azimuth angle 92, which is a rotation of the surface about a vertical axis 93 that passes through the center of the surface, and an elevation angle 94, which is a rotation of the surface about a horizontal axis 95 that passes through the surface and is parallel to the display plane. If the azimuth angle is zero then points of the surface which lie on a column of the array onto which the surface is defined, are projected to a single column of pixels on the display plane and thus the display screen. This is illustrated in FIG. 2, which shows the surface 201, the display plane 202 and the columns of the surface aligned with the columns 203 of the display plane 202. A prior art technique, which is described in the paper by P. K. Robertson mentioned above, performs a preprocessing step that resamples the surface into a second two-dimensional array according to a planar rotation defined by the azimuth angle. This prior technique effectively rotates the surface array so that the azimuth angle may be regarded as zero, and therefore the columns of the surface grid are aligned with the columns of the display plane. The present invention avoids this preprocessing step by resampling the surface on a point-by-point basis as the surface points are needed. The present invention only resamples points of the surface array that fall within the view of the display plane. Thus the present invention removes the need for a second array in which to store the resampled surface. The point-by-point resampling also reduces the number of surface points that need to be resampled which results in a computational savings especially where large surface arrays are used.
FIG. 3 shows that the parallel projection of the points of the surface 301 to the display plane 302 (i.e., representing the display screen) is monotonic. This signifies that as one proceeds along a column of visible surface points in a direction away from the display plane, the projected points proceed along the display plane in an upward direction. In mathematical terms, let Py denote the y (or vertical) component of the projection function. If (x1, y1, z1) and (x2, y2, z2) are two surface points such that x1 =x2 (i.e., the points lie in the same column) and y1 ≦y2, then the projected points satisfy the relation Py (x1, y1, z1)≦Py (x2, y2, z2).
FIG. 4 shows that neighboring points of the surface may project to the same pixel 401 of the display plane. Since the pixels are spaced one unit apart, this signifies that when the fractional portions of the projected points Py (x1, y1, z1) and Py (x2, y2, z2) are truncated, they result in the same integer (i.e., the same pixel). Neighboring points may also project to distinct pixels, and FIG. 5 illustrates that they may even project to widely separated pixels 501.
The prior art technique mentioned above (and described in the aforementioned paper by P. K. Robertson) projects surface points to the display screen starting with the farthest point and proceeding to the nearest point. If two points project to the same pixel, the nearer one will overwrite the farther one. Interpolation is used only if the points project to widely separated pixels, in which case the grey-level (or color) values of the pixels in between are interpolated. However, this prior art technique leads to aliasing errors due to the overwriting of pixels, especially at occluding boundaries where they are very noticeable to a human observer. The present invention takes advantage of the monotonicity of the projection to avoid these aliasing effects.
The present invention avoids aliasing effects by the use of the following technique. Rather than proceeding along the surface from the farthest points to the nearest points as in the prior art, the present invention begins with the nearest point and proceeds to the farthest point. Each point (x, y, z1), where (x, y) is an integer grid location and z1 is the height of the surface at that location, is projected along with the preceding point (x, y-1, z2). A one-dimensional array of floating-point variables is used to accumulate weighted grey-level shades (or colors) from the points. The weights are calculated by use of the distance between the projected pair of points and by use of the fractional offsets from the integer-valued pixel locations. Let p1 and p2 be the y-components of the projections of the points, and let square brackets denote the operation of truncation to the largest integer that does not exceed the given number. (For example, [3.2]=[3.9]=3).
There are three possible cases:
Case 1: p1 ≦p2
Case 2: p1 >p2 and [p1 ]=[p2 ]
Case 3: p1 >p2 and [p1 ]>[p2 ]
In case 1, which is illustrated in FIG. 6A, both points lie on a portion of the surface that is facing away from the display plane and is therefore not visible. In case 2, the points project to the same pixel as shown in FIG. 6B, and therefore the value (p1 -p2)S is added to element [p1 ] of the one-dimensional array. S denotes the grey-level shade (or color) of the surface at the grid point (x, y). In case 3, which is illustrated in FIG. 6C, the points project to distinct pixels. In this case, the value (1-(p2 -[p2 ]))S is added to element [p2 ] of the one-dimensional array, and (p1 -[p1 ])S is added to element [p1 ]. In addition, the value S is added to elements [p2 ]+1 through [p1 ]-1 (i.e., the pixels in between [p2 ] and [p1 ]). Alternatively, the shading value to be added to elements [p2 ]+1 through [p1 ]-1 may be calculated by linear interpolation of the shades of the surface at the two grid points (x,y) and (x,y-1).
After all the points in a column have been projected, the values of the one-dimensional array are rounded to pixel intensities and written to the display buffer and displayed on the graphics screen. The pixel intensities can also be stored in a separate two-dimensional array until all the columns have been processed. Although storing the pixel values in a separate array until all columns have been processed requires an additional array it allows the screen to be updated with the entire image at one time. The present invention can be utilized with this double buffering technique. Because every grid point of the surface contributes to the pixel intensities, aliasing effects within columns are avoided.
It should be noted that the grey-level or color shading of the surface can be computed as needed or pre-computed and stored in another two-dimensional array. Any grey-level or color image can be stored in this array. This capability enables the generation of an image of the three-dimensional surface with the given image overlaid upon it. Because of the lack of aliasing effects, the overlaid image will not be degraded. The technique works with almost any shading technique including Lambert cosine shading and Phong specular reflection, shadowing, coloring and refracted light effects. These and other techniques suitable for use with the present invention are described in Computer Graphics Principles and Practice, Second Edition, 1990, by Foley el. al. which is hereby incorporated by reference.
The IG can reduce aliasing effects across the columns by the use of intermediate scanlines. Given a number n of intermediate scanlines, for each scanline k, where 0≦k<n, the surface points of the form (x+k/n, y, z) are projected. The grid column is specified by the integer x, and the grid point within the column is specified by the integer y. The height z of the surface at the point (x+k/n, y) is determined by interpolation. The weighted grey-level shades are multiplied by 1/n before being added to the one-dimensional array, and the array is converted to pixel values only after the last intermediate scanline (i.e., k=n-1) has been processed. Typically, two or three intermediate scan lines are sufficient to remove aliasing effects.
Hidden surface removal is accomplished as follows. A floating-point variable denoted HMAX, which must be initialized to zero before processing each column, maintains the current maximum value of the projected points. Any point that projects to a value greater than HMAX is visible, while a point that projects to a lesser value is hidden as illustrated in FIG. 7. If the projected point p2 is less than HMAX, it is set equal to HMAX as shown in FIG. 8 before the processing of one of the three possible cases described above is performed. After the processing is completed, HMAX is updated to the value of the point p1 if it was visible. In this way, hidden portions of the surface are not permitted to contribute grey-level shading to the one-dimensional array. The visible portions of the surface between pairs of projected points do contribute to the grey-level shading, however, and this prevents aliasing effects at the boundaries of occluding surfaces.
An embodiment of the present invention is given as a flow diagram in FIG. 9. A pseudocode listing is given in Table I along with line numbers that are keyed to the blocks of the flow diagram of FIG. 9. A description is provided below with reference to the pseudocode of Table I. The display plane (i.e., screen) is assumed to be RD×CD pixels in size, where RD is the number of rows and CD is the number of columns. The surface is defined in an array of size RS×CS. The floating-point array ACC is of length RD and accumulates the grey-level values for each column of pixels. The floating-point variable HMAX, which is needed for the hidden surface removal, stores the current maximum of the points projected to the display plane. The variable SHADE stores the grey-level shade of the current point on the surface.
The embodiment shown in Table I loops through the columns of the display screen from left to right (see line 101) as a user would view the screen. The psuedocode can easily be modified to provide looping from right to left or from the center out to the edges or interlacing. Thus, the columns may be processed in any order.
The projection of points from the surface to the display plane is performed in lines 105-108. Line 105 performs the point-by-point resampling of the surface by the azimuth angle. This resampling is defined by the plane rotation
where az is the azimuth angle.
Line 106 calculates the height of the surface at the new point by bilinear interpolation. Line 107 determines the shade of the surface at the new point. Line 108 performs the rotation by the elevation angle. Since the surface columns are conceptually aligned with the display columns, this is a plane rotation. The height of the projected point on the display plane is thus defined by
where el is the elevation angle.
Note that the value q defined by the rotation is not needed. Similarly, the value p2 defined in line 123 is the height of the projection of the preceding point. Although the above described resampling utilized a bilinear interpolation, other interpolation techniques (i.e., nearest neighbor or bicubic or others) can be used by the present invention. Persons of ordinary skill in the art can modify the above described embodiment to use these other interpolation techniques.
The hidden surface removal is accomplished in lines 110 and 122. The weighted accumulation of grey-level values is performed in lines 113-121. The grey-level pixel values for a column are written to the display buffer by lines 125-127.
For simplicity, the processing of intermediate scan lines has been omitted from the embodiment given in Table I and FIG. 9. However, those of ordinary skill in the art will have no difficulty incorporating it. For example, a third loop can be inserted between lines 102 and 103 to loop over the intermediate scan lines. In line 105 the variable i must be replaced with i+k/s, where k is the current intermediate scan line number and s is the number of intermediate scan lines. In addition, the value of SHADE computed in line 107 must be multiplied by 1/s.
The orientation of the display plane with respect to the surface may also be controlled interactively by a user via the input devices. The IG 83 or another application can translate the user's action(s) into a new display plane orientation. This input could simply consist of using the keyboard to input an elevation and azimuth angle. Many other techniques are available such as using slider bars to define the angles or a graphical compass or by positioning a rectangle representing the display plane over a wire frame model of the surface. These as well as many other techniques can utilized to allow the user to interactively select the desired view. A preferred technique is to display a wire frame model of the surface which allows the user to view the wire frame from the currently selected orientation. The user then adjusts the orientation to the desired orientation using the wire frame as shown on the display. When the user has the desired orientation a selection is made to start the anti-aliasing operation so that the wire frame model is shaded accordingly. This provides an effective interactive technique for obtaining the desired image.
Those skilled in the art will also have no difficulty adding other enhancements. For example, a zoom function can be easily incorporated that allows the generation of images of enlarged portions of the surface. If (c,d) is the grid point specifying the center of the surface portion to enlarge, and if r is the magnifying factor (where r=-1 denotes no enlargement and r=-2 denotes doubling the size, for example) then (a,b) must be replaced with (1/r) [(a,b)-(c,d)]+(c,d) immediately after line 105 of the pseudocode of Table I.
Those skilled in the art will also have little difficulty incorporating other methods for performing the weighted accumulation of grey-level values. The following method is a more precise method but requires more computations. Let S1 be the shade of the surface at the grid point (x, y), and let S2 be the shade at (x, y-1). Let p1 and p2 be the y-components of the projections of the points. In case 2 of the three possible cases described above, the value (Px -p2)S should be added to element [p1 ] of the one-dimensional array, where S=(S1 +S2)/2 is the average shade. In case 3, define
w=(S1 -S2)/(p1 -p2),
q1 =p1 -[p1 ] and
q2 =1-(p2 -[p2 ]).
Then the value
q1 (S2 +w(1/2(p1 +[p1 ])-p2))
should be added to element [p1 ] of the array, and the value
q2 (S2 +w(1/2(p2 +[p2 ]+1)-p2))
should be added to element [p2 ]. In addition, for each integer k from [p2 ]+1 to [p2 ]-1, the value S2 +w(k-p2) should be added to element k of the array.
TABLE I______________________________________101 LOOP for i = 1 to CD (* Loop over the columns of thedisplay screen *)102 Let ACCj = 0 for j=1 to RD.103 Let HMAX = 0.104 LOOP for j=1 to RS (* Loop over the surface points within the column *)105 Let (a,b) be the image of the point (i,j) after a plane rotation by the azimuth angle.106 Let z be the height of the surface at the point (a,b).107 Let SHADE be the grey-level shading of the surface at the point (a,b).108 Let (q,p1) be the image of the point (j,z) after a plane rotation by the elevation angel.109 IF j=1 THEN GOTO 122 (* Skip to the next iteration *)110 Let p2 = MAX(p2, HMAX).111 Let m be the largest integer not exceeding p1.112 Let n be the largest integer not exceeding pp2.113 IF p1 > p2 THEN114 IF m = n THEN115 Let ACCm = ACCm + (p1 - p2)*SHADE.116 ELSE117 Let ACCm = ACCm + (p1 - m)*SHADE.118 Let ACCn = ACCn + (1 - (p2 - n))*SHADE.119 Let ACCk = ACCk + SHADE for k = n+1 to m-1.120 END IF121 END IF122 Let HMAX = MAX(p1, HMAX).123 Let p2 = p1124 END LOOP125 LOOP for j = 1 to RD126 Display the grey-level pixel value ACCj at pixel location (i,j) on the display screen.127 END LOOP128 END LOOP______________________________________
While the invention has been described in detail herein in accord with certain preferred embodiments thereof, modifications and changes therein may be effected by those skilled in the art. Accordingly, it is intended by the appended claims to cover all such modifications and changes as fall within the true spirit and scope of the invention.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4821210 *||Apr 2, 1987||Apr 11, 1989||General Electric Co.||Fast display of three-dimensional images|
|US4821212 *||Aug 8, 1984||Apr 11, 1989||General Electric Company||Three dimensional texture generator for computed terrain images|
|US4847789 *||Jul 7, 1986||Jul 11, 1989||International Business Machines Corporation||Method for hidden line removal|
|US5101475 *||Apr 17, 1989||Mar 31, 1992||The Research Foundation Of State University Of New York||Method and apparatus for generating arbitrary projections of three-dimensional voxel-based data|
|US5175806 *||Mar 28, 1989||Dec 29, 1992||Computer Design, Inc.||Method and apparatus for fast surface detail application to an image|
|US5179638 *||Apr 26, 1990||Jan 12, 1993||Honeywell Inc.||Method and apparatus for generating a texture mapped perspective view|
|US5201030 *||Jul 31, 1992||Apr 6, 1993||Sun Microsystems, Inc.||Method and apparatus for dithering graphic images|
|US5222204 *||Mar 14, 1990||Jun 22, 1993||Hewlett-Packard Company||Pixel interpolation in perspective space|
|US5282262 *||Apr 9, 1992||Jan 25, 1994||Sony Corporation||Method and apparatus for transforming a two-dimensional video signal onto a three-dimensional surface|
|US5313568 *||Jul 6, 1993||May 17, 1994||Hewlett-Packard Company||Three dimensional computer graphics employing ray tracing to compute form factors in radiosity|
|JPH0254A *||Title not available|
|1||*||Fast Perspective Views of Images Using One Dimensional Operations, P. K. Robertson, Feb. 1937, IEEE Computer Graphics and Applications.|
|2||*||Foley, et al. Fundamentals of Computer Graphics , 2nd Addison Wesley Pub Co (1990).|
|3||Foley, et al. Fundamentals of Computer Graphics, 2nd Addison-Wesley Pub Co (1990).|
|4||*||Frieder, O. et al, Dynamic Hidden Surfaces Using a MIMD Multiprocessor, Computer Based Medical Systems, pp. 44 51, (1990).|
|5||Frieder, O. et al, Dynamic Hidden Surfaces Using a MIMD Multiprocessor, Computer-Based Medical Systems, pp. 44-51, (1990).|
|6||*||Shepard, Terry et al, Real time Hidden Surface Removal in a Flight Simulator, Communications, Computers and Signal Processing, pp. 607 610, (1991).|
|7||Shepard, Terry et al, Real-time Hidden Surface Removal in a Flight Simulator, Communications, Computers and Signal Processing, pp. 607-610, (1991).|
|8||*||Wang, Sue Ling Chen et al, Visibility Determination on Projected Grid Surfaces, IEEE Graphics and Applications Magazine, pp. 36 43, (1990).|
|9||Wang, Sue-Ling Chen et al, Visibility Determination on Projected Grid Surfaces, IEEE Graphics and Applications Magazine, pp. 36-43, (1990).|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US5619627 *||May 3, 1994||Apr 8, 1997||Loral Aerospace Corp.||Multiple-level occulting using a mask buffer|
|US5680138 *||Dec 15, 1995||Oct 21, 1997||Lockheed Martin Corporation||Synthetic aperture radar simulation|
|US5751290 *||Sep 20, 1996||May 12, 1998||Industrial Technology Research Institute||Three dimensional graphics system and method with correction to z buffer value errors|
|US6253164 *||Dec 24, 1997||Jun 26, 2001||Silicon Graphics, Inc.||Curves and surfaces modeling based on a cloud of points|
|US6285779 *||Aug 2, 1999||Sep 4, 2001||Trident Microsystems||Floating-point complementary depth buffer|
|US6453065 *||Feb 6, 2001||Sep 17, 2002||Trident Microsystems, Inc.||Floating-point complementary depth buffer|
|US6523079||Feb 15, 2001||Feb 18, 2003||Elonex Ip Holdings Ltd||Micropersonal digital assistant|
|US6636633||May 3, 1999||Oct 21, 2003||Intel Corporation||Rendering of photorealistic computer graphics images|
|US6757445||Oct 4, 2000||Jun 29, 2004||Pixxures, Inc.||Method and apparatus for producing digital orthophotos using sparse stereo configurations and external models|
|US6782130||Apr 10, 2003||Aug 24, 2004||Intel Corporation||Rendering of photorealistic computer graphics images|
|US7034820 *||Nov 26, 2002||Apr 25, 2006||Canon Kabushiki Kaisha||Method, apparatus and program for processing a three-dimensional image|
|US7239312||Oct 28, 2005||Jul 3, 2007||Canon Kabushiki Kaisha||Method, apparatus and program for processing a three-dimensional image|
|US7518615||Jul 12, 2000||Apr 14, 2009||Silicon Graphics, Inc.||Display system having floating point rasterization and floating point framebuffering|
|US7619749 *||Aug 29, 2006||Nov 17, 2009||The Hong Kong Polytechnic University||Methods and apparatus of aligning surfaces|
|US8013856 *||Sep 27, 2007||Sep 6, 2011||Ziosoft, Inc.||Image processing method|
|US8553946 *||Jan 9, 2008||Oct 8, 2013||Tomtom International B.V.||Displaying elevation information from a digital map|
|US9177414 *||Jul 25, 2012||Nov 3, 2015||Electronics And Telecommunications Research Institute||Apparatus and method for rendering point cloud using voxel grid|
|US20030088511 *||Jun 20, 2002||May 8, 2003||Karboulonis Peter Panagiotis||Method and system for access and usage management of a server/client application by a wireless communications appliance|
|US20030107568 *||Nov 26, 2002||Jun 12, 2003||Shinya Urisaka||Method, apparatus and program for processing a three-dimensional image|
|US20030178320 *||Feb 26, 2003||Sep 25, 2003||Applied Materials, Inc.||Method and composition for polishing a substrate|
|US20040082288 *||Mar 5, 2003||Apr 29, 2004||Applied Materials, Inc.||Fixed abrasive articles|
|US20050041385 *||Sep 29, 2004||Feb 24, 2005||Dan Kikinis||Micro personal digital assistant with a compressed BIOS system|
|US20070195084 *||Aug 29, 2006||Aug 23, 2007||Chi-Fai Cheung||Methods and apparatus of aligning surfaces|
|US20080075346 *||Sep 27, 2007||Mar 27, 2008||Ziosoft, Inc.||Image processing method|
|US20080212893 *||Jan 9, 2008||Sep 4, 2008||Alexandru Serbanescu||Displaying elevation information from a digital map|
|US20120139931 *||Feb 16, 2012||Jun 7, 2012||Graphics Properties Holdings, Inc.||Display system having floating point rasterization and floating point framebuffering|
|US20120249548 *||Oct 4, 2012||Graphics Properties Holdings, Inc.||Floating point computer system with per-fragment operations|
|US20120249561 *||Oct 4, 2012||Graphics Properties Holdings, Inc.||Floating point computer system with s_e_m formatting|
|US20120249566 *||Jun 12, 2012||Oct 4, 2012||Graphics Properties Holdings, Inc.||Floating point computer system with frame buffer for storing color values during or after rasterization|
|US20120256932 *||Jun 12, 2012||Oct 11, 2012||Graphics Properties Holdings, Inc.||Floating point computer system on a single chip|
|US20120256933 *||Oct 11, 2012||Graphics Properties Holdings, Inc.||Floating point computer system with floating point memory|
|US20120262470 *||Jun 12, 2012||Oct 18, 2012||Graphics Properties Holdings, Inc.||Floating point computer system and texturing|
|US20130057653 *||Mar 7, 2013||Electronics And Telecommunications Research Institute||Apparatus and method for rendering point cloud using voxel grid|
|WO2001009761A1 *||Aug 2, 2000||Feb 8, 2001||Trident Microsystems Inc||Floating-point complementary depth buffer|
|WO2005086078A1 *||Mar 2, 2005||Sep 15, 2005||Theodore Armand Camus||Method and apparatus for classifying an object|
|U.S. Classification||345/421, 345/419|
|Oct 4, 1993||AS||Assignment|
Owner name: IBM CORPORATION, NEW YORK
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:PRITT, MARK D.;REEL/FRAME:006739/0595
Effective date: 19930927
|Dec 23, 1996||AS||Assignment|
Owner name: LOCKHEED MARTIN CORPORATION, MARYLAND
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INTERNATIONAL BUSINESS MACHINES, CORPORATION;REEL/FRAME:008430/0312
Effective date: 19960829
|Aug 25, 1997||AS||Assignment|
Owner name: LOCKHEED MARTIN CORPORATION, MARYLAND
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:LOCKHEED MARTIN FEDERAL SYSTEMS, INC.;REEL/FRAME:008677/0842
Effective date: 19970620
|Jan 28, 2000||FPAY||Fee payment|
Year of fee payment: 4
|Jan 30, 2004||FPAY||Fee payment|
Year of fee payment: 8
|Jan 30, 2008||FPAY||Fee payment|
Year of fee payment: 12
|Feb 4, 2008||REMI||Maintenance fee reminder mailed|