Clipping ( computer graphics ) - wikipedia Clipping ( computer graphics ) This article possibly contains original research. Please improve it by verifying the claims made and adding inline citations. Statements consisting only of original research should be removed. ( August 2015 ) This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. ( August 2015 ) Clipping, in the context of computer graphics, is a method to selectively enable or disable rendering operations within a defined region of interest. Mathematically, clipping can be described using the terminology of constructive geometry. A rendering algorithm only draws pixels in the intersection between the clip region and the scene model. Lines and surfaces outside the view volume ( aka. frustum ) are removed. Clip regions are commonly specified to improve render performance. A well - chosen clip allows the renderer to save time and energy by skipping calculations related to pixels that the user can not see. Pixels that will be drawn are said to be within the clip region. Pixels that will not be drawn are outside the clip region. More informally, pixels that will not be drawn are said to be `` clipped. '' Contents 1 Clipping in 2D graphics 2 Clipping in 3D graphics 2.1 Near clipping 2.2 Occlusion clipping ( Z - or depth clipping ) 3 Importance of clipping in video games 4 Algorithms 5 See also 6 Further reading 7 References Clipping in 2D graphics In two - dimensional graphics, a clip region may be defined so that pixels are only drawn within the boundaries of a window or frame. Clip regions can also be used to selectively control pixel rendering for aesthetic or artistic purposes. In many implementations, the final clip region is the composite ( or intersection ) of one or more application - defined shapes, as well as any system hardware constraints In one example application, consider an image editing program. A user application may render the image into a viewport. As the user zooms and scrolls to view a smaller portion of the image, the application can set a clip boundary so that pixels outside the viewport are not rendered. In addition, GUI widgets, overlays, and other windows or frames may obscure some pixels from the original image. In this sense, the clip region is the composite of the application - defined `` user clip '' and the `` device clip '' enforced by the system 's software and hardware implementation. Application software can take advantage of this clip information to save computation time, energy, and memory, avoiding work related to pixels that are n't visible. Clipping in 3D graphics A view frustum, with near - and far - clip planes. Only the shaded volume is rendered. In three - dimensional graphics, the terminology of clipping can be used to describe many related features. Typically, `` clipping '' refers to operations in the plane that work with rectangular shapes, and `` culling '' refers to more general methods to selectively process scene model elements. This terminology is not rigid, and exact usage varies among many sources. Scene model elements include geometric primitives : points or vertices ; line segments or edges ; polygons or faces ; and more abstract model objects such as curves, splines, surfaces, and even text. In complicated scene models, individual elements may be selectively disabled ( clipped ) for reasons including visibility within the viewport ( frustum culling ) ; orientation ( backface culling ), obscuration by other scene or model elements ( occlusion culling, depth - or `` z '' clipping ). Sophisticated algorithms exist to efficiently detect and perform such clipping. Many optimized clipping methods rely on specific hardware acceleration logic provided by a graphics processing unit ( GPU ). The concept of clipping can be extended to higher dimensionality using methods of abstract algebraic geometry. Near clipping Beyond projection of vertices & 2D clipping, near clipping is required to correctly rasterise 3D primitives ; this is because vertices may have been projected behind the eye. Near clipping ensures that all the vertices used have valid 2D coordinates. Together with far - clipping it also helps prevent overflow of depth - buffer values. Some early texture mapping hardware ( using forward texture mapping ) in video games suffered from complications associated with near clipping and UV coordinates. Occlusion clipping ( Z - or depth clipping ) Main articles : depth buffer and occlusion culling In 3D computer graphics, `` Z '' often refers to the depth axis in the system of coordinates centered at the viewport origin : `` Z '' is used interchangeably with `` depth '', and conceptually corresponds to the distance `` into the virtual screen. '' In this coordinate system, `` X '' and `` Y '' therefore refer to a conventional cartesian coordinate system laid out on the user 's screen or viewport. This viewport is defined by the geometry of the viewing frustum, and parameterizes the field of view. Z - clipping, or depth clipping, refers to techniques that selectively render certain scene objects based on their depth relative to the screen. Most graphics toolkits allow the programmer to specify a `` near '' and `` far '' clip depth, and only portions of objects between those two planes are displayed. A creative application programmer can use this method to render visualizations of the interior of a 3D object in the scene. For example, a medical imaging application could use this technique to render the organs inside a human body. A video game programmer can use clipping information to accelerate game logic. For example, a tall wall or building that occludes other game entities can save GPU time that would otherwise be spent transforming and texturing items in the rear areas of the scene ; and a tightly integrated software program can use this same information to save CPU time by optimizing out game logic for objects that are n't seen by the player. Importance of clipping in video games This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. ( August 2015 ) Good clipping strategy is important in the development of video games in order to maximize the game 's frame rate and visual quality. Despite GPU chips that are faster every year, it remains computationally expensive to transform, texture, and shade polygons, especially with the multiple texture and shading passes common today. Hence, game developers must live within a certain `` budget '' of polygons that can be drawn each video frame. To maximize the game 's visual quality, developers prefer to let aesthetic choices, rather than hardware limitation, dictate the polygon budget. Optimizations that save performance therefore or take advantage of graphics pipeline acceleration improve the player 's experience. Clipping optimization can speed up the rendering of the current scene, economizing the use of renderer time and memory within the hardware 's capability. Programmers often devise clever heuristics to speed up the clipper, as it is sometimes computationally prohibitive to use line casting or ray tracing to determine with 100 % accuracy which polygons are not within the camera 's field of view. Spatially aware data structures, such as octrees, R * trees, and bounding volume hierarchies can be used to partition scenes into rendered and non-rendered areas ( allowing the renderer to reject or accept entire tree nodes where appropriate ). Occlusion optimizations based on viewpoint geometry may introduce artifacts if the scene contains reflective surfaces. A common technique, reflection mapping, can optionally use existing occlusion estimates from the viewpoint of the main view frustum ; or, if performance allows, a new occlusion map can be computed from a separate camera position. For historical reasons, some video games used collision detection optimizations with identical logic and hardware acceleration as the occlusion test. As a result, non-specialists have incorrectly used the term `` clip '' ( and its antonym `` no clipping '' ) to refer to collision detection. Algorithms Line clipping algorithms : Cohen -- Sutherland Liang -- Barsky Fast - clipping Cyrus -- Beck Nicholl -- Lee -- Nicholl Skala O ( lg N ) Algorithm Polygon clipping algorithms : Greiner - Hormann Sutherland -- Hodgman Weiler -- Atherton Vatti Rendering Methodologies Painter 's algorithm See also Boolean operations on polygons Bounding volume Clip Space Hidden surface determination Pruning ( decision trees ) Visibility ( geometry ) Further reading GPU Gems : Efficient Occlusion Culling Clipping in Java AWT : java. awt. Graphics. clipRect JavaDoc Clipping in UIKit for iOS ( 2D ) : UIRectClip Clipping in SceneKit for iOS ( 3D ) : SCNCamera ( Adjusting Camera Perspective ) Clipping in OpenGL : OpenGL Technical FAQs : Clipping, Culling, and Visibility Testing References Jump up ^ Bertoline, Gary ; Wiebe, Eric ( 2002 ). Fundamentals of Graphics Communication ( 3rd ed. ). McGraw - Hill. p. G - 3. ISBN 0 - 07 - 232209 - 8. Retrieved 2015 - 01 - 04. ^ Jump up to : `` java. awt. Graphics. clipRect ''. Oracle. 2014. ^ Jump up to : Sekulic, Dean ( 2004 ). `` Efficient Occlusion Culling ''. GPU Gems. Pearson. Retrieved 2015 - 01 - 02. Jump up ^ Paul Martz ( 2001 ). `` Clipping, Culling, and Visibility Testing ''. OpenGL.org. Retrieved 2015 - 01 - 02. Retrieved from `` https://en.wikipedia.org/w/index.php?title=Clipping_(computer_graphics)&oldid=842246712 '' Categories : Clipping ( computer graphics ) Computer graphics Computer graphic artifacts Hidden categories : Articles that may contain original research from August 2015 All articles that may contain original research Articles needing additional references from August 2015 All articles needing additional references Talk Contents About Wikipedia Deutsch Español Français Italiano Nederlands Polski Русский Српски / srpski Українська Edit links This page was last edited on 21 May 2018, at 06 : 14. Text is available under the Creative Commons Attribution - ShareAlike License ; additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia ® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization. About Wikipedia

Question: what do you mean by clipping in computer graphics
Answer: a method to selectively enable or disable rendering operations within a defined region of interest