Hidden-surface Problem Research Articles

Visible Surface Detection Algorithms: A Review

In computer graphics, there are many surface detection algorithms. When we view a picture containing non-transparent objects and surfaces, then we cannot see those objects from view which is behind from objects closer to eye. We must remove these hidden surfaces to get a realistic screen image. The identification and removal of these surfaces is called Hidden-surface problem. In this paper I review some visible surface detection algorithms like Z buffer method, Area subdivision method, Scan line method etc.

Hidden Surface Problems: On the Digital Image as Material Object

This article offers a materialist critique of the digital image through a history of early computer graphics. Critiquing existing genealogies that understand computer generated images as the outgrowth of prior visual media forms, the author suggests that graphics offer us a uniquely computational image form, one concerned less with realism and mimesis than with delimiting the world through the black boxing of vision. Focusing on one of the most significant challenges to the field of computer graphics research from 1963–1979 – what is known as the ‘hidden-line’ or ‘hidden-surface’ problem – the article argues that the material logic of the digital image is not one of inscription but restriction, a making absent.

Hardware Implementation of 3D-Bresenham’s Algorithm Using FPGA

Traditional 3D-Bresenham’s algorithm is efficient in generating lines on raster systems using only integer calculations. This algorithm is needed as a solution of hidden surface problem using depth-buffer method to calculate z value for each pixel, while calculated values of x and y are used to address frame buffer memory, z value is used to test hidden surface by saving the closest depth in depth buffer. In this paper Bresenham’s algorithm for plotting 3D-lines is examined then modified to simplify hardware requirements during implementation phase. Basing on efficiency of the algorithm on the space symmetry an enhanced version of this algorithm is implemented using OpenGL. Experimental results confirm results calculated theoretically for both traditional and modified algorithms. The hardware implementation is accomplished for real time applications, and a graphic sub-system is designed using FPGA. Finally, a comparison is accomplished for Spartan3E utilization which is used to implement the hardware unit.

Fast algorithm for generating CPK images on graphics workstations

An algorithm for generating CPK images of molecules is presented that uses bitmap operations to solve the hidden-surface problem. The algorithm makes certain assumptions: that the size and shading of each atom are determined only by its type and are unaffected by the atom's position, and that an intersection table comprised of entries for all pairs of atoms whose radii intersect is available. For speed, bit-maps of shaded and colored atom disks are predrawn. The atoms are projected from back to front. Atom intersections are explicitly calculated and used to generate mask bitmaps that are then used to truncate the predrawn disks, leaving the visible portions of the atom disks.

Visibility determination on projected grid surfaces

An algorithm is presented for solving the hidden-line and hidden-surface problems on grid surfaces, such as graphs of bivariate functions specified by their values on a set of grid points. The algorithm is implemented in image space, taking advantage of the raster display resolution. The procedure examines the edges of a projected grid surface in a systematic order to find all points visible to the observer from which a visible periphery for the surface is established. As the algorithm proceeds, this changing periphery floats toward the edges of the visible parts of the solid surface and determines the visibility of every point of the edges being processed. The procedure is therefore termed the floating perimeter algorithm. (FPA).< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Towards image realism with interactive update rates in complex virtual building environments

Two strategies, pre-computation before display and adaptive refinement during display, are used to combine interactivity with high image quality in a virtual building simulation. Pre-computation is used in two ways. The hidden-surface problem is partially solved by automatically pre-computing potentially visible sets of the model for sets of related viewpoints. Rendering only the potentially visible subset associated with the current viewpoint, rather than the entire model, produces significant speedups on real building models. Solutions for the radiosity lighting model are pre-computed for up to twenty different sets of lights. Linear combinations of these solutions can be manipulated in real time. We use adaptive refinement to trade image realism for interactivity as the situation requires. When the user is stationary we replace a coarse model using few polygons with a more detailed model. Image-level linear interpolation smooths the transition between differing levels of image realism.

Hidden-surface removal in polyhedral cross-sections

Many of the fundamental problems in computer graphics involve the notion of visibility. In one approach to the hiddensurface problem, priorities are assigned to the faces of a scene. A realistic image is then rendered by displaying the faces with the resulting priority ordering. We introduce a tree-based formalism for describing priority orderings that simplifies an existing algorithm. As well, a decompositionbased algorithm is presented for classes of scenes that do not in general admit priority orderings. The algorithm requiresO(n logn) time ift=1 andO(tn logn+n logn logm) time ift>1, wheren andm are respectively the number of faces and polyhedra in the scene, andt is a minimum decomposition factor of the scene. Finally, the tree-based formalism is used in the development ofO(n) time insertion and deletion algorithms that solve the problem of dynamically maintaining a priority ordering.

Special problems in applying the physical optics method for backscatter computations of complicated objects

The backscatter computation of complicated objects is carried by the physical optics (PO) method, known as the vector Kirchoff approximation. The object is described by a geometrical model using flat plates (panels). These panels can be nonperfectly conducting and multilayered. The PO solution for the scattering matrix of a single multilayered panel is evaluated in detail using the Fresnel reflection coefficients. An example of the computed reflection coefficient of a two-layered medium is presented. The phase integral of the PO method is solved analytically. The hidden-surface problem is discussed, and the procedure for the treatment of doubly reflecting panels is described. For an ideal conducting cube with additional surfaces that generate shadow and double-reflection effects, the computed radar cross section (RCS) is compared with measurements. Computational results of the RCS for nonperfectly conducting panels are given. >

Worst-case optimal hidden-surface removal

An O( n 2 ) hidden-surface removal algorithm is shown. This is an improvement over the previous best worst-case performance of O( n 2 log n ). It has been established that the hidden-line and hidden-surface problems have an Ω( n 2 ) worst-case lower bound, so the algorithm is optimal. However, the algorithm is not output-size sensitive. Two corollaries to the result are (1) hidden-lines can be removed in optimal O( n 2 ) time, and (2) the portion of a 3-D polyhedron visible from a given interior point is constructible in optimal O( n 2 ) time.

A linear algorithm for eliminating hidden-lines from a polygonal cylinder

A variety of applications have motivated interest in the hidden-line and hidden-surface problem. This has resulted in a number of fundamentally different solutions. However no algorithm has been shown to be optimal. A common trait among algorithms for hidden-line elimination is a worst case complexity ofO(n2). It is the interent here to introduce an algorithm that exhibits a linear worst case complexity. The use of a restricted class of input, has been employed to achieve asymptotic improvement in complexity as well as simplifying the problem enough to permit theoretic analysis of the algorithm. The class of input is still general enough to conform to the requirements of a number of applications.

An analytic visible surface algorithm for independent pixel processing

An algorithm is presented that solves the visible surface problem at each pixel independently. This allows motion blur and depth of field blurring to be integrated into the algorithm. It also allows parallel processing. The algorithm works on large numbers of polygons. An analytic Gaussian filter is used. The filter can be elongated or scaled differently for each polygon to adjust for its speed or distance from the focal plane. This is achieved by shrinking or scaling the polygon prior to solving the hidden surface problem so that blurring is correctly presented when objects obscure each other.

An Aid to Hidden Surface Removal in Real Time CGI Systems

One of the limiting factors in the development of real-time Computer Generated Image systems for displaying perspective colour scenes is finding a suitable solution to the hidden surface problem. This paper presents a solution to this problem, whereby spatial properties of a three-dimensional 'model' held in the Computer Generated Image system database are utilized in order to minimize hidden surface computations for producing moving perspective scenes. This solution is particularly acceptable to situations involving a fixed model and moving eye point. Often Computer Generated Image systems resort to processing individual surfaces from objects in the model to obtain display priority levels; the solution presented is based upon the use of preprocessed relative priority levels which only require complete objects to be given priority levels thus reducing real-time computation. Once an absolute display priority level for an object is found it will be shown that all surfaces forming that object have known display priority levels. Techniques used to obtain object display priority levels are discussed, together with background information concerning the hidden surface problem.

Hidden Line Elimination in Projected Grid Surfaces

Abstract : Hidden line and hidden surface problems are often simpler when restricted to special classes of objects. An example is the class of grid surfaces, i.e. graphs of bivariate functions represented by their values on a set of grid points. Projected grid surfaces have geometric properties which permit hidden line or hidden surface elimination to be done more easily then in the general case. These properties are discussed in this paper and an algorithm is given which exploits them. (Author)

On visible surface generation by a priori tree structures

This paper describes a new algorithm for solving the hidden surface (or line) problem, to more rapidly generate realistic images of 3-D scenes composed of polygons, and presents the development of theoretical foundations in the area as well as additional related algorithms. As in many applications the environment to be displayed consists of polygons many of whose relative geometric relations are static, we attempt to capitalize on this by preprocessing the environment's database so as to decrease the run-time computations required to generate a scene. This preprocessing is based on generating a “binary space partitioning” tree whose in order traversal of visibility priority at run-time will produce a linear order, dependent upon the viewing position, on (parts of) the polygons, which can then be used to easily solve the hidden surface problem. In the application where the entire environment is static with only the viewing-position changing, as is common in simulation, the results presented will be sufficient to solve completely the hidden surface problem.

Parallel processing techniques for hidden surface removal

Previous work in the hidden-surface problem has revealed two key concepts. First, the removal of non-visible surfaces is essentially a sorting problem. Second, some form of coherence is essential for the efficient solution of this problem. In order to provide real-time simulations, it is not only the amount of sorting which must be reduced, but the total time required for computation. One potentially economic strategy to attain this goal is the use of parallel processor systems. This approach implies that the computational time will no longer be dependent on the total amount of sorting, but more on the appropriate division of responsibility. This paper investigates two existing algorithmic approaches to the hidden-surface problem with a view towards their applicability to implementation on a parallel machine organization. In particular, the statistical results of a parallel processor implementation indicate the difficulties stemming from a loss of coherence and imply potentially important design criteria for a parallel configuration.

Hidden surface removal using polygon area sorting

A polygon hidden surface and hidden line removal algorithm is presented. The algorithm recursively subdivides the image into polygon shaped windows until the depth order within the window is found. Accuracy of the input data is preserved.The approach is based on a two-dimensional polygon clipper which is sufficiently general to clip a concave polygon with holes to the borders of a concave polygon with holes.A major advantage of the algorithm is that the polygon form of the output is the same as the polygon form of the input. This allows entering previously calculated images to the system for further processing. Shadow casting may then be performed by first producing a hidden surface removed view from the vantage point of the light source and then resubmitting these tagged polygons for hidden surface removal from the position of the observer. Planar surface detail also becomes easy to represent without increasing the complexity of the hidden surface problem. Translucency is also possible.Calculation times are primarily related to the visible complexity of the final image, but can range from a linear to an exponential relationship with the number of input polygons depending on the particular environment portrayed. To avoid excessive computation time, the implementation uses a screen area subdivision preprocessor to create several windows, each containing a specified number of polygons. The hidden surface algorithm is applied to each of these windows separately. This technique avoids the difficulties of subdividing by screen area down to the screen resolution level while maintaining the advantages of the polygon area sort method.

A Characterization of Ten Hidden-Surface Algorithms

Abstract : The paper asserts that the hidden-surface problem is mainly one of sorting. The various surfaces of an object to be shown in hidden-surface or hidden-line form must be sorted to find out which ones are visible at various places on the screen. Surfaces may be sorted by lateral position in the picture (XY), by depth (Z), or by other criteria. The paper shows that the order of sorting and the types of sorting used form differences among the existing hidden-surface algorithms. (Modified author abstract)